@applitools/core 1.0.0

package/dist/troubleshoot/check-network.js

@@ -0,0 +1,106 @@
+"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.checkNetwork = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const utils_1 = require("./utils");
+const eyes_1 = __importDefault(require("./eyes"));
+const ufg_1 = __importDefault(require("./ufg"));
+const utils = __importStar(require("@applitools/utils"));
+const TIMEOUT = 15000;
+const config = utils.config.getConfig({ params: ['apiKey', 'serverUrl', 'proxy'] });
+async function checkNetwork({ stream = process.stdout, eyes = eyes_1.default, ufg = ufg_1.default } = {}) {
+    const hasClearLine = stream.clearLine && stream.cursorTo;
+    async function doTest(func, name) {
+        const delimiterLength = 30 - name.length;
+        const delimiter = new Array(delimiterLength).join(' ');
+        hasClearLine && printSuccess(name, delimiter, '[ ?  ]');
+        const start = Date.now();
+        const funcWithTimeout = (0, utils_1.ptimeoutWithError)(func(), TIMEOUT, new Error('request timeout!'));
+        const [err] = await (0, utils_1.presult)(funcWithTimeout);
+        const end = (Date.now() - start) / 1000;
+        clearLine();
+        if (err) {
+            printErr(name, delimiter, `[ X  ]  +${end}`, err.message, err.message[err.message.length - 1] !== '\n' ? '\n' : '');
+        }
+        else {
+            printSuccess(name, delimiter, `[ OK ]  +${end}`, '\n');
+        }
+        return !!err;
+    }
+    function print(...msg) {
+        stream.write((0, chalk_1.default)(...msg));
+    }
+    function printErr(...msg) {
+        stream.write(chalk_1.default.red(...msg));
+    }
+    function printSuccess(...msg) {
+        stream.write(chalk_1.default.green(...msg));
+    }
+    function clearLine() {
+        if (hasClearLine) {
+            stream.clearLine(0);
+            stream.cursorTo(0);
+        }
+    }
+    if (!config.apiKey) {
+        printErr('Missing "apiKey". Add APPLITOOLS_API_KEY as an env variable or add "apiKey" in applitools.config.js\n');
+        return;
+    }
+    const proxyEnvMsg = `HTTP_PROXY="${process.env.HTTP_PROXY || ''}"\nHTTPS_PROXY="${process.env.HTTPS_PROXY || ''}"`;
+    const configMsg = `User config: ${JSON.stringify(config, null, 2)}\n${proxyEnvMsg}`;
+    print(`Eyes Check Network. Running with:\n\n---\n\n${chalk_1.default.cyan(configMsg)}\n\n---\n\n`);
+    let hasErr = false;
+    let curlRenderErr = true;
+    let curlVgErr = true;
+    // TODO - http and fetch need to account for proxy.
+    print('[1] Checking eyes API', eyes.url.origin, '\n');
+    curlRenderErr = await doTest(eyes.testCurl, '[eyes] cURL');
+    hasErr = curlRenderErr;
+    hasErr = (await doTest(eyes.testHttps, '[eyes] https')) || hasErr;
+    hasErr = (await doTest(eyes.testFetch, '[eyes] node-fetch')) || hasErr;
+    hasErr = await doTest(eyes.testServer, '[eyes] server connector');
+    print('[2] Checking Ultrafast grid API', ufg.url.origin, '\n');
+    curlVgErr = await doTest(ufg.testCurl, '[UFG] cURL');
+    hasErr = curlVgErr || hasErr;
+    hasErr = (await doTest(ufg.testHttps, '[UFG] https')) || hasErr;
+    hasErr = (await doTest(ufg.testFetch, '[UFG] node-fetch')) || hasErr;
+    hasErr = (await doTest(ufg.testServer, '[UFG] server connector')) || hasErr;
+    if (!hasErr) {
+        printSuccess('\nSuccess!\n');
+    }
+    const proxyMsg = '\nYour proxy seems to be blocking requests to Applitools. Please make sure the following command succeeds:';
+    if (curlRenderErr) {
+        printErr(proxyMsg, '\n', eyes.cmd, '\n');
+    }
+    else if (curlVgErr) {
+        printErr(proxyMsg, '\n', await ufg.getCmd());
+    }
+}
+exports.checkNetwork = checkNetwork;
+checkNetwork();

package/dist/troubleshoot/eyes.js

@@ -0,0 +1,85 @@
+"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.CURL_CMD = exports.RENDER_INFO_URL = void 0;
+const https_1 = require("https");
+const core_base_1 = require("@applitools/core-base");
+const utils_1 = require("./utils");
+const utils = __importStar(require("@applitools/utils"));
+const node_fetch_1 = __importDefault(require("node-fetch"));
+exports.RENDER_INFO_URL = `${utils_1.config.serverUrl}/api/sessions/renderinfo?apiKey=${utils_1.config.apiKey}`;
+exports.CURL_CMD = `curl ${exports.RENDER_INFO_URL} ${(0, utils_1.getProxyCurlArg)()}`;
+const validateRawAccountInfo = res => {
+    if (!res || !res.accessToken || !res.resultsUrl) {
+        throw new Error(`bad render info result ${JSON.stringify(res)}`);
+    }
+};
+const validateAccountInfo = res => {
+    if (!res || !res.ufg || !res.ufg.accessToken || !res.uploadUrl) {
+        throw new Error(`bad render info result ${JSON.stringify(res)}`);
+    }
+};
+exports.default = {
+    async testFetch() {
+        const response = await (0, node_fetch_1.default)(exports.RENDER_INFO_URL);
+        const data = await response.json();
+        validateRawAccountInfo(data);
+    },
+    async testCurl() {
+        const { stdout } = await utils.process.execute(exports.CURL_CMD, {
+            maxBuffer: 10000000,
+        });
+        const data = JSON.parse(stdout);
+        validateRawAccountInfo(data);
+    },
+    async testServer() {
+        const server = (0, core_base_1.makeCoreRequests)({ agentId: 'check-network' });
+        const result = await server.getAccountInfo({ settings: utils_1.config });
+        validateAccountInfo(result);
+    },
+    testHttps: async () => {
+        return new Promise((resolve, reject) => {
+            const request = (0, https_1.get)(exports.RENDER_INFO_URL, response => {
+                let data = '';
+                response.on('data', chunk => (data += chunk));
+                response.on('end', () => {
+                    try {
+                        validateRawAccountInfo(JSON.parse(data));
+                        resolve();
+                    }
+                    catch (err) {
+                        reject(err);
+                    }
+                });
+            });
+            request.on('error', reject);
+        });
+    },
+    url: new URL(exports.RENDER_INFO_URL),
+    cmd: exports.CURL_CMD,
+};

package/dist/troubleshoot/ufg.js

@@ -0,0 +1,130 @@
+"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.getCmd = void 0;
+const https_1 = require("https");
+const crypto_1 = require("crypto");
+const eyes_1 = require("./eyes");
+const ufg_client_1 = require("@applitools/ufg-client");
+const utils_1 = require("./utils");
+const utils = __importStar(require("@applitools/utils"));
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const value = Buffer.from(JSON.stringify({ resources: {}, domNodes: [] }));
+const hash = (0, crypto_1.createHash)('sha256').update(value).digest('hex');
+const contentType = 'x-applitools-html/cdt';
+const resource = {
+    id: 'id',
+    url: 'https://localhost:2107',
+    value,
+    hash: { hashFormat: 'sha256', hash, contentType },
+    contentType,
+};
+const UFG_PUT_RESOURCE_URL = `https://render-wus.applitools.com/sha256/${resource.hash.hash}?render-id=fake`;
+const accessTokenPromise = new Promise(async (resolve) => {
+    const { stdout } = await utils.process.execute(`curl -s ${eyes_1.RENDER_INFO_URL} ${(0, utils_1.getProxyCurlArg)()}`, {
+        maxBuffer: 10000000,
+    });
+    const accessToken = JSON.parse(stdout).accessToken;
+    if (!accessToken)
+        throw new Error('could not receive auth token since cURL command to get it failed.');
+    resolve(accessToken);
+});
+const getCmd = async () => `curl -X PUT -H "Content-Type: application/json" -H "X-Auth-Token: ${await accessTokenPromise}" -d '${resource.value}' ${UFG_PUT_RESOURCE_URL} ${(0, utils_1.getProxyCurlArg)()}`;
+exports.getCmd = getCmd;
+const validateVgResult = (res, sha) => {
+    if (!res || res.hash !== sha) {
+        throw new Error(`bad VG result ${res}`);
+    }
+};
+exports.default = {
+    async testFetch() {
+        const response = await (0, node_fetch_1.default)(UFG_PUT_RESOURCE_URL, {
+            method: 'PUT',
+            headers: {
+                'Content-Type': 'x-applitools-html/cdt',
+                'X-Auth-Token': await accessTokenPromise,
+            },
+            body: resource.value,
+        });
+        const data = await response.json();
+        validateVgResult(data, resource.hash.hash);
+    },
+    async testCurl() {
+        // HTTP_PROXY and HTTPS_PROXY are read by cURL.
+        let proxyUrl;
+        if (utils_1.config.proxy) {
+            proxyUrl = new URL(utils.types.isString(utils_1.config.proxy) ? utils_1.config.proxy : utils_1.config.proxy.url);
+            if (utils_1.config.proxy.username)
+                proxyUrl.username = utils_1.config.proxy.username;
+            if (utils_1.config.proxy.password)
+                proxyUrl.password = utils_1.config.proxy.password;
+        }
+        const { stdout } = await utils.process.execute(await (0, exports.getCmd)(), { maxBuffer: 10000000 });
+        validateVgResult(JSON.parse(stdout), resource.hash.hash);
+    },
+    testServer: async () => {
+        const url = new URL(UFG_PUT_RESOURCE_URL);
+        const requests = (0, ufg_client_1.makeUFGRequests)({
+            config: { serverUrl: url.origin, accessToken: await accessTokenPromise, uploadUrl: '', stitchingServiceUrl: '' },
+            logger: null,
+        });
+        await requests.uploadResource({ resource });
+    },
+    async testHttps() {
+        return new Promise(async (resolve, reject) => {
+            const url = new URL(UFG_PUT_RESOURCE_URL);
+            const request = (0, https_1.request)({
+                host: url.host,
+                path: `${url.pathname}${url.search}`,
+                method: 'PUT',
+                headers: {
+                    'Content-Type': 'x-applitools-html/cdt',
+                    'X-Auth-Token': await accessTokenPromise,
+                },
+            });
+            request.on('response', response => {
+                let data = '';
+                response.on('data', chunk => (data += chunk));
+                response.on('end', () => {
+                    try {
+                        validateVgResult(JSON.parse(data), resource.hash.hash);
+                        resolve();
+                    }
+                    catch (e) {
+                        reject(e);
+                    }
+                });
+            });
+            request.on('error', reject);
+            request.write(resource.value);
+            request.end();
+        });
+    },
+    url: new URL(UFG_PUT_RESOURCE_URL),
+    getCmd: exports.getCmd,
+};

package/dist/troubleshoot/utils.js

@@ -0,0 +1,68 @@
+"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.ptimeoutWithError = exports.presult = exports.getProxyCurlArg = exports.config = void 0;
+const utils = __importStar(require("@applitools/utils"));
+exports.config = {
+    serverUrl: 'https://eyesapi.applitools.com',
+    ...utils.config.getConfig({ params: ['apiKey', 'serverUrl', 'proxy'] }),
+};
+function getProxyCurlArg() {
+    // HTTP_PROXY and HTTPS_PROXY are read by cURL.
+    let proxyUrl;
+    if (exports.config.proxy) {
+        proxyUrl = new URL(utils.types.isString(exports.config.proxy) ? exports.config.proxy : exports.config.proxy.url);
+        if (exports.config.proxy.username)
+            proxyUrl.username = exports.config.proxy.username;
+        if (exports.config.proxy.password)
+            proxyUrl.password = exports.config.proxy.password;
+    }
+    return proxyUrl ? `-x ${proxyUrl.href}` : '';
+}
+exports.getProxyCurlArg = getProxyCurlArg;
+function presult(promise) {
+    return promise.then(v => [undefined, v], err => [err]);
+}
+exports.presult = presult;
+async function ptimeoutWithError(promiseOrPromiseFunc, timeout, err) {
+    let promiseResolved = false;
+    const hasAborted = () => promiseResolved;
+    const promise = promiseOrPromiseFunc.then ? promiseOrPromiseFunc : promiseOrPromiseFunc(hasAborted);
+    let cancel;
+    const v = await Promise.race([
+        promise.then(v => ((promiseResolved = true), cancel && clearTimeout(cancel), v), err => ((promiseResolved = true), cancel && clearTimeout(cancel), Promise.reject(err))),
+        new Promise(res => (cancel = setTimeout(() => {
+            if (promiseResolved)
+                res(undefined);
+            else {
+                cancel = undefined;
+                promiseResolved = true;
+                res(Promise.reject(err));
+            }
+        }, timeout))),
+    ]);
+    return v;
+}
+exports.ptimeoutWithError = ptimeoutWithError;

package/dist/ufg/abort.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeAbort = void 0;
+function makeAbort({ storage, controller, logger: defaultLogger }) {
+    return async function ({ logger = defaultLogger, } = {}) {
+        controller.abort();
+        const results = await Promise.allSettled(storage);
+        const eyes = results.reduce((eyes, result) => {
+            const value = result.status === 'fulfilled' ? result.value : result.reason;
+            return eyes.set(value.eyes, value.renderer);
+        }, new Map());
+        return Promise.all(Array.from(eyes.entries(), async ([eyes, renderer]) => {
+            const [result] = await eyes.abort({ logger });
+            return { ...result, renderer };
+        }));
+    };
+}
+exports.makeAbort = makeAbort;

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeCheckAndClose = void 0;
+function makeCheckAndClose(_options) {
+    return null;
+}
+exports.makeCheckAndClose = makeCheckAndClose;

package/dist/ufg/check.js

@@ -0,0 +1,192 @@
+"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.makeCheck = void 0;
+const driver_1 = require("@applitools/driver");
+const take_snapshots_1 = require("./utils/take-snapshots");
+const wait_for_lazy_load_1 = require("../utils/wait-for-lazy-load");
+const to_base_check_settings_1 = require("../utils/to-base-check-settings");
+const generate_safe_selectors_1 = require("./utils/generate-safe-selectors");
+const utils = __importStar(require("@applitools/utils"));
+function makeCheck({ spec, getEyes, client, test, signal, target: defaultTarget, logger: defaultLogger, }) {
+    return async function check({ target = defaultTarget, settings = {}, logger = defaultLogger, }) {
+        var _a, _b;
+        logger.log('Command "check" is called with settings', settings);
+        if (signal.aborted) {
+            logger.warn('Command "check" was called after test was already aborted');
+            throw new Error('Command "check" was called after test was already aborted');
+        }
+        const { elementReferencesToCalculate, elementReferenceToTarget, getBaseCheckSettings } = (0, to_base_check_settings_1.toBaseCheckSettings)({ settings });
+        let snapshots, snapshotUrl, snapshotTitle, regionToTarget, selectorsToCalculate;
+        if (spec === null || spec === void 0 ? void 0 : spec.isDriver(target)) {
+            // TODO driver custom config
+            const driver = await (0, driver_1.makeDriver)({ spec, driver: target, logger });
+            const viewportSize = await driver.getViewportSize();
+            if (driver.isWeb && (!settings.renderers || settings.renderers.length === 0)) {
+                settings.renderers = [{ name: 'chrome', ...viewportSize }];
+            }
+            let cleanupGeneratedSelectors;
+            if (driver.isWeb) {
+                const generated = await (0, generate_safe_selectors_1.generateSafeSelectors)({
+                    context: driver.currentContext,
+                    elementReferences: [...(elementReferenceToTarget ? [elementReferenceToTarget] : []), ...elementReferencesToCalculate],
+                });
+                cleanupGeneratedSelectors = generated.cleanupGeneratedSelectors;
+                if (elementReferenceToTarget) {
+                    regionToTarget = (_a = generated.selectors[0]) === null || _a === void 0 ? void 0 : _a.safeSelector;
+                    if (!regionToTarget)
+                        throw new Error('Target element not found');
+                    selectorsToCalculate = generated.selectors.slice(1);
+                }
+                else {
+                    selectorsToCalculate = generated.selectors;
+                }
+            }
+            snapshots = await (0, take_snapshots_1.takeSnapshots)({
+                driver,
+                settings: {
+                    ...test.server,
+                    waitBeforeCapture: settings.waitBeforeCapture,
+                    disableBrowserFetching: settings.disableBrowserFetching,
+                    layoutBreakpoints: settings.layoutBreakpoints,
+                    renderers: settings.renderers,
+                    skipResources: client.getCachedResourceUrls(),
+                },
+                hooks: {
+                    async beforeSnapshots() {
+                        if (driver.isWeb && settings.lazyLoad) {
+                            await (0, wait_for_lazy_load_1.waitForLazyLoad)({ driver, settings: settings.lazyLoad !== true ? settings.lazyLoad : {}, logger });
+                        }
+                    },
+                },
+                provides: {
+                    getChromeEmulationDevices: client.getChromeEmulationDevices,
+                    getIOSDevices: client.getIOSDevices,
+                },
+                logger,
+            });
+            snapshotUrl = await driver.getUrl();
+            snapshotTitle = await driver.getTitle();
+            await (cleanupGeneratedSelectors === null || cleanupGeneratedSelectors === void 0 ? void 0 : cleanupGeneratedSelectors());
+        }
+        else {
+            snapshots = !utils.types.isArray(target) ? Array(settings.renderers.length).fill(target) : target;
+            snapshotUrl = utils.types.has(snapshots[0], 'url') ? snapshots[0].url : undefined;
+        }
+        regionToTarget !== null && regionToTarget !== void 0 ? regionToTarget : (regionToTarget = (_b = elementReferenceToTarget) !== null && _b !== void 0 ? _b : settings.region);
+        selectorsToCalculate !== null && selectorsToCalculate !== void 0 ? selectorsToCalculate : (selectorsToCalculate = elementReferencesToCalculate.map(selector => ({
+            originalSelector: selector,
+            safeSelector: selector,
+        })));
+        const promises = settings.renderers.map(async (renderer, index) => {
+            try {
+                if (signal.aborted) {
+                    logger.warn('Command "check" was aborted before rendering');
+                    throw new Error('Command "check" was aborted before rendering');
+                }
+                const { cookies, ...snapshot } = snapshots[index];
+                const renderTargetPromise = client.createRenderTarget({
+                    snapshot,
+                    settings: { renderer, referer: snapshotUrl, cookies, proxy: test.server.proxy, autProxy: settings.autProxy },
+                });
+                const request = {
+                    target: null,
+                    settings: {
+                        ...settings,
+                        region: regionToTarget,
+                        type: utils.types.has(snapshot, 'cdt') ? 'web' : 'native',
+                        renderer,
+                        selectorsToCalculate: selectorsToCalculate.map(({ safeSelector }) => safeSelector),
+                        includeFullPageSize: Boolean(settings.pageId),
+                    },
+                };
+                const { rendererId, rawEnvironment } = await client.bookRenderer({ settings: request.settings });
+                const eyes = await getEyes({ rawEnvironment });
+                try {
+                    if (signal.aborted) {
+                        logger.warn('Command "check" was aborted before rendering');
+                        throw new Error('Command "check" was aborted before rendering');
+                    }
+                    else if (eyes.aborted) {
+                        logger.warn(`Renderer with id ${rendererId} was aborted during one of the previous steps`);
+                        throw new Error(`Renderer with id "${rendererId}" was aborted during one of the previous steps`);
+                    }
+                    request.settings.rendererId = rendererId;
+                    request.target = await renderTargetPromise;
+                    if (signal.aborted) {
+                        logger.warn('Command "check" was aborted before rendering');
+                        throw new Error('Command "check" was aborted before rendering');
+                    }
+                    else if (eyes.aborted) {
+                        logger.warn(`Renderer with id ${rendererId} was aborted during one of the previous steps`);
+                        throw new Error(`Renderer with id "${rendererId}" was aborted during one of the previous steps`);
+                    }
+                    const { renderId, selectorRegions, ...baseTarget } = await client.render({ request, signal });
+                    const baseSettings = getBaseCheckSettings({
+                        calculatedRegions: selectorsToCalculate.map(({ originalSelector }, index) => ({
+                            selector: originalSelector,
+                            regions: selectorRegions[index],
+                        })),
+                    });
+                    baseSettings.renderId = renderId;
+                    baseTarget.source = snapshotUrl;
+                    baseTarget.name = snapshotTitle;
+                    if (signal.aborted) {
+                        logger.warn('Command "check" was aborted after rendering');
+                        throw new Error('Command "check" was aborted after rendering');
+                    }
+                    else if (eyes.aborted) {
+                        logger.warn(`Renderer with id ${rendererId} was aborted during one of the previous steps`);
+                        throw new Error(`Renderer with id "${rendererId}" was aborted during one of the previous steps`);
+                    }
+                    const [result] = await eyes.check({ target: baseTarget, settings: baseSettings, logger });
+                    if (eyes.aborted) {
+                        logger.warn(`Renderer with id ${rendererId} was aborted during one of the previous steps`);
+                        throw new Error(`Renderer with id "${rendererId}" was aborted during one of the previous steps`);
+                    }
+                    return { ...result, eyes, renderer };
+                }
+                catch (error) {
+                    error.eyes = eyes;
+                    await eyes.abort();
+                    throw error;
+                }
+            }
+            catch (error) {
+                error.userTestId = test.userTestId;
+                error.renderer = renderer;
+                throw error;
+            }
+        });
+        return settings.renderers.map((renderer, index) => ({
+            asExpected: true,
+            windowId: null,
+            userTestId: test.userTestId,
+            renderer,
+            promise: promises[index],
+        }));
+    };
+}
+exports.makeCheck = makeCheck;

package/dist/ufg/close.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeClose = void 0;
+function makeClose({ storage, logger: defaultLogger }) {
+    return async function ({ settings, logger = defaultLogger, } = {}) {
+        const results = await Promise.allSettled(storage);
+        let error;
+        const eyes = results.reduce((eyes, result) => {
+            let value;
+            if (result.status === 'fulfilled') {
+                value = result.value;
+            }
+            else {
+                value = result.reason;
+                error !== null && error !== void 0 ? error : (error = result.reason);
+            }
+            return eyes.set(value.eyes, value.renderer);
+        }, new Map());
+        if (error) {
+            await Promise.all(Array.from(eyes.entries(), async ([eyes]) => eyes.abort({ logger })));
+            throw error;
+        }
+        else {
+            return Promise.all(Array.from(eyes.entries(), async ([eyes, renderer]) => {
+                const [result] = await eyes.close({ settings, logger });
+                return { ...result, renderer };
+            }));
+        }
+    };
+}
+exports.makeClose = makeClose;