@applitools/core 4.74.2 → 4.75.0

package/dist/classic/utils/capture.js

@@ -0,0 +1,209 @@
+"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.generateBaseScreenshotsAndSettings = exports.isCapturedAsRequested = void 0;
+const nml_client_1 = require("@applitools/nml-client");
+const take_screenshots_1 = require("./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 chalk_1 = __importDefault(require("chalk"));
+const utils = __importStar(require("@applitools/utils"));
+const lang = __importStar(require("../../lang"));
+/** Whether the capture keeps `environment` as its exact environment, at the same index. */
+function isCapturedAsRequested(settings, driverEnvironment, environment) {
+    return (shouldTakeWebScreenshot(settings, driverEnvironment) &&
+        settings.screenshotMode !== 'default' &&
+        !('iosDeviceInfo' in environment) &&
+        !('androidDeviceInfo' in environment));
+}
+exports.isCapturedAsRequested = isCapturedAsRequested;
+function shouldTakeWebScreenshot(settings, driverEnvironment) {
+    var _a;
+    return (driverEnvironment.isWeb ||
+        !((_a = driverEnvironment.applitoolsLib) === null || _a === void 0 ? void 0 : _a.instrumented) ||
+        !!settings.webview ||
+        settings.screenshotMode === 'default');
+}
+/**
+ * create base targets (array of screenshots) and base settings (array of check settings) for each environment
+ */
+async function generateBaseScreenshotsAndSettings(settings, uniqueEnvironments, eyes, logger, driver) {
+    const driverEnvironment = await driver.getEnvironment();
+    uniqueEnvironments = addMobileDeviceInfo(uniqueEnvironments, driverEnvironment);
+    await beforeScreenshot();
+    if (shouldTakeWebScreenshot(settings, driverEnvironment)) {
+        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 checkConflictingCapabilities() {
+        var _a;
+        if ((_a = driverEnvironment.applitoolsLib) === null || _a === void 0 ? void 0 : _a.conflictingCapabilities) {
+            const message = lang.applitoolsLibConflictingCapabilitiesWarning({
+                conflictingCapabilities: driverEnvironment.applitoolsLib.conflictingCapabilities,
+            });
+            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;
+        });
+    }
+}
+exports.generateBaseScreenshotsAndSettings = generateBaseScreenshotsAndSettings;
+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,
+        };
+    });
+}

package/dist/get-typed-eyes.js

@@ -13,11 +13,11 @@ function makeGetTypedEyes({ type: defaultType, settings: defaultSettings, target
             return eyes;
         }
         else if (type === 'ufg') {
-            const typedEyes = await cores.ufg.openEyes({ target, settings: defaultSettings, storage: eyes.storage, logger });
+            const typedEyes = await cores.ufg.openEyes({ target, settings: defaultSettings, session: eyes.session, logger });
             return typedEyes;
         }
         else {
-            const typedEyes = await cores.classic.openEyes({ target, settings: defaultSettings, storage: eyes.storage, logger });
+            const typedEyes = await cores.classic.openEyes({ target, settings: defaultSettings, session: eyes.session, logger });
             return typedEyes;
         }
     };

package/dist/offline/run-offline-snapshots.js

@@ -194,7 +194,9 @@ async function runOfflineSnapshots(options) {
                 const lastTarget = targets.pop();
                 try {
                     await uploadResourcePromise;
-                    await Promise.all(targets.map((target, index) => runCheck(eyes, target, index, logger)));
+                    // The server records steps in arrival order, so replay them one at a time.
+                    for (const [index, target] of targets.entries())
+                        await runCheck(eyes, target, index, logger);
                     if (lastTarget) {
                         lastTarget.settings = (0, merge_configs_1.mergeConfigs)(lastTarget.settings, closeSettings);
                         await runCheckAndClose(eyes, lastTarget, targets.length - 1, logger);

package/dist/tasks/abort.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.add = void 0;
+const queries_1 = require("./queries");
+/**
+ * Aborts the environment's session as soon as it is open, without waiting for its steps (they read the
+ * abort signal), unless an abort is already queued. A pending close or matchAndEnd still gets it; core-base ends a
+ * session only once. Kind `dismiss`: if the open is still lazy (nothing needed it), it's discarded and no session
+ * opens.
+ */
+function add(graph, { inputs, labels }) {
+    var _a;
+    const { session, env } = labels;
+    const [abort] = (0, queries_1.queryTasks)({ session, type: 'abort', env });
+    if (abort)
+        return abort;
+    const open = (0, queries_1.environmentOpen)(labels);
+    const deps = { open };
+    const logger = (_a = open === null || open === void 0 ? void 0 : open.inputs.logger) !== null && _a !== void 0 ? _a : inputs.logger;
+    return graph.add({ type: 'abort', kind: 'dismiss', deps, inputs: { ...inputs, logger }, labels, logger, run });
+}
+exports.add = add;
+async function run(deps, { settings, logger }) {
+    var _a, _b;
+    try {
+        await deps.open.abort({ settings, logger });
+    }
+    catch (error) {
+        logger.warn('Command "abort" received an error during waiting for eyes instances in background', error);
+        await ((_b = (_a = error === null || error === void 0 ? void 0 : error.info) === null || _a === void 0 ? void 0 : _a.eyes) === null || _b === void 0 ? void 0 : _b.abort({ settings, logger }));
+    }
+}

package/dist/tasks/aborted-check.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.add = void 0;
+/**
+ * A check the test was aborted during, before it added its steps: it fails with the abort and is kept by its
+ * session, so the environment's getResults rejects with it.
+ */
+function add(graph, { inputs, labels }) {
+    return graph.add({ type: 'abortedCheck', inputs, labels, keep: labels.session, run });
+}
+exports.add = add;
+async function run(_deps, { error }) {
+    throw error;
+}

package/dist/tasks/classic/capture.js

@@ -0,0 +1,54 @@
+"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.add = void 0;
+const utils = __importStar(require("@applitools/utils"));
+const capture_1 = require("../../classic/utils/capture");
+const to_environment_key_1 = require("../../automation/utils/to-environment-key");
+const openTask = __importStar(require("../open"));
+/**
+ * A classic check's capture of every environment in one pass — they share the driver, whose viewport
+ * it resizes per environment. The check awaits it, so the page stays untouched until it's done.
+ */
+function add(graph, { inputs, labels }) {
+    const { eyes, driver, environments, newTestDelay, logger } = inputs;
+    const opens = newTestDelay
+        ? environments.map(environment => openTask.add(graph, {
+            inputs: { eyes, environment, driver, logger: eyes.getEnvironmentLogger(environment, logger) },
+            labels: { session: labels.session, env: (0, to_environment_key_1.toEnvironmentKey)(environment) },
+        }))
+        : [];
+    const deps = Object.fromEntries(opens.map((open, index) => [`open${index}`, open]));
+    return graph.add({ type: 'capture', deps, inputs, labels, logger: inputs.logger, run });
+}
+exports.add = add;
+async function run(deps, inputs) {
+    const { eyes, driver, settings, environments, newTestDelay, logger } = inputs;
+    // 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 (newTestDelay && Object.values(deps).some(baseEyes => baseEyes.test.isNew)) {
+        await utils.general.sleep(newTestDelay);
+    }
+    return (0, capture_1.generateBaseScreenshotsAndSettings)(settings, environments, eyes, logger, driver);
+}

package/dist/tasks/classic/steps.js

@@ -0,0 +1,51 @@
+"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.addCapture = exports.addCheckAndClose = exports.addCheck = void 0;
+const graph_1 = require("../graph");
+const openTask = __importStar(require("../open"));
+const uploadTask = __importStar(require("./upload"));
+const matchTask = __importStar(require("../match"));
+const captureTask = __importStar(require("./capture"));
+const lifecycle_1 = require("../lifecycle");
+/** A check step: its upload, then its match after the environment's previous one. */
+function addCheck(session, env, step) {
+    const labels = { session, env };
+    openTask.add(graph_1.graph, { inputs: step.open, labels });
+    const upload = uploadTask.add(graph_1.graph, { deps: { capture: step.capture }, inputs: step.upload, labels });
+    return matchTask.add(graph_1.graph, { deps: { upload }, inputs: step.inputs, labels });
+}
+exports.addCheck = addCheck;
+/** A check step and the close it fuses into: one `matchAndEnd`. */
+function addCheckAndClose(session, env, { settings, ...step }) {
+    addCheck(session, env, step);
+    (0, lifecycle_1.addClose)(session, env, { settings, logger: step.inputs.logger });
+}
+exports.addCheckAndClose = addCheckAndClose;
+/** A classic check's capture; its steps read their targets from it by index. */
+function addCapture(session, inputs) {
+    return captureTask.add(graph_1.graph, { inputs, labels: { session, env: '' } });
+}
+exports.addCapture = addCapture;

package/dist/tasks/classic/upload.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.add = void 0;
+const abort_error_1 = require("../../errors/abort-error");
+const upload_target_1 = require("../upload-target");
+const queries_1 = require("../queries");
+/** The slow leg of a classic check step: normalize the captured target and upload its resources. */
+function add(graph, { deps, inputs, labels }) {
+    return graph.add({
+        type: 'upload',
+        deps: { ...deps, open: (0, queries_1.environmentOpen)(labels) },
+        inputs,
+        labels,
+        logger: inputs.logger,
+        run,
+    });
+}
+exports.add = add;
+/** Resolves `undefined` when the capture failed: the check throws it, and the step is skipped. */
+async function run(deps, { signal, logger, ...step }) {
+    const baseEyes = deps.open;
+    let target;
+    if ('index' in step) {
+        let captured;
+        try {
+            captured = deps.capture;
+        }
+        catch {
+            return undefined;
+        }
+        const { baseTarget, baseSetting } = captured[step.index];
+        target = { target: baseTarget, settings: baseSetting };
+    }
+    else {
+        target = step;
+    }
+    if ((signal === null || signal === void 0 ? void 0 : signal.aborted) || !baseEyes.running)
+        throw new abort_error_1.AbortError('Command "check" was aborted before uploading');
+    return (0, upload_target_1.uploadTarget)(baseEyes, target, logger);
+}

package/dist/tasks/close.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.add = void 0;
+const queries_1 = require("./queries");
+/**
+ * The environment's terminal close, unless a close, abort or fused match already ends it. Kind `dismiss`: if the
+ * open is still lazy (nothing needed it), it's discarded and no session opens.
+ */
+function add(graph, { inputs, labels }) {
+    var _a;
+    const { session, env } = labels;
+    const [ending] = ['close', 'abort', 'matchAndEnd'].flatMap(type => (0, queries_1.queryTasks)({ session, type, env }));
+    if (ending)
+        return ending;
+    const open = (0, queries_1.environmentOpen)(labels);
+    const deps = { open };
+    // After the environment's last step, so a still-unstarted match fuses into this close.
+    const after = [(0, queries_1.lastStep)(session, env)];
+    const logger = (_a = open === null || open === void 0 ? void 0 : open.inputs.logger) !== null && _a !== void 0 ? _a : inputs.logger;
+    return graph.add({ type: 'close', kind: 'dismiss', deps, after, inputs: { ...inputs, logger }, labels, logger, run });
+}
+exports.add = add;
+async function run({ open: baseEyes }, { settings, logger }) {
+    try {
+        await baseEyes.close({ settings, logger });
+    }
+    catch (error) {
+        logger.warn('Command "close" received an error during performing, trying to perform abort instead', error);
+        await baseEyes.abort({ settings, logger });
+    }
+}

package/dist/tasks/fill.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.add = void 0;
+const queries_1 = require("./queries");
+/**
+ * An empty test's environment that still gets a session: as a normal dependent, it activates the lazy open, so
+ * the close or abort resting on it can't dismiss it.
+ */
+function add(graph, { labels }) {
+    const deps = { open: (0, queries_1.environmentOpen)(labels) };
+    return graph.add({ type: 'fill', deps, labels, run: async () => { } });
+}
+exports.add = add;

package/dist/tasks/get-results.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.add = void 0;
+const queries_1 = require("./queries");
+/** The environment's result, once everything else in it has settled. */
+function add(graph, { inputs, labels }) {
+    var _a;
+    const { session, env } = labels;
+    const open = (0, queries_1.environmentOpen)(labels);
+    const deps = { open, aborted: (0, queries_1.queryTasks)({ session, type: 'abortedCheck', env })[0] };
+    // After every unfinished leaf of the environment's tasks, so the result comes after all of them.
+    const after = graph.filter(task => task.labels.session === session && task.labels.env === env && task.dependents.size === 0);
+    const logger = (_a = open === null || open === void 0 ? void 0 : open.inputs.logger) !== null && _a !== void 0 ? _a : inputs.logger;
+    return graph.add({ type: 'getResults', deps, after, inputs: { ...inputs, logger }, labels, logger, run });
+}
+exports.add = add;
+async function run(deps, { settings, logger }) {
+    try {
+        // Reading a failed dependency throws its error.
+        void deps.aborted;
+        const baseEyes = deps.open;
+        const [result] = await baseEyes.getResults({ settings, logger });
+        return { ...result, environment: baseEyes.test.environment };
+    }
+    catch (error) {
+        logger.fatal('Command "getResults" received an error', error, 'during performing with settings', settings);
+        throw error;
+    }
+}

package/dist/tasks/graph.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.graph = void 0;
+const task_manager_1 = require("@applitools/task-manager");
+/** Core's one task graph — every test is a disjoint tree in it. */
+exports.graph = (0, task_manager_1.makeTaskManager)();

package/dist/tasks/index.js

@@ -0,0 +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 __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 });
+exports.activeEnvironmentKeys = void 0;
+__exportStar(require("./lifecycle"), exports);
+var queries_1 = require("./queries");
+Object.defineProperty(exports, "activeEnvironmentKeys", { enumerable: true, get: function () { return queries_1.activeEnvironmentKeys; } });

package/dist/tasks/lifecycle.js

@@ -0,0 +1,101 @@
+"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.addAbortedCheck = exports.getResults = exports.addClose = exports.abortSession = exports.closeSession = exports.declareFillers = exports.declareOpens = void 0;
+const graph_1 = require("./graph");
+const openTask = __importStar(require("./open"));
+const closeTask = __importStar(require("./close"));
+const abortTask = __importStar(require("./abort"));
+const fillTask = __importStar(require("./fill"));
+const getResultsTask = __importStar(require("./get-results"));
+const abortedCheckTask = __importStar(require("./aborted-check"));
+const abort_error_1 = require("../errors/abort-error");
+const to_environment_key_1 = require("../automation/utils/to-environment-key");
+const queries_1 = require("./queries");
+/**
+ * Declares the opens of the environments known at openEyes, lazy: the first check needing one opens it,
+ * and a close that finds it still unneeded dismisses it, so no empty session is created.
+ */
+function declareOpens(eyes, environments, driver, logger) {
+    for (const environment of environments) {
+        const open = { eyes, environment, driver, logger: eyes.getEnvironmentLogger(environment, logger) };
+        openTask.add(graph_1.graph, { inputs: open, labels: { session: eyes.session, env: (0, to_environment_key_1.toEnvironmentKey)(environment) } });
+    }
+}
+exports.declareOpens = declareOpens;
+/**
+ * Fills an empty test's environments, so it still has a session per environment: the ones its close names
+ * (declared here), or else a classic test's declared ones. An empty ufg test that names none opens nothing.
+ * Returns the filled environments' opens.
+ */
+function declareFillers(eyes, environments, logger) {
+    const session = eyes.session;
+    if ((0, queries_1.openedEnvironmentKeys)(session).length > 0)
+        return [];
+    const opens = (environments === null || environments === void 0 ? void 0 : environments.length)
+        ? environments.map(environment => openTask.add(graph_1.graph, {
+            inputs: { eyes, environment, logger: eyes.getEnvironmentLogger(environment, logger) },
+            labels: { session, env: (0, to_environment_key_1.toEnvironmentKey)(environment) },
+        }))
+        : eyes.type === 'classic'
+            ? (0, queries_1.queryTasks)({ session, type: 'open' })
+            : [];
+    for (const open of opens)
+        fillTask.add(graph_1.graph, { labels: open.labels });
+    return opens;
+}
+exports.declareFillers = declareFillers;
+/** Closes every environment of the session; a still-unstarted last match fuses into its close. */
+function closeSession(session, inputs) {
+    for (const env of (0, queries_1.environmentKeys)(session))
+        addClose(session, env, inputs);
+}
+exports.closeSession = closeSession;
+/** Aborts every environment of the session as soon as it is open, without waiting for its steps. */
+function abortSession(session, inputs) {
+    for (const env of (0, queries_1.environmentKeys)(session)) {
+        abortTask.add(graph_1.graph, { inputs, labels: { session, env } });
+    }
+}
+exports.abortSession = abortSession;
+/** Closes the environment after its last step. */
+function addClose(session, env, inputs) {
+    closeTask.add(graph_1.graph, { inputs, labels: { session, env } });
+}
+exports.addClose = addClose;
+/** The environment's result, after every unfinished task of it — its last match, close or abort. */
+function getResults(session, env, inputs) {
+    return getResultsTask.add(graph_1.graph, { inputs, labels: { session, env } }).promise;
+}
+exports.getResults = getResults;
+/** Records a check the test was aborted during, before it added its steps (see `aborted-check.ts`). */
+function addAbortedCheck(eyes, environments, message, logger) {
+    logger.warn(message);
+    for (const environment of environments) {
+        const error = new abort_error_1.AbortError(message, { userTestId: eyes.test.userTestId, environment });
+        abortedCheckTask.add(graph_1.graph, { inputs: { error }, labels: { session: eyes.session, env: (0, to_environment_key_1.toEnvironmentKey)(environment) } });
+    }
+}
+exports.addAbortedCheck = addAbortedCheck;