@applitools/core 4.74.2 → 4.75.0

package/dist/classic/check.js

@@ -1,43 +1,14 @@
 "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;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeCheck = void 0;
-const nml_client_1 = require("@applitools/nml-client");
 const driver_1 = require("@applitools/driver");
-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 tasks_1 = require("../tasks");
+const steps_1 = require("../tasks/classic/steps");
+const capture_1 = require("./utils/capture");
 const abort_error_1 = require("../errors/abort-error");
-const chalk_1 = __importDefault(require("chalk"));
-const utils = __importStar(require("@applitools/utils"));
-const lang = __importStar(require("../lang"));
+const ABORTED = 'Command "check" was aborted before checking';
 function makeCheck({ eyes, target: defaultTarget, environments: defaultEnvironments = [], spec, signal, logger: mainLogger, }) {
     return async function check({ target = defaultTarget, settings = {}, logger = mainLogger, } = {}) {
         var _a;
@@ -52,335 +23,95 @@ function makeCheck({ eyes, target: defaultTarget, environments: defaultEnvironme
             throw new abort_error_1.AbortError('Command "check" was called after test was already aborted');
         }
         const uniqueEnvironments = (0, uniquify_environments_1.uniquifyEnvironments)((_a = settings.environments) !== null && _a !== void 0 ? _a : defaultEnvironments);
-        let driver = undefined;
-        if ((0, driver_1.isDriver)(target, spec)) {
-            driver = await (0, driver_1.makeDriver)({ spec, driver: target, reset: target === defaultTarget, logger });
-            if (settings.matchTimeout) {
-                // when match timeout is set, retry checking until it passes or timeout is reached. This will stall the client test execution until it passes or timeout is reached to prevent the test from continuing and changing the state of the app
-                logger.log(`Match timeout is set to ${settings.matchTimeout}ms - will retry checking until it passes or timeout is reached`);
-                const start = Date.now();
-                const environmentLogger = logger.extend({ tags: [`environment-${utils.general.shortid()}`] });
-                // this getter actually open the eyes session if it's not already open
-                const baseEyes = await Promise.all(uniqueEnvironments.map(environment => getBaseEyes({ environment, driver, logger: environmentLogger })));
-                // if the test is new for any of the environments, we wait for the page to stabaliize before starting the checks. This should prevent us from creating a baseline with a loading spinner or something similar
-                if (baseEyes.map(baseEye => baseEye.test.isNew).some(isNew => isNew)) {
-                    await new Promise(resolve => setTimeout(resolve, settings.matchTimeout));
-                }
-                let asExpected = false, retries = 0;
-                do {
-                    retries++;
-                    // generate base targets (images to be compared) and settings for each environment
-                    const baseScreenshotsAndSettings = await generateBaseScreenshotsAndSettings(settings, uniqueEnvironments, eyes, logger, driver);
-                    const promises = baseScreenshotsAndSettings.map(async ({ exactEnvironment: environment, baseSetting: settings, baseTarget: target }) => {
-                        return await checkEnvironment({
-                            eyes,
-                            driver,
-                            target,
-                            environment,
-                            signal,
-                            logger,
-                            settings: {
-                                ...settings,
-                                replaceLast: retries > 1,
-                            },
-                        });
-                    });
-                    const results = await Promise.all(promises);
-                    asExpected = results.every(result => result.asExpected);
-                    if (retries === 1) {
-                        baseScreenshotsAndSettings.forEach(({ exactEnvironment }) => {
-                            // put dummy promises in storage to tell eyes.close that all checks hepped
-                            putInStorage(exactEnvironment, eyes, Promise.resolve());
-                        });
-                    }
-                } while (!asExpected && Date.now() - start < settings.matchTimeout);
-            }
-            else {
-                // Eagerly start opening sessions for web environments while screenshots are being taken.
-                // NML environments are excluded because their exact environment shape (deviceName, os,
-                // viewportSize) is only resolved after generateBaseScreenshotsAndSettings() returns, and
-                // using the unique env shape would open the session with wrong/empty fields.
-                const environmentLoggers = new Map();
-                uniqueEnvironments
-                    .filter(env => !('iosDeviceInfo' in env) && !('androidDeviceInfo' in env))
-                    .forEach(environment => {
-                    const environmentLogger = logger.extend({ tags: [`environment-${utils.general.shortid()}`] });
-                    environmentLoggers.set((0, to_environment_key_1.toEnvironmentKey)(environment), environmentLogger);
-                    void getBaseEyes({ environment, driver, logger: environmentLogger });
-                });
-                // generate base targets (images to be compared) and settings for each environment
-                const baseScreenshotsAndSettings = await generateBaseScreenshotsAndSettings(settings, uniqueEnvironments, eyes, logger, driver);
-                // when no match timeout is set, queue all environment checks against the server without stalling the client test execution
-                baseScreenshotsAndSettings.forEach(({ exactEnvironment: environment, baseSetting, baseTarget }) => {
-                    checkInTheBackground(environment, baseTarget, baseSetting, environmentLoggers.get((0, to_environment_key_1.toEnvironmentKey)(environment)));
-                });
-            }
-        }
-        else {
-            uniqueEnvironments.forEach(environment => checkInTheBackground(environment, target, settings));
-        }
-        function checkInTheBackground(environment, target, settings, environmentLogger) {
-            putInStorage(environment, eyes, checkEnvironment({ eyes, driver, target, environment, signal, logger, settings, environmentLogger }));
+        const mutability = settings.assumesMutability ? { eyes, checkName: settings.name } : undefined;
+        if (!(0, driver_1.isDriver)(target, spec)) {
+            uniqueEnvironments.forEach(environment => addStep(environment, { upload: { target, settings: settings } }, undefined, {
+                canFuse: true,
+                mutability,
+            }));
+            return;
         }
-    };
-    function putInStorage(environment, eyes, promise) {
-        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);
+        const driver = await (0, driver_1.makeDriver)({ spec, driver: target, reset: target === defaultTarget, logger });
+        if ((signal === null || signal === void 0 ? void 0 : signal.aborted) && settings.matchTimeout)
+            throw abortError();
+        if (signal === null || signal === void 0 ? void 0 : signal.aborted)
+            return (0, tasks_1.addAbortedCheck)(eyes, uniqueEnvironments, ABORTED, logger);
+        if (settings.matchTimeout) {
+            // when match timeout is set, retry checking until it passes or timeout is reached. This will stall the client test execution until it passes or timeout is reached to prevent the test from continuing and changing the state of the app
+            logger.log(`Match timeout is set to ${settings.matchTimeout}ms - will retry checking until it passes or timeout is reached`);
+            const start = Date.now();
+            let asExpected = false;
+            let retries = 0;
+            do {
+                retries += 1;
+                const capture = (0, steps_1.addCapture)(eyes.session, {
+                    eyes,
+                    driver,
+                    settings: { ...settings, replaceLast: retries > 1 },
+                    environments: uniqueEnvironments,
+                    newTestDelay: retries === 1 ? settings.matchTimeout : undefined,
+                    logger,
+                });
+                // Each attempt's steps go to the session of the environment the capture resolved.
+                const environments = await capture.promise.then(captured => captured.map(({ exactEnvironment }) => exactEnvironment), () => uniqueEnvironments);
+                if (signal === null || signal === void 0 ? void 0 : signal.aborted)
+                    throw abortError();
+                const matches = environments.map((environment, index) => addStep(environment, { upload: { index }, capture }, driver, {
+                    canFuse: false,
+                    mutability: retries === 1 ? mutability : undefined,
+                }));
+                const results = Promise.all(matches.map(match => match.promise.then(result => result.asExpected, () => false)));
+                await capture.promise;
+                asExpected = (await results).every(Boolean);
+                if (signal === null || signal === void 0 ? void 0 : signal.aborted)
+                    throw abortError();
+            } while (!asExpected && Date.now() - start < settings.matchTimeout);
+            return;
         }
-        item.jobs.push(promise.then());
-        return item;
-    }
-    function getBaseEyes({ environment, driver, logger, }) {
-        return eyes.getBaseEyes({ settings: { environment, driver }, logger });
-    }
-}
-exports.makeCheck = makeCheck;
-async function logAmmutabilityIfNeeded({ eyes, baseEyes, settings, logger, }) {
-    var _a;
-    if (settings.assumesMutability) {
-        await 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: (_a = baseEyes.test.environment) === null || _a === void 0 ? void 0 : _a.environmentId,
-                    },
-                    isNew: baseEyes.test.isNew,
-                    resultsUrl: baseEyes.test.resultsUrl,
-                },
-                ...eyes.test.eyesServer,
-            },
-            logger,
+        // One capture of every environment; the check returns once it's done (the test may change the page
+        // right after), while its steps run in the background.
+        const driverEnvironment = await driver.getEnvironment();
+        if (signal === null || signal === void 0 ? void 0 : signal.aborted)
+            return (0, tasks_1.addAbortedCheck)(eyes, uniqueEnvironments, ABORTED, logger);
+        const capture = (0, steps_1.addCapture)(eyes.session, { eyes, driver, settings, environments: uniqueEnvironments, logger });
+        const canOpenBeforeCapture = uniqueEnvironments.map(environment => (0, capture_1.isCapturedAsRequested)(settings, driverEnvironment, environment));
+        uniqueEnvironments.forEach((environment, index) => {
+            if (canOpenBeforeCapture[index]) {
+                addStep(environment, { upload: { index }, capture }, driver, { canFuse: true, mutability });
+            }
         });
-        settings.assumesMutability = false; // prevent from logging this message again for the same check
-    }
-}
-async function checkEnvironment({ eyes, driver, target, environment, signal, logger, settings, environmentLogger: providedEnvironmentLogger, }) {
-    var _a, _b;
-    const environmentLogger = providedEnvironmentLogger !== null && providedEnvironmentLogger !== void 0 ? providedEnvironmentLogger : logger.extend({ tags: [`environment-${utils.general.shortid()}`] });
-    environmentLogger.log('Command "check" is called with settings', settings);
-    try {
+        const captured = await capture.promise;
         if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
-            abortError({ logger: environmentLogger, message: 'Command "check" was aborted before checking' });
+            return (0, tasks_1.addAbortedCheck)(eyes, captured.map(({ exactEnvironment }) => exactEnvironment), ABORTED, logger);
         }
-        const baseEyes = await eyes.getBaseEyes({ settings: { environment, driver }, logger: environmentLogger });
-        void logAmmutabilityIfNeeded({
-            eyes,
-            baseEyes,
-            settings,
-            logger: environmentLogger,
-        });
-        try {
-            if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
-                abortError({
-                    logger: environmentLogger,
-                    message: `Command "check" was aborted before checking`,
-                });
+        captured.forEach(({ exactEnvironment }, index) => {
+            if (!canOpenBeforeCapture[index]) {
+                addStep(exactEnvironment, { upload: { index }, capture }, driver, { canFuse: true, mutability });
             }
-            else if (!baseEyes.running) {
-                abortError({
-                    logger: environmentLogger,
-                    message: `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`,
-                });
-            }
-            return await baseEyes.check({
-                target,
-                settings: settings,
-                logger: environmentLogger,
-            });
-        }
-        catch (error) {
-            environmentLogger.error(`Check on environment with id "${(_b = baseEyes.test.environment) === null || _b === void 0 ? void 0 : _b.environmentId}" failed due to an error`, error);
-            if (baseEyes.running && !(signal === null || signal === void 0 ? void 0 : signal.aborted))
-                void 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 };
-        throw error;
-    }
-    return { asExpected: false };
-}
-/**
- * @throws {AbortError}
- */
-function abortError({ logger, message }) {
-    logger.warn(message);
-    throw new abort_error_1.AbortError(message);
-}
-/**
- * create base targets (array of screenshots) and base settings (array of check settings) for each environment
- */
-async function generateBaseScreenshotsAndSettings(settings, uniqueEnvironments, eyes, logger, driver) {
-    var _a;
-    const driverEnvironment = await driver.getEnvironment();
-    uniqueEnvironments = addMobileDeviceInfo(uniqueEnvironments, driverEnvironment);
-    await beforeScreenshot();
-    const shouldTakeWebScreenshot = driverEnvironment.isWeb ||
-        !((_a = driverEnvironment.applitoolsLib) === null || _a === void 0 ? void 0 : _a.instrumented) ||
-        settings.webview ||
-        settings.screenshotMode === 'default';
-    if (shouldTakeWebScreenshot) {
-        return await takeWebScreenshot({
-            driver,
-            settings,
-            environments: uniqueEnvironments,
-            logger,
-            eyes,
         });
-    }
-    else {
-        // take screenshot using NML
-        checkConflictingCapabilities();
-        return await takeNMLScreenshot({
-            driver,
-            settings,
-            environments: uniqueEnvironments,
-            logger,
-            eyes,
-        });
-    }
-    async function beforeScreenshot() {
-        var _a;
-        await driver.currentContext.setScrollingElement((_a = settings.scrollRootElement) !== null && _a !== void 0 ? _a : null);
-        if (settings.lazyLoad && driverEnvironment.isWeb) {
-            await (0, wait_for_lazy_load_1.waitForLazyLoad)({
-                context: driver.currentContext,
-                settings: settings.lazyLoad !== true ? settings.lazyLoad : {},
-                logger,
-            });
+        function abortError() {
+            logger.warn(ABORTED);
+            return new abort_error_1.AbortError(ABORTED, { userTestId: eyes.test.userTestId, environment: uniqueEnvironments[0] });
         }
-    }
-    function checkConflictingCapabilities() {
-        var _a;
-        if ((_a = driverEnvironment.applitoolsLib) === null || _a === void 0 ? void 0 : _a.conflictingCapabilities) {
-            const message = lang.applitoolsLibConflictingCapabilitiesWarning({
-                conflictingCapabilities: driverEnvironment.applitoolsLib.conflictingCapabilities,
+        function addStep(environment, step, driver, match) {
+            const environmentLogger = eyes.getEnvironmentLogger(environment, logger);
+            const open = { eyes, environment, driver, logger: environmentLogger };
+            return (0, steps_1.addCheck)(eyes.session, (0, to_environment_key_1.toEnvironmentKey)(environment), {
+                open,
+                capture: step.capture,
+                upload: { ...step.upload, signal, logger: environmentLogger },
+                inputs: {
+                    ...match,
+                    signal,
+                    onError: (error, baseEyes) => {
+                        var _a;
+                        environmentLogger.error(`Check on environment with id "${(_a = baseEyes.test.environment) === null || _a === void 0 ? void 0 : _a.environmentId}" failed due to an error`, error);
+                        error.info = { ...error.info, userTestId: eyes.test.userTestId, environment };
+                    },
+                    logger: environmentLogger,
+                },
             });
-            logger.console.log(chalk_1.default.yellow(message));
-            logger.log(message);
-        }
-    }
-    function addMobileDeviceInfo(environments, driverEnvironment) {
-        return environments.map(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;
-        });
-    }
-}
-async function takeWebScreenshot({ driver, settings, environments, logger, eyes, }) {
-    let actualEnvironments = environments;
-    if (settings.screenshotMode === 'default') {
-        const { localEnvironment, renderEnvironments } = await (0, nml_client_1.getNMLEnvironmentsInfo)({
-            environments: environments,
-            supportedEnvironmentsUrl: eyes.test.supportedEnvironmentsUrl,
-            proxy: eyes.test.eyesServer.proxy,
-            logger,
-        });
-        actualEnvironments = localEnvironment ? [localEnvironment] : renderEnvironments;
-    }
-    const { elementReferences, getBaseCheckSettings } = (0, to_base_check_settings_1.toBaseCheckSettings)({ settings });
-    const screenshots = await (0, take_screenshots_1.takeScreenshots)({
-        driver,
-        settings: {
-            ...settings,
-            environments: actualEnvironments,
-            regionsToCalculate: elementReferences.calculate,
-            calculateView: !!settings.pageId,
-            domSettings: settings.sendDom ? { proxy: eyes.test.eyesServer.proxy } : undefined,
-        },
-        logger,
-    });
-    return screenshots.map(({ calculatedRegions, ...baseTarget }, i) => {
-        return {
-            baseTarget,
-            baseSetting: getBaseCheckSettings({ calculatedRegions }),
-            exactEnvironment: actualEnvironments[i],
-        };
-    });
-}
-async function takeNMLScreenshot({ driver, settings, environments, logger, eyes, }) {
-    const nmlClient = await eyes.core.getNMLClient({
-        driver,
-        settings: { ...eyes.test.eyesServer, supportedEnvironmentsUrl: eyes.test.supportedEnvironmentsUrl },
-        logger,
-    });
-    if (settings.scrollRootElement || settings.region || (0, to_base_check_settings_1.hasCodedRegions)(settings)) {
-        //TODO we can skip `preTakeScreenshot` if the element/s already have the attribute `content-desc` (for android)
-        // and send it to `takeScreenshot` right away (possibly with `name` attribute for ios as well)
-        await nmlClient.preTakeScreenshot({ logger });
-    }
-    const { elementReferences, getBaseCheckSettings } = (0, to_base_check_settings_1.toBaseCheckSettings)({
-        settings: {
-            ...settings,
-            ...(await (0, to_base_check_settings_1.extractMobileElementsIntoCheckSettings)({ settings, driver, logger })),
-        },
-    });
-    const calculate = elementReferences.calculate;
-    if (typeof settings.waitBeforeCapture === 'function') {
-        throw new Error('providing functions to waitBeforeCapture is not supported in NML - please use a number instead');
-    }
-    const screenshots = await nmlClient.takeScreenshots({
-        settings: {
-            environments: environments,
-            fully: settings.fully,
-            stitchMode: settings.stitchMode,
-            hideScrollbars: settings.hideScrollbars,
-            hideCaret: settings.hideCaret,
-            overlap: settings.overlap,
-            waitBeforeCapture: settings.waitBeforeCapture,
-            waitBetweenStitches: settings.waitBetweenStitches,
-            lazyLoad: settings.lazyLoad,
-            name: settings.name,
-            region: elementReferences.target,
-            selectorsToFindRegionsFor: calculate.map(({ name }) => name),
-            scrollRootElement: elementReferences.scrolling,
-            sendDom: settings.sendDom,
-        },
-        logger,
-    });
-    return screenshots.map(({ calculateRegions, ...baseTarget }) => {
-        var _a, _b;
-        const aggregateCalculatedRegions = [];
-        calculate.forEach(({ reference }, index) => {
-            const regions = calculateRegions === null || calculateRegions === void 0 ? void 0 : calculateRegions[index];
-            if (regions) {
-                aggregateCalculatedRegions.push({ regions, selector: reference });
-            }
-            else {
-                logger.log(`Regions "${JSON.stringify(reference)}" was not found in the screenshot`);
-            }
-        });
-        if ((_a = baseTarget.dom) === null || _a === void 0 ? void 0 : _a.error) {
-            logger.warn('could not fetch DOM: ' + baseTarget.dom.error);
         }
-        return {
-            baseTarget: { ...baseTarget, dom: (_b = baseTarget.dom) === null || _b === void 0 ? void 0 : _b.url, isTransformed: true },
-            baseSetting: getBaseCheckSettings({
-                calculatedRegions: aggregateCalculatedRegions,
-            }),
-            exactEnvironment: baseTarget.environment,
-        };
-    });
+    };
 }
+exports.makeCheck = makeCheck;

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

@@ -1,59 +1,20 @@
 "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.makeGetBaseEyes = void 0;
-const to_environment_key_1 = require("../automation/utils/to-environment-key");
-const utils = __importStar(require("@applitools/utils"));
+exports.getBaseEyes = void 0;
 const report_kobiton_1 = require("../automation/utils/report-kobiton");
-function makeGetBaseEyes({ settings: defaultSettings, eyes, logger: mainLogger, }) {
-    const getBaseEyesWithCache = utils.general.wrap(getBaseEyes, (getBaseEyes, options) => {
-        const key = (0, to_environment_key_1.toEnvironmentKey)(options.settings.environment);
-        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;
+async function getBaseEyes({ eyes, settings, logger, }) {
+    var _a;
+    const defaultSettings = eyes.openSettings;
+    logger.log(`Command "getBaseEyes" is called with settings`, settings);
+    const baseEyes = await eyes.core.base.openEyes({
+        settings: {
+            ...defaultSettings,
+            fallbackBaselineId: (_a = settings.environment) === null || _a === void 0 ? void 0 : _a.fallbackBaselineId,
+            environment: { ...defaultSettings.environment, ...settings.environment },
+        },
+        logger,
     });
-    return getBaseEyesWithCache;
-    async function getBaseEyes({ settings, logger = mainLogger, }) {
-        var _a;
-        logger = logger.extend(mainLogger);
-        logger.log(`Command "getBaseEyes" is called with settings`, settings);
-        const baseEyes = await eyes.core.base.openEyes({
-            settings: {
-                ...defaultSettings,
-                fallbackBaselineId: (_a = settings.environment) === null || _a === void 0 ? void 0 : _a.fallbackBaselineId,
-                environment: { ...defaultSettings.environment, ...settings.environment },
-            },
-            logger,
-        });
-        void (0, report_kobiton_1.reportKobiton)({ driver: settings.driver, settings: baseEyes.test, logger });
-        return baseEyes;
-    }
+    void (0, report_kobiton_1.reportKobiton)({ driver: settings.driver, settings: baseEyes.test, logger });
+    return baseEyes;
 }
-exports.makeGetBaseEyes = makeGetBaseEyes;
+exports.getBaseEyes = getBaseEyes;

package/dist/classic/open-eyes.js

@@ -25,22 +25,24 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeOpenEyes = void 0;
 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("../automation/close");
 const abort_1 = require("../automation/abort");
 const get_results_1 = require("../automation/get-results");
 const extract_default_environments_1 = require("./utils/extract-default-environments");
+const make_environment_loggers_1 = require("../automation/utils/make-environment-loggers");
+const tasks_1 = require("../tasks");
+const uniquify_environments_1 = require("../automation/utils/uniquify-environments");
 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, storage = new Map(), logger = mainLogger, }) {
-        var _a, _b, _c, _d;
+    return async function openEyes({ target, settings, session = {}, logger = mainLogger, }) {
+        var _a, _b, _c, _d, _e;
         logger = logger.extend(mainLogger);
-        logger.log(`Command "openEyes" is called with ${target ? 'default driver' : ''}`, ...(settings ? ['and settings', settings] : []), storage.size > 0 ? 'and default eyes storage' : '');
+        logger.log(`Command "openEyes" is called with ${target ? 'default driver' : ''}`, ...(settings ? ['and settings', settings] : []), (0, tasks_1.activeEnvironmentKeys)(session).length > 0 ? 'and existing sessions' : '');
         const driver = target && (await (0, driver_1.makeDriver)({ spec, driver: target, logger, customConfig: settings }));
-        if (driver && storage.size === 0) {
+        if (driver && (0, tasks_1.activeEnvironmentKeys)(session).length === 0) {
             const environment = await driver.getEnvironment();
             if (((_a = settings.environment) === null || _a === void 0 ? void 0 : _a.viewportSize) && !environment.isMobile) {
                 await driver.setViewportSize(settings.environment.viewportSize);
@@ -68,7 +70,7 @@ function makeOpenEyes({ core, spec, logger: mainLogger }) {
                 }
             }
         }
-        return utils.general.extend({}, eyes => {
+        const eyes = utils.general.extend({}, eyes => {
             var _a, _b, _c, _d;
             return {
                 type: 'classic',
@@ -86,15 +88,20 @@ function makeOpenEyes({ core, spec, logger: mainLogger }) {
                     account,
                 },
                 running: true,
-                storage,
-                getBaseEyes: (0, get_base_eyes_1.makeGetBaseEyes)({ settings, eyes, logger }),
+                session,
+                getEnvironmentLogger: (0, make_environment_loggers_1.makeEnvironmentLoggers)(),
+                openSettings: settings,
                 check: (0, check_1.makeCheck)({ eyes, target: driver, environments, spec, signal, logger }),
                 checkAndClose: (0, check_and_close_1.makeCheckAndClose)({ eyes, target: driver, environments, spec, signal, logger }),
-                close: (0, close_1.makeClose)({ eyes, driver, environments, logger }),
-                abort: (0, abort_1.makeAbort)({ eyes, driver, environments, controller, logger }),
+                close: (0, close_1.makeClose)({ eyes, driver, logger }),
+                abort: (0, abort_1.makeAbort)({ eyes, driver, controller, logger }),
                 getResults: (0, get_results_1.makeGetResults)({ eyes, logger }),
             };
         });
+        // A device environment's session opens with the exact environment its capture resolves, so it isn't declared here.
+        const declared = (0, uniquify_environments_1.uniquifyEnvironments)(((_e = settings.environments) === null || _e === void 0 ? void 0 : _e.length) ? settings.environments : environments).filter(environment => !utils.types.has(environment, 'iosDeviceInfo') && !utils.types.has(environment, 'androidDeviceInfo'));
+        (0, tasks_1.declareOpens)(eyes, declared, driver, logger);
+        return eyes;
     };
 }
 exports.makeOpenEyes = makeOpenEyes;