@applitools/core 3.9.1 → 3.10.1

package/dist/classic/check.js

@@ -25,81 +25,78 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeCheck = void 0;
 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_renderers_1 = require("../automation/utils/uniquify-renderers");
+const extract_renderer_key_1 = require("../automation/utils/extract-renderer-key");
+const abort_error_1 = require("../errors/abort-error");
 const utils = __importStar(require("@applitools/utils"));
-function makeCheck({ eyes, target: defaultTarget, spec, logger: mainLogger, }) {
+function makeCheck({ eyes, target: defaultTarget, renderers: defaultRenderers = [], spec, signal, logger: mainLogger, }) {
     return async function check({ target = defaultTarget, settings = {}, logger = mainLogger, } = {}) {
-        var _a, _b, _c, _d;
+        var _a, _b;
         logger = logger.extend(mainLogger);
         logger.log('Command "check" is called with settings', settings);
         if (!target)
             throw new Error('Method was called with no target');
-        const baseEyes = await eyes.getBaseEyes();
-        if (!(0, driver_1.isDriver)(target, spec)) {
-            return (await Promise.all(baseEyes.map(baseEyes => baseEyes.check({ target, settings: settings, logger })))).flat();
+        if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+            logger.warn('Command "check" was called after test was already aborted');
+            throw new abort_error_1.AbortError('Command "check" was called after test was already aborted');
         }
-        const driver = await (0, driver_1.makeDriver)({ spec, driver: target, reset: target === defaultTarget, logger });
-        const environment = await driver.getEnvironment();
-        await driver.currentContext.setScrollingElement((_a = settings.scrollRootElement) !== null && _a !== void 0 ? _a : null);
-        if (settings.lazyLoad && environment.isWeb) {
-            if (settings.lazyLoad) {
+        const uniqueRenderers = (0, uniquify_renderers_1.uniquifyRenderers)((_a = settings.renderers) !== null && _a !== void 0 ? _a : defaultRenderers);
+        const baseTargets = [];
+        const baseSettings = [];
+        const transformedRenderers = [];
+        if ((0, driver_1.isDriver)(target, spec)) {
+            const 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 environment = await driver.getEnvironment();
+            uniqueRenderers.forEach(renderer => {
+                var _a, _b;
+                var _c, _d;
+                if (utils.types.has(renderer, 'iosDeviceInfo')) {
+                    (_a = (_c = renderer.iosDeviceInfo).version) !== null && _a !== void 0 ? _a : (_c.version = environment.platformVersion);
+                }
+                else if (utils.types.has(renderer, 'androidDeviceInfo')) {
+                    (_b = (_d = renderer.androidDeviceInfo).version) !== null && _b !== void 0 ? _b : (_d.version = environment.platformVersion);
+                }
+                return renderer;
+            });
+            if (settings.lazyLoad && environment.isWeb) {
                 await (0, wait_for_lazy_load_1.waitForLazyLoad)({
                     context: driver.currentContext,
                     settings: settings.lazyLoad !== true ? settings.lazyLoad : {},
                     logger,
                 });
             }
-        }
-        // TODO it actually could be different per eyes
-        const shouldRunOnce = true;
-        const finishAt = Date.now() + ((_b = settings.retryTimeout) !== null && _b !== void 0 ? _b : 0);
-        let baseTarget;
-        let baseSettings;
-        let results;
-        const { elementReferencesToCalculate, getBaseCheckSettings } = (0, to_base_check_settings_1.toBaseCheckSettings)({ settings });
-        do {
-            if (environment.isWeb ||
-                !environment.isApplitoolsLib ||
-                settings.webview ||
-                settings.screenshotMode === 'default') {
-                const screenshot = await (0, take_screenshot_1.takeScreenshot)({
+            const { elementReferencesToCalculate, getBaseCheckSettings } = (0, to_base_check_settings_1.toBaseCheckSettings)({ settings });
+            if (environment.isWeb || !environment.isApplitoolsLib || settings.screenshotMode === 'default') {
+                const screenshots = await (0, take_screenshots_1.takeScreenshots)({
                     driver,
-                    settings: { ...settings, regionsToCalculate: elementReferencesToCalculate },
+                    settings: {
+                        ...settings,
+                        renderers: uniqueRenderers,
+                        regionsToCalculate: elementReferencesToCalculate,
+                        calculateView: !!settings.pageId,
+                        domSettings: settings.sendDom ? { proxy: eyes.test.eyesServer.proxy } : undefined,
+                    },
                     logger,
                 });
-                baseTarget = {
-                    name: await driver.getTitle(),
-                    source: await driver.getUrl(),
-                    image: await screenshot.image.toPng(),
-                    locationInViewport: utils.geometry.location(screenshot.region),
-                    isTransformed: true,
-                };
-                baseSettings = getBaseCheckSettings({ calculatedRegions: screenshot.calculatedRegions });
-                if (environment.isWeb && settings.sendDom) {
-                    if (settings.fully)
-                        await ((_c = screenshot.scrollingElement) === null || _c === void 0 ? void 0 : _c.setAttribute('data-applitools-scroll', 'true'));
-                    else
-                        await ((_d = screenshot.element) === null || _d === void 0 ? void 0 : _d.setAttribute('data-applitools-scroll', 'true'));
-                    baseTarget.dom = await (0, take_dom_capture_1.takeDomCapture)({ driver, settings: { proxy: eyes.test.eyesServer.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();
-                }
-                await screenshot.restoreState();
+                transformedRenderers.push(...uniqueRenderers);
+                screenshots.forEach(({ calculatedRegions, ...baseTarget }) => {
+                    baseTargets.push(baseTarget);
+                    baseSettings.push(getBaseCheckSettings({ calculatedRegions }));
+                });
             }
             else {
-                const nmlClient = await eyes.core.getNMLClient({ config: eyes.test.eyesServer, driver, logger });
-                const screenshot = await nmlClient.takeScreenshot({
+                const nmlClient = await eyes.core.getNMLClient({
+                    driver,
+                    settings: { ...eyes.test.eyesServer, renderEnvironmentsUrl: eyes.test.renderEnvironmentsUrl },
+                    logger,
+                });
+                const screenshots = await nmlClient.takeScreenshots({
                     settings: {
-                        name: settings.name,
+                        renderers: uniqueRenderers,
                         fully: settings.fully,
                         stitchMode: settings.stitchMode,
                         hideScrollbars: settings.hideScrollbars,
@@ -108,20 +105,68 @@ function makeCheck({ eyes, target: defaultTarget, spec, logger: mainLogger, }) {
                         waitBeforeCapture: settings.waitBeforeCapture,
                         waitBetweenStitches: settings.waitBetweenStitches,
                         lazyLoad: settings.lazyLoad,
+                        name: settings.name,
                     },
                     logger,
                 });
-                baseTarget = { image: screenshot.image, isTransformed: true };
-                baseSettings = getBaseCheckSettings({ calculatedRegions: [] });
+                screenshots.forEach(({ calculatedRegions: _calculatedRegions, renderEnvironment, ...baseTarget }) => {
+                    transformedRenderers.push({ environment: renderEnvironment });
+                    baseTargets.push({ ...baseTarget, isTransformed: true });
+                    baseSettings.push(getBaseCheckSettings({ calculatedRegions: [] }));
+                });
             }
-            baseSettings.ignoreMismatch = !shouldRunOnce;
-            results = (await Promise.all(baseEyes.map(baseEyes => baseEyes.check({ target: baseTarget, settings: baseSettings, logger })))).flat();
-        } while (!shouldRunOnce && !results.some(result => result.asExpected) && Date.now() < finishAt);
-        if (!shouldRunOnce && !results.some(result => result.asExpected)) {
-            baseSettings.ignoreMismatch = false;
-            results = (await Promise.all(baseEyes.map(baseEyes => baseEyes.check({ target: baseTarget, settings: baseSettings, logger })))).flat();
         }
-        return results;
+        else {
+            transformedRenderers.push(...uniqueRenderers);
+            baseTargets.push(target);
+            baseSettings.push(settings);
+        }
+        const promises = transformedRenderers.map(async (renderer, index) => {
+            const rendererLogger = logger.extend({ tags: [`renderer-${utils.general.shortid()}`] });
+            try {
+                if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                    rendererLogger.warn('Command "check" was aborted before checking');
+                    throw new abort_error_1.AbortError('Command "check" was aborted before checking');
+                }
+                const baseEyes = await eyes.getBaseEyes({ settings: { renderer }, logger: rendererLogger });
+                try {
+                    if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                        rendererLogger.warn('Command "check" was aborted before checking');
+                        throw new abort_error_1.AbortError('Command "check" was aborted before checking');
+                    }
+                    else if (!baseEyes.running) {
+                        rendererLogger.warn(`Check on environment with id "${baseEyes.test.renderEnvironmentId}" was aborted during one of the previous steps`);
+                        throw new abort_error_1.AbortError(`Check on environment with id "${baseEyes.test.renderEnvironmentId}" was aborted during one of the previous steps`);
+                    }
+                    await baseEyes.check({
+                        target: baseTargets[index],
+                        settings: baseSettings[index],
+                        logger: rendererLogger,
+                    });
+                }
+                catch (error) {
+                    rendererLogger.error(`Check on environment with id "${baseEyes.test.renderEnvironmentId}" failed due to an error`, error);
+                    if (baseEyes.running && !(signal === null || signal === void 0 ? void 0 : signal.aborted))
+                        await baseEyes.abort({ logger: rendererLogger });
+                    error.info = { eyes: baseEyes };
+                    throw error;
+                }
+            }
+            catch (error) {
+                rendererLogger.error(`Check with id ${renderer.id} failed before checking started due to an error`, error);
+                error.info = { ...error.info, userTestId: eyes.test.userTestId, renderer };
+                throw error;
+            }
+        });
+        transformedRenderers.forEach((renderer, index) => {
+            const key = (0, extract_renderer_key_1.extractRendererKey)(renderer);
+            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.makeCheck = makeCheck;

package/dist/classic/core.js

@@ -34,21 +34,21 @@ const extract_text_1 = require("../automation/extract-text");
 const get_nml_client_1 = require("../automation/get-nml-client");
 const open_eyes_1 = require("./open-eyes");
 const utils = __importStar(require("@applitools/utils"));
-function makeCore({ spec, clients, base, agentId = 'core-classic', cwd = process.cwd(), logger: defaultLogger, }) {
+function makeCore({ spec, clients, base, concurrency, agentId = 'core-classic', cwd = process.cwd(), logger: defaultLogger, }) {
     const logger = (0, logger_1.makeLogger)({ logger: defaultLogger, format: { label: 'core-classic' } });
     logger.log(`Core classic is initialized ${base ? 'with' : 'without'} custom base core`);
-    base !== null && base !== void 0 ? base : (base = (0, core_base_1.makeCore)({ agentId, cwd, logger }));
+    base !== null && base !== void 0 ? base : (base = (0, core_base_1.makeCore)({ concurrency, agentId, cwd, logger }));
     return utils.general.extend(base, core => {
         return {
             type: 'classic',
             base: base,
             getViewportSize: spec && (0, get_viewport_size_1.makeGetViewportSize)({ spec, logger }),
             setViewportSize: spec && (0, set_viewport_size_1.makeSetViewportSize)({ spec, logger }),
-            getNMLClient: (0, get_nml_client_1.makeGetNMLClient)({ client: clients === null || clients === void 0 ? void 0 : clients.nml, logger }),
-            openEyes: (0, open_eyes_1.makeOpenEyes)({ spec, core, logger }),
             locate: (0, locate_1.makeLocate)({ spec, core, logger }),
             locateText: (0, locate_text_1.makeLocateText)({ spec, core, logger }),
             extractText: (0, extract_text_1.makeExtractText)({ spec, core, logger }),
+            getNMLClient: (0, get_nml_client_1.makeGetNMLClient)({ client: clients === null || clients === void 0 ? void 0 : clients.nml, logger }),
+            openEyes: (0, open_eyes_1.makeOpenEyes)({ spec, core, logger }),
         };
     });
 }

package/dist/classic/get-base-eyes.js

@@ -24,17 +24,40 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeGetBaseEyes = void 0;
+const extract_renderer_key_1 = require("../automation/utils/extract-renderer-key");
 const utils = __importStar(require("@applitools/utils"));
-function makeGetBaseEyes({ settings, eyes, base, logger: mainLogger }) {
-    const getBaseEyesWithCache = utils.general.cachify(getBaseEyes, () => 'default');
-    if (base)
-        getBaseEyesWithCache.setCachedValue('default', Promise.resolve(base));
+function makeGetBaseEyes({ settings: defaultSettings, eyes, logger: mainLogger, }) {
+    const getBaseEyesWithCache = utils.general.wrap(getBaseEyes, (getBaseEyes, options) => {
+        const key = (0, extract_renderer_key_1.extractRendererKey)(options.settings.renderer);
+        let item = eyes.storage.get(key);
+        if (!item) {
+            item = { eyes: utils.promises.makeControlledPromise(), jobs: [] };
+            eyes.storage.set(key, item);
+        }
+        if (!item.eyes.settled)
+            item.eyes.resolve(getBaseEyes(options));
+        return item.eyes;
+    });
     return getBaseEyesWithCache;
-    async function getBaseEyes({ logger = mainLogger } = {}) {
+    async function getBaseEyes({ settings, logger = mainLogger, }) {
         logger = logger.extend(mainLogger);
         logger.log(`Command "getBaseEyes" is called with settings`, settings);
-        const baseEyes = await eyes.core.base.openEyes({ settings, logger });
-        return [baseEyes];
+        let environment;
+        if (utils.types.has(settings.renderer, 'environment')) {
+            environment = settings.renderer.environment;
+        }
+        else {
+            // NOTE: ios and android handled by nml-client
+            // TODO: chrome emulation, desktop
+            environment = { renderer: settings.renderer };
+        }
+        return eyes.core.base.openEyes({
+            settings: {
+                ...defaultSettings,
+                environment: { ...defaultSettings.environment, ...environment, properties: settings.renderer.properties },
+            },
+            logger,
+        });
     }
 }
 exports.makeGetBaseEyes = makeGetBaseEyes;

package/dist/classic/open-eyes.js

@@ -28,71 +28,57 @@ const driver_1 = require("@applitools/driver");
 const get_base_eyes_1 = require("./get-base-eyes");
 const check_1 = require("./check");
 const check_and_close_1 = require("./check-and-close");
-const close_1 = require("./close");
-const abort_1 = require("./abort");
+const close_1 = require("../automation/close");
+const abort_1 = require("../automation/abort");
+const get_results_1 = require("../automation/get-results");
+const extract_default_renderers_1 = require("./utils/extract-default-renderers");
+const abort_controller_1 = require("abort-controller");
 const utils = __importStar(require("@applitools/utils"));
 function makeOpenEyes({ core, spec, logger: mainLogger }) {
-    return async function openEyes({ target, settings, base, logger = mainLogger, }) {
+    return async function openEyes({ target, settings, storage = new Map(), logger = mainLogger, }) {
         var _a, _b, _c;
-        var _d;
         logger = logger.extend(mainLogger);
-        logger.log(`Command "openEyes" is called with ${target ? 'default driver and' : ''}`, ...(settings ? ['settings', settings] : []), base ? 'predefined eyes' : '');
+        logger.log(`Command "openEyes" is called with ${target ? 'default driver' : ''}`, ...(settings ? ['and settings', settings] : []), storage.size > 0 ? 'and default eyes storage' : '');
         const driver = target && (await (0, driver_1.makeDriver)({ spec, driver: target, logger, customConfig: settings }));
-        if (driver && !base) {
+        if (driver && storage.size === 0) {
             const environment = await driver.getEnvironment();
-            const currentContext = driver.currentContext;
-            (_a = settings.environment) !== null && _a !== void 0 ? _a : (settings.environment = {});
-            if (environment.isEC) {
-                settings.environment.ecSessionId = (await driver.getSessionId());
-            }
-            if (environment.isWeb) {
-                (_b = (_d = settings.environment).userAgent) !== null && _b !== void 0 ? _b : (_d.userAgent = await driver.getUserAgentLegacy());
-            }
-            if (!settings.environment.deviceName && environment.deviceName) {
-                settings.environment.deviceName = environment.deviceName;
-            }
-            if (!settings.environment.os) {
-                if (environment.isNative && environment.platformName) {
-                    settings.environment.os = environment.platformName;
-                    if (!settings.keepPlatformNameAsIs) {
-                        if (/^android/i.test(settings.environment.os)) {
-                            settings.environment.os = `Android${settings.environment.os.slice(7)}`;
-                        }
-                        if (/^ios/i.test(settings.environment.os)) {
-                            settings.environment.os = `iOS${settings.environment.os.slice(3)}`;
-                        }
-                    }
-                    if (environment.platformVersion) {
-                        settings.environment.os += ` ${environment.platformVersion}`;
-                    }
-                }
-                else if (environment.isReliable &&
-                    environment.isChromium &&
-                    ((environment.isWindows && Number.parseInt(environment.browserVersion) >= 107) ||
-                        (environment.isMac && Number.parseInt(environment.browserVersion) >= 90))) {
-                    settings.environment.os = `${environment.platformName} ${(_c = environment.platformVersion) !== null && _c !== void 0 ? _c : ''}`.trim();
-                }
-            }
-            if (!settings.environment.viewportSize || environment.isMobile) {
-                const viewport = await driver.getViewport();
-                const size = await driver.getViewportSize();
-                settings.environment.viewportSize = utils.geometry.scale(size, viewport.viewportScale);
-            }
-            else {
+            if (((_a = settings.environment) === null || _a === void 0 ? void 0 : _a.viewportSize) && !environment.isMobile) {
                 await driver.setViewportSize(settings.environment.viewportSize);
             }
-            await currentContext.focus();
+            (_b = settings.environment) !== null && _b !== void 0 ? _b : (settings.environment = {});
+            if (environment.isEC) {
+                settings.environment.ecSessionId = (_c = (await driver.getSessionId())) !== null && _c !== void 0 ? _c : undefined;
+            }
         }
-        base !== null && base !== void 0 ? base : (base = [await core.base.openEyes({ settings, logger })]);
-        return utils.general.extend(base[0], eyes => ({
-            type: 'classic',
-            core,
-            getBaseEyes: (0, get_base_eyes_1.makeGetBaseEyes)({ settings, eyes, base, logger }),
-            check: (0, check_1.makeCheck)({ eyes, target: driver, spec, logger }),
-            checkAndClose: (0, check_and_close_1.makeCheckAndClose)({ eyes, target: driver, spec, logger }),
-            close: (0, close_1.makeClose)({ eyes, target: driver, spec, logger }),
-            abort: (0, abort_1.makeAbort)({ eyes, target: driver, spec, logger }),
-        }));
+        const renderers = await (0, extract_default_renderers_1.extractDefaultRenderers)({ driver, settings });
+        const controller = new abort_controller_1.AbortController();
+        const account = await core.getAccountInfo({ settings, logger });
+        return utils.general.extend({}, eyes => {
+            var _a;
+            return {
+                type: 'classic',
+                core,
+                test: {
+                    userTestId: settings.userTestId,
+                    batchId: (_a = settings.batch) === null || _a === void 0 ? void 0 : _a.id,
+                    keepBatchOpen: settings.keepBatchOpen,
+                    eyesServer: account.eyesServer,
+                    ufgServer: account.ufgServer,
+                    uploadUrl: account.uploadUrl,
+                    stitchingServiceUrl: account.stitchingServiceUrl,
+                    renderEnvironmentsUrl: account.renderEnvironmentsUrl,
+                    account,
+                },
+                running: true,
+                storage,
+                getBaseEyes: (0, get_base_eyes_1.makeGetBaseEyes)({ settings, eyes, logger }),
+                check: (0, check_1.makeCheck)({ eyes, target: driver, renderers, spec, signal: controller.signal, logger }),
+                checkAndClose: (0, check_and_close_1.makeCheckAndClose)({ eyes, target: driver, renderers, spec, signal: controller.signal, logger }),
+                close: (0, close_1.makeClose)({ eyes, target: driver, renderers, logger }),
+                abort: (0, abort_1.makeAbort)({ eyes, target: driver, renderers, spec, controller, logger }),
+                getResults: (0, get_results_1.makeGetResults)({ eyes, logger }),
+            };
+        });
     };
 }
 exports.makeOpenEyes = makeOpenEyes;

package/dist/classic/utils/extract-default-renderers.js

@@ -0,0 +1,72 @@
+"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.extractDefaultRenderers = void 0;
+const utils = __importStar(require("@applitools/utils"));
+async function extractDefaultRenderers({ driver, settings, }) {
+    var _a, _b, _c;
+    const renderer = { environment: {} };
+    if (!driver) {
+        renderer.environment = (_a = settings === null || settings === void 0 ? void 0 : settings.environment) !== null && _a !== void 0 ? _a : {};
+        return [renderer];
+    }
+    const currentContext = driver.currentContext;
+    try {
+        const environment = await driver.getEnvironment();
+        const viewport = await driver.getViewport();
+        const size = await driver.getViewportSize();
+        renderer.environment.viewportSize = utils.geometry.scale(size, viewport.viewportScale);
+        if (environment.isEC)
+            renderer.environment.ecSessionId = (_b = (await driver.getSessionId())) !== null && _b !== void 0 ? _b : undefined;
+        if (environment.isWeb)
+            renderer.environment.userAgent = await driver.getUserAgentLegacy();
+        if (environment.deviceName)
+            renderer.environment.deviceName = environment.deviceName;
+        if (environment.isNative && environment.platformName) {
+            renderer.environment.os = environment.platformName;
+            if (environment.platformVersion)
+                renderer.environment.os += ` ${environment.platformVersion}`;
+            if (!(settings === null || settings === void 0 ? void 0 : settings.keepPlatformNameAsIs)) {
+                if (/^android/i.test(renderer.environment.os)) {
+                    renderer.environment.os = `Android${renderer.environment.os.slice(7)}`;
+                }
+                if (/^ios/i.test(renderer.environment.os)) {
+                    renderer.environment.os = `iOS${renderer.environment.os.slice(3)}`;
+                }
+            }
+        }
+        else if (environment.isReliable &&
+            environment.isChromium &&
+            ((environment.isWindows && Number.parseInt(environment.browserVersion) >= 107) ||
+                (environment.isMac && Number.parseInt(environment.browserVersion) >= 90))) {
+            renderer.environment.os = `${environment.platformName} ${(_c = environment.platformVersion) !== null && _c !== void 0 ? _c : ''}`.trim();
+        }
+        return [renderer];
+    }
+    finally {
+        await currentContext.focus();
+    }
+}
+exports.extractDefaultRenderers = extractDefaultRenderers;

package/dist/classic/utils/take-screenshots.js

@@ -0,0 +1,60 @@
+"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.takeScreenshots = void 0;
+const take_dom_capture_1 = require("./take-dom-capture");
+const take_screenshot_1 = require("../../automation/utils/take-screenshot");
+const utils = __importStar(require("@applitools/utils"));
+async function takeScreenshots({ driver, settings, logger, }) {
+    var _a, _b;
+    const screenshot = await (0, take_screenshot_1.takeScreenshot)({ driver, settings, logger });
+    const baseTarget = {
+        name: await driver.getTitle(),
+        source: await driver.getUrl(),
+        image: await screenshot.image.toPng(),
+        locationInViewport: utils.geometry.location(screenshot.region),
+        calculatedRegions: screenshot.calculatedRegions,
+        isTransformed: true,
+    };
+    const environment = await driver.getEnvironment();
+    if (environment.isWeb && settings.domSettings) {
+        if (settings.fully)
+            await ((_a = screenshot.scrollingElement) === null || _a === void 0 ? void 0 : _a.setAttribute('data-applitools-scroll', 'true'));
+        else
+            await ((_b = screenshot.element) === null || _b === void 0 ? void 0 : _b.setAttribute('data-applitools-scroll', 'true'));
+        baseTarget.dom = await (0, take_dom_capture_1.takeDomCapture)({ driver, settings: settings.domSettings, logger }).catch(() => undefined);
+    }
+    if (settings.calculateView) {
+        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();
+    }
+    await screenshot.restoreState();
+    return new Array(settings.renderers.length).fill(baseTarget);
+}
+exports.takeScreenshots = takeScreenshots;

package/dist/close.js

@@ -25,13 +25,16 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeClose = void 0;
 const utils = __importStar(require("@applitools/utils"));
-function makeClose({ eyes, logger: mainLogger, }) {
+function makeClose({ eyes, renderers: defaultRenderers, logger: mainLogger, }) {
     return async function close({ settings, config, logger = mainLogger, } = {}) {
-        var _a;
+        var _a, _b;
         logger = logger.extend(mainLogger, { tags: [`close-${utils.general.shortid()}`] });
+        const typedEyes = await eyes.getTypedEyes({ logger });
         settings = { ...config === null || config === void 0 ? void 0 : config.close, ...settings };
         (_a = settings.updateBaselineIfNew) !== null && _a !== void 0 ? _a : (settings.updateBaselineIfNew = true);
-        const typedEyes = await eyes.getTypedEyes({ logger });
+        if (typedEyes.type === 'classic' && !utils.types.isEmpty(defaultRenderers)) {
+            (_b = settings.renderers) !== null && _b !== void 0 ? _b : (settings.renderers = defaultRenderers);
+        }
         await typedEyes.close({ settings, logger });
     };
 }

package/dist/core.js

@@ -40,7 +40,7 @@ const close_batch_1 = require("./close-batch");
 const delete_test_1 = require("./delete-test");
 const extract_environment_1 = require("./utils/extract-environment");
 const utils = __importStar(require("@applitools/utils"));
-function makeCore({ spec, concurrency, base: defaultBase, environment: defaultEnvironment, agentId = 'core', cwd = process.cwd(), logger: defaultLogger, } = {}) {
+function makeCore({ spec, clients, concurrency, base: defaultBase, environment: defaultEnvironment, agentId = 'core', cwd = process.cwd(), logger: defaultLogger, } = {}) {
     const logger = (0, logger_1.makeLogger)({ logger: defaultLogger, format: { label: 'core' } });
     const environment = (0, extract_environment_1.extractEnvironment)(defaultEnvironment);
     logger.log(`Core is initialized ${defaultBase ? 'with' : 'without'} custom base core and environment`, environment);
@@ -50,14 +50,14 @@ function makeCore({ spec, concurrency, base: defaultBase, environment: defaultEn
             base: base,
             getViewportSize: spec && (0, get_viewport_size_1.makeGetViewportSize)({ spec, logger }),
             setViewportSize: spec && (0, set_viewport_size_1.makeSetViewportSize)({ spec, logger }),
-            getNMLClient: (0, get_nml_client_1.makeGetNMLClient)({ logger }),
+            getNMLClient: (0, get_nml_client_1.makeGetNMLClient)({ client: clients === null || clients === void 0 ? void 0 : clients.nml, logger }),
             getECClient: (0, get_ec_client_1.makeGetECClient)({ logger }),
             getAccountInfo: (0, get_account_info_1.makeGetAccountInfo)({ core, logger }),
-            makeManager: (0, make_manager_1.makeMakeManager)({ spec, concurrency, core, base: defaultBase, agentId, environment, logger }),
+            makeManager: (0, make_manager_1.makeMakeManager)({ spec, clients, concurrency, core, base: defaultBase, agentId, environment, logger }),
             locate: (0, locate_1.makeLocate)({ spec, core, logger }),
             locateText: (0, locate_text_1.makeLocateText)({ spec, core, logger }),
             extractText: (0, extract_text_1.makeExtractText)({ spec, core, logger }),
-            openEyes: (0, open_eyes_1.makeOpenEyes)({ spec, core, concurrency, environment, logger }),
+            openEyes: (0, open_eyes_1.makeOpenEyes)({ spec, clients, core, concurrency, environment, logger }),
             closeBatch: (0, close_batch_1.makeCloseBatch)({ core, logger }),
             deleteTest: (0, delete_test_1.makeDeleteTest)({ core, logger }),
         };

package/dist/get-typed-eyes.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeGetTypedEyes = void 0;
 function makeGetTypedEyes({ type: defaultType, settings: defaultSettings, target, cores, logger: mainLogger, }) {
     let eyes;
-    return async function getTypedEyes({ type = defaultType, settings, logger = mainLogger, } = {}) {
+    return async function getTypedEyes({ type = defaultType, logger = mainLogger, } = {}) {
         logger = logger.extend(mainLogger);
         if (!eyes) {
             eyes = await cores[type].openEyes({ target, settings: defaultSettings, logger });
@@ -13,13 +13,11 @@ function makeGetTypedEyes({ type: defaultType, settings: defaultSettings, target
             return eyes;
         }
         else if (type === 'ufg') {
-            const base = await eyes.getBaseEyes({ logger });
-            const typedEyes = await cores.ufg.openEyes({ target, settings: defaultSettings, base, logger });
+            const typedEyes = await cores.ufg.openEyes({ target, settings: defaultSettings, storage: eyes.storage, logger });
             return typedEyes;
         }
         else {
-            const base = (await Promise.all(settings.map(settings => eyes.getBaseEyes({ settings, logger })))).flat();
-            const typedEyes = await cores.classic.openEyes({ target, settings: defaultSettings, base, logger });
+            const typedEyes = await cores.classic.openEyes({ target, settings: defaultSettings, storage: eyes.storage, logger });
             return typedEyes;
         }
     };

package/dist/make-manager.js

@@ -30,7 +30,7 @@ const core_2 = require("./ufg/core");
 const open_eyes_1 = require("./open-eyes");
 const get_manager_results_1 = require("./get-manager-results");
 const utils = __importStar(require("@applitools/utils"));
-function makeMakeManager({ spec, concurrency: defaultConcurrency = utils.general.getEnvValue('CONCURRENCY', 'number'), core, base, agentId: defaultAgentId, environment, cwd = process.cwd(), logger: mainLogger, }) {
+function makeMakeManager({ spec, clients, concurrency: defaultConcurrency = utils.general.getEnvValue('CONCURRENCY', 'number'), core, base, agentId: defaultAgentId, environment, cwd = process.cwd(), logger: mainLogger, }) {
     return async function makeManager({ type = 'classic', settings, logger = mainLogger, } = {}) {
         var _a, _b, _c, _d, _e;
         var _f;
@@ -48,7 +48,7 @@ function makeMakeManager({ spec, concurrency: defaultConcurrency = utils.general
         };
         const storage = [];
         return {
-            openEyes: utils.general.wrap((0, open_eyes_1.makeOpenEyes)({ type, batch: settings.batch, spec, core, cores, environment, logger }), async (openEyes, options) => {
+            openEyes: utils.general.wrap((0, open_eyes_1.makeOpenEyes)({ type, clients, batch: settings.batch, spec, core, cores, environment, logger }), async (openEyes, options) => {
                 const eyes = await openEyes(options);
                 storage.push(eyes);
                 return eyes;