@applitools/core 4.19.0 → 4.20.0

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## [4.20.0](https://github.com/Applitools-Dev/sdk/compare/js/core@4.19.0...js/core@4.20.0) (2024-09-30)
+
+
+### Features
+
+* offline execution ([#2528](https://github.com/Applitools-Dev/sdk/issues/2528)) ([e6c3b9e](https://github.com/Applitools-Dev/sdk/commit/e6c3b9e3315203027551da3bfdecf90490edd029))
+
+
+### Dependencies
+
+* @applitools/ufg-client bumped to 1.13.0
+  #### Features
+
+  * offline execution ([#2528](https://github.com/Applitools-Dev/sdk/issues/2528)) ([e6c3b9e](https://github.com/Applitools-Dev/sdk/commit/e6c3b9e3315203027551da3bfdecf90490edd029))
+* @applitools/core-base bumped to 1.17.0
+  #### Features
+
+  * offline execution ([#2528](https://github.com/Applitools-Dev/sdk/issues/2528)) ([e6c3b9e](https://github.com/Applitools-Dev/sdk/commit/e6c3b9e3315203027551da3bfdecf90490edd029))
+* @applitools/ec-client bumped to 1.9.6
+
+
 ## [4.19.0](https://github.com/Applitools-Dev/sdk/compare/js/core@4.18.2...js/core@4.19.0) (2024-09-16)
 
 

package/dist/autonomous/core.js

@@ -14,7 +14,7 @@ function makeAutonomousCore({ spec, clients, base: defaultBase, asyncCache, agen
     const core = (0, core_1.makeCore)({ spec, clients, base: defaultBase, asyncCache, agentId, cwd, logger });
     return {
         type: 'autonomous',
-        takeSnapshots: spec && (0, take_snapshots_1.makeTakeSnapshots)({ core, logger }),
+        takeSnapshots: spec && (0, take_snapshots_1.makeTakeSnapshots)({ core, spec, logger }),
         createRenderTarget: (0, create_render_target_1.makeCreateRenderTarget)({ core, logger }),
         startRenders: (0, start_renders_1.makeStartRenders)({ core, logger }),
         getRenderResults: (0, get_render_results_1.makeGetRenderResults)({ core, logger }),

package/dist/autonomous/create-render-target.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeCreateRenderTarget = void 0;
+const create_render_target_from_snapshot_1 = require("../ufg/create-render-target-from-snapshot");
 function makeCreateRenderTarget({ core, logger: defaultLogger }) {
     return async function createRenderTarget({ snapshot, logger = defaultLogger, }) {
         const ufgClient = await core.getUFGClient({
@@ -11,21 +12,7 @@ function makeCreateRenderTarget({ core, logger: defaultLogger }) {
             },
             logger,
         });
-        const target = await ufgClient.createRenderTarget({
-            snapshot: snapshot.target,
-            settings: {
-                environment: snapshot.environment,
-                cookies: snapshot.target.cookies,
-                headers: {
-                    Referer: snapshot.url,
-                    'User-Agent': snapshot.userAgent,
-                    ...snapshot.settings.headers,
-                },
-                proxy: snapshot.account.eyesServer.proxy,
-                autProxy: snapshot.settings.autProxy,
-            },
-            logger,
-        });
+        const target = await (0, create_render_target_from_snapshot_1.createRenderTargetFromSnapshot)({ ufgClient, snapshot, logger });
         return { ...snapshot, target };
     };
 }

package/dist/autonomous/take-snapshots.js

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

package/dist/classic/core.js

@@ -34,10 +34,10 @@ const extract_text_1 = require("../automation/extract-text");
 const get_nml_client_1 = require("../automation/get-nml-client");
 const open_eyes_1 = require("./open-eyes");
 const utils = __importStar(require("@applitools/utils"));
-function makeCore({ spec, clients, base: defaultBase, concurrency, agentId = 'core-classic', cwd = process.cwd(), logger: defaultLogger, }) {
+function makeCore({ spec, clients, base: defaultBase, concurrency, agentId = 'core-classic', cwd = process.cwd(), logger: defaultLogger, offlineLocationPath, }) {
     const logger = (0, logger_1.makeLogger)({ logger: defaultLogger, format: { label: 'core-classic' } });
     logger.log(`Core classic is initialized ${defaultBase ? 'with' : 'without'} custom base core`);
-    const base = defaultBase !== null && defaultBase !== void 0 ? defaultBase : (0, core_base_1.makeCore)({ agentId, concurrency, cwd, logger });
+    const base = defaultBase !== null && defaultBase !== void 0 ? defaultBase : (0, core_base_1.makeCore)({ agentId, concurrency, cwd, logger, offlineLocationPath });
     return utils.general.extend(base, core => {
         return {
             type: 'classic',

package/dist/cli/cli.js

@@ -32,6 +32,7 @@ const core_server_1 = require("../universal/core-server");
 const core_server_process_1 = require("../universal/core-server-process");
 const logs_1 = require("../troubleshoot/logs");
 const check_network_1 = require("../troubleshoot/check-network");
+const run_offline_snapshots_1 = require("../run-offline-snapshots");
 const yargs_1 = __importDefault(require("yargs"));
 const utils = __importStar(require("@applitools/utils"));
 const fs_1 = __importDefault(require("fs"));
@@ -151,5 +152,24 @@ yargs_1.default
     handler: async () => {
         await (0, check_network_1.checkNetwork)();
     },
+})
+    .command({
+    command: 'run-offline-snapshots',
+    builder: yargs => yargs
+        .options({
+        offlineLocationPath: {
+            description: 'path to offline snapshots folder',
+            type: 'string',
+        },
+    })
+        .fail((_msg, err, _yargs) => {
+        if (err) {
+            console.error(err.message);
+            process.exit(1);
+        }
+    }),
+    handler: async (args) => {
+        await (0, run_offline_snapshots_1.runOfflineSnapshots)(args);
+    },
 })
     .wrap(yargs_1.default.terminalWidth()).argv;

package/dist/core.js

@@ -41,6 +41,7 @@ const make_manager_1 = require("./make-manager");
 const close_batch_1 = require("./close-batch");
 const delete_test_1 = require("./delete-test");
 const extract_test_environment_1 = require("./utils/extract-test-environment");
+const ensure_offline_folder_1 = require("./utils/ensure-offline-folder");
 const validate_sdk_version_1 = require("./utils/validate-sdk-version");
 const memory_usage_logging_1 = require("./utils/memory-usage-logging");
 const utils = __importStar(require("@applitools/utils"));
@@ -51,10 +52,11 @@ function makeCore({ spec, clients, base: defaultBase, concurrency = utils.genera
     logger.log(`Core is initialized ${defaultBase ? 'with' : 'without'} custom base core and environment `, environment);
     if (environment.sdk)
         (0, validate_sdk_version_1.validateSdkVersion)(environment.sdk, { logger });
-    const base = defaultBase !== null && defaultBase !== void 0 ? defaultBase : (0, core_base_1.makeCore)({ agentId, concurrency, cwd, logger });
+    const offlineLocationPath = (0, ensure_offline_folder_1.ensureOfflineFolder)();
+    const base = defaultBase !== null && defaultBase !== void 0 ? defaultBase : (0, core_base_1.makeCore)({ agentId, concurrency, cwd, logger, offlineLocationPath });
     const cores = {
-        ufg: (0, core_2.makeCore)({ spec, clients, base, asyncCache, logger }),
-        classic: (0, core_1.makeCore)({ spec, clients, base, logger }),
+        ufg: (0, core_2.makeCore)({ spec, clients, base, asyncCache, logger, offlineLocationPath }),
+        classic: (0, core_1.makeCore)({ spec, clients, base, logger, offlineLocationPath }),
     };
     return utils.general.extend(base, core => {
         return {
@@ -76,6 +78,7 @@ function makeCore({ spec, clients, base: defaultBase, concurrency = utils.genera
                 environment,
                 asyncCache,
                 logger,
+                offlineLocationPath,
             }),
             locate: (0, locate_1.makeLocate)({ spec, core, logger }),
             locateText: (0, locate_text_1.makeLocateText)({ spec, core, logger }),

package/dist/make-manager.js

@@ -30,7 +30,7 @@ const core_2 = require("./ufg/core");
 const open_eyes_1 = require("./open-eyes");
 const get_manager_results_1 = require("./get-manager-results");
 const utils = __importStar(require("@applitools/utils"));
-function makeMakeManager({ spec, clients, core, base: defaultBase, agentId: defaultAgentId, environment, cwd = process.cwd(), logger: mainLogger, asyncCache, }) {
+function makeMakeManager({ spec, clients, core, base: defaultBase, agentId: defaultAgentId, environment, cwd = process.cwd(), logger: mainLogger, asyncCache, offlineLocationPath, }) {
     return async function makeManager({ type = 'classic', settings, logger = mainLogger, } = {}) {
         var _a, _b, _c, _d, _e, _f, _g;
         var _h, _j;
@@ -42,9 +42,10 @@ function makeMakeManager({ spec, clients, core, base: defaultBase, agentId: defa
         (_f = (_j = settings.batch).buildId) !== null && _f !== void 0 ? _f : (_j.buildId = utils.general.getEnvValue('BATCH_BUILD_ID'));
         (_g = settings.agentId) !== null && _g !== void 0 ? _g : (settings.agentId = type === 'ufg' ? defaultAgentId === null || defaultAgentId === void 0 ? void 0 : defaultAgentId.replace(/(\/\d)/, '.visualgrid$1') : defaultAgentId);
         logger.log('Command "makeManager" is called with settings', settings);
-        const base = defaultBase !== null && defaultBase !== void 0 ? defaultBase : (0, core_base_1.makeCore)({ agentId: settings.agentId, concurrency: settings.concurrency, cwd, logger });
+        const base = defaultBase !== null && defaultBase !== void 0 ? defaultBase : (0, core_base_1.makeCore)({ agentId: settings.agentId, concurrency: settings.concurrency, cwd, logger, offlineLocationPath });
+        const fetchConcurrency = settings.fetchConcurrency;
         const cores = {
-            ufg: (0, core_2.makeCore)({ spec, clients, base, fetchConcurrency: settings.fetchConcurrency, asyncCache, logger }),
+            ufg: (0, core_2.makeCore)({ spec, clients, base, fetchConcurrency, asyncCache, logger, offlineLocationPath }),
             classic: (0, core_1.makeCore)({ spec, clients, base, logger }),
         };
         const storage = [];

package/dist/open-eyes.js

@@ -35,6 +35,7 @@ const abort_1 = require("./abort");
 const get_eyes_results_1 = require("./get-eyes-results");
 const populate_eyes_server_settings_1 = require("./utils/populate-eyes-server-settings");
 const utils = __importStar(require("@applitools/utils"));
+const core_base_1 = require("@applitools/core-base");
 function makeOpenEyes({ type: defaultType = 'classic', clients, batch, removeDuplicateTests, core, cores, spec, environment, logger: mainLogger, asyncCache, }) {
     return async function openEyes({ type = defaultType, settings, config, target, logger = mainLogger, }) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u;
@@ -98,7 +99,9 @@ function makeOpenEyes({ type: defaultType = 'classic', clients, batch, removeDup
             },
             logger,
         });
-        const eyes = await getTypedEyes({ logger });
+        const eyes = await getTypedEyes({ logger }).catch(error => {
+            throw refineMissingApiKeyException(error, environment === null || environment === void 0 ? void 0 : environment.sdk);
+        });
         return utils.general.extend(eyes, eyes => {
             var _a, _b;
             return ({
@@ -113,6 +116,63 @@ function makeOpenEyes({ type: defaultType = 'classic', clients, batch, removeDup
     };
 }
 exports.makeOpenEyes = makeOpenEyes;
+function refineMissingApiKeyException(error, sdk) {
+    var _a;
+    if (!sdk || typeof sdk !== 'object')
+        return error;
+    try {
+        if (error instanceof core_base_1.MissingApiKeyError) {
+            const apiKeyTutorials = {
+                python: {
+                    'eyes-selenium': 'api-ref/sdk-api/selenium/python/#API',
+                    'eyes-playwright': 'api-ref/sdk-api/playwright/python/#API',
+                    'eyes-robotframework': 'api-ref/sdk-api/robot/#API',
+                    'eyes-images': undefined,
+                },
+                ruby: {
+                    eyes_images: 'api-ref/sdk-api/selenium/ruby/#API',
+                    eyes_appium: undefined,
+                    eyes_selenium: undefined,
+                    eyes_universal: undefined,
+                    eyes_capybara: undefined,
+                    eyes_calabash: undefined,
+                },
+                java: {
+                    java_appium: undefined,
+                    java_selenium: 'api-ref/sdk-api/selenium/java/#API',
+                    java_playwright: 'api-ref/sdk-api/playwright/java/#API',
+                    java_images: undefined,
+                },
+                dotnet: {
+                    'eyes-selenium': 'api-ref/sdk-api/selenium/csharp/#API',
+                    'eyes-playwright': 'api-ref/sdk-api/playwright/csharp/#API',
+                    'eyes-appium': undefined,
+                    'eyes-appium2': undefined,
+                    'eyes-images': undefined,
+                },
+                js: {
+                    'eyes-images': undefined,
+                    'eyes-webdriverio': 'api-ref/sdk-api/wdio/#API',
+                    'eyes-selenium': 'api-ref/sdk-api/selenium/javascript/#API',
+                    'eyes-playwright': 'api-ref/sdk-api/playwright/javascript/#API',
+                    'eyes-puppeteer': 'api-ref/sdk-api/puppeteer/javascript/#API',
+                    'eyes-storybook': 'api-ref/sdk-api/storybook/#API',
+                    'eyes-cypress': 'api-ref/sdk-api/cypress/#API',
+                },
+            };
+            const { lang, name } = sdk !== null && sdk !== void 0 ? sdk : {};
+            const path = (_a = apiKeyTutorials[lang]) === null || _a === void 0 ? void 0 : _a[name];
+            if (path) {
+                error.message = error.message.replace('Default.html#cshid=api', path);
+            }
+        }
+    }
+    catch {
+        // if it fails, no harm done. The error message is fine without this refinement
+        return error;
+    }
+    return error;
+}
 function getLatestCommitInfoFromEnvVars(logger) {
     const timestamp = utils.general.getEnvValue('GIT_LATEST_COMMIT_TIMESTAMP');
     const sha = utils.general.getEnvValue('GIT_LATEST_COMMIT_SHA');

package/dist/run-offline-snapshots.js

@@ -0,0 +1,346 @@
+"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.runOfflineSnapshots = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const tar = __importStar(require("tar"));
+const core_1 = require("./core");
+const get_ufg_client_1 = require("./ufg/get-ufg-client");
+const logger_1 = require("@applitools/logger");
+const to_base_check_settings_1 = require("./automation/utils/to-base-check-settings");
+const chalk_1 = __importDefault(require("chalk"));
+const utils = __importStar(require("@applitools/utils"));
+async function runOfflineSnapshots(options) {
+    if (!options.offlineLocationPath)
+        throw new Error('offlineLocationPath is required');
+    const startTime = Date.now();
+    const logger = (0, logger_1.makeLogger)({ format: { label: 'offline-exec' } });
+    const core = (0, core_1.makeCore)();
+    const account = await core.getAccountInfo({ settings: options });
+    const ufgClient = await (0, get_ufg_client_1.makeGetUFGClient)({ logger })({
+        settings: { ...account.eyesServer, ...account.ufgServer },
+    });
+    const executionFiles = (await fs_1.default.promises.readdir(options.offlineLocationPath)).filter(filename => filename.endsWith('.tar.gz'));
+    if (executionFiles.length === 1) {
+        logger.console.log(`Running execution ${executionFiles[0]} from folder ${path_1.default.resolve(options.offlineLocationPath)}`);
+    }
+    else if (executionFiles.length === 0) {
+        logger.console.log('No execution artifacts were found at', options.offlineLocationPath);
+    }
+    else {
+        logger.console.log(`Running the following executions from folder ${options.offlineLocationPath} :\n  ${executionFiles.join('\n  ')}`);
+    }
+    if (executionFiles.length === 0) {
+        throw new Error(`Unable to find offline executions in ${options.offlineLocationPath}`);
+    }
+    const allTestResults = (await Promise.all(executionFiles.map(runExecution))).flat();
+    const { exitCode, outputStr } = processResults({ testResults: allTestResults, totalTime: Date.now() - startTime });
+    if (exitCode) {
+        throw new Error(outputStr);
+    }
+    else {
+        logger.console.log(outputStr);
+    }
+    async function runExecution(executionFile) {
+        const executionName = executionFile.replace('.tar.gz', '');
+        const executionLogger = logger.extend({ tags: [executionName] });
+        executionLogger.log('unpacking execution', executionFile);
+        await tar.extract({
+            file: path_1.default.resolve(options.offlineLocationPath, executionFile),
+            gzip: true,
+            C: options.offlineLocationPath,
+        });
+        const executionPath = path_1.default.resolve(options.offlineLocationPath, executionName);
+        executionLogger.log('handling execution', executionPath);
+        const testFolders = (await fs_1.default.promises.readdir(executionPath)).filter(foldername => foldername.startsWith('test-'));
+        executionLogger.log('running tests', testFolders);
+        const results = await Promise.all(testFolders.map(async (testFolder) => {
+            const testLogger = logger.extend({ tags: [testFolder] });
+            const testPath = path_1.default.resolve(executionPath, testFolder);
+            const openSettings = (await fs_1.default.promises
+                .readFile(path_1.default.resolve(testPath, 'settings.json'), 'utf-8')
+                .then(JSON.parse));
+            logger.console.log(`Running test: ${openSettings.testName} (${formatEnvironment(openSettings.environment)})`);
+            return runTest(executionPath, testPath, openSettings, testLogger);
+        }));
+        const batchIds = [...new Set(results.map(t => t.batchId))];
+        const allTestResults = results.map(t => t.results);
+        executionLogger.log('done running all tests', allTestResults);
+        // @ts-expect-error // we use node v12 types, therefore it's not aware of the existence of `fs.promises.rm`
+        await fs_1.default.promises.rm(executionPath, { recursive: true });
+        await core.closeBatch({ settings: batchIds.map(batchId => ({ batchId, ...account.eyesServer })) });
+        executionLogger.log('one execution', executionFile);
+        return allTestResults;
+    }
+    async function runTest(executionPath, testPath, openSettings, logger) {
+        const environment = await ufgClient.getActualEnvironment({
+            settings: { environment: openSettings.environment.requested },
+        });
+        const eyes = await core.base.openEyes({
+            settings: {
+                ...openSettings,
+                environment: {
+                    ...openSettings.environment,
+                    ...environment,
+                },
+                ...account.eyesServer,
+            },
+            logger,
+        });
+        const checkFolders = (await fs_1.default.promises.readdir(testPath)).filter(folderpath => folderpath.startsWith('check-'));
+        logger.log('running checks for test', testPath, ':', checkFolders);
+        const targets = (await Promise.all(checkFolders.map(checkFolder => fs_1.default.promises.readFile(path_1.default.resolve(testPath, checkFolder, 'snapshot.json'), 'utf-8').then(JSON.parse))));
+        await uploadResources(executionPath, targets, logger);
+        // logger.log('resource hashes for test', testFolder, ':', resourceHashes)
+        logger.log('uploaded resources for test', testPath);
+        await Promise.all(targets.map((target, index) => runCheck(eyes, target, index, logger)));
+        await eyes.close({
+            settings: await fs_1.default.promises.readFile(path_1.default.resolve(testPath, 'close.json'), 'utf-8').then(JSON.parse),
+        });
+        logger.log('done running test', logger);
+        return { batchId: openSettings.batch.id, results: (await eyes.getResults({ logger }))[0] };
+    }
+    async function uploadResources(executionPath, targets, logger) {
+        const uploadLogger = logger.extend({ tags: ['upload-resources'] });
+        const promises = targets.map(async ({ target }) => {
+            let resourcePromises = Object.values(target.resources)
+                .filter(isHashedResource)
+                .map(async (resource) => {
+                const contentfuleResource = {
+                    id: '',
+                    url: '',
+                    value: await fs_1.default.promises.readFile(path_1.default.resolve(executionPath, 'resources', resource.hash)),
+                    contentType: resource.contentType,
+                    hash: resource,
+                };
+                return ufgClient.uploadResource({ resource: contentfuleResource, logger: uploadLogger });
+            });
+            resourcePromises = resourcePromises.concat(ufgClient.uploadResource({
+                resource: {
+                    id: '',
+                    url: '',
+                    value: await fs_1.default.promises.readFile(path_1.default.resolve(executionPath, 'resources', target.snapshot.hash)),
+                    contentType: target.snapshot.contentType,
+                    hash: target.snapshot,
+                },
+                logger: uploadLogger,
+            }));
+            return Promise.all(resourcePromises);
+        });
+        await Promise.all(promises);
+        function isHashedResource(resource) {
+            return 'hash' in resource;
+        }
+    }
+    async function runCheck(eyes, target, index, logger) {
+        var _a;
+        const checkLogger = logger.extend({ tags: [`check-${index}`] });
+        const { elementReferences: selectors, getBaseCheckSettings } = (0, to_base_check_settings_1.toBaseCheckSettings)({
+            settings: target.settings,
+        });
+        const { renderId, selectorRegions, ...baseTarget } = await ufgClient.render({
+            target: target.target,
+            settings: {
+                ...target.settings,
+                region: (_a = selectors.target) !== null && _a !== void 0 ? _a : target.settings.region,
+                scrollRootElement: selectors.scrolling,
+                selectorsToCalculate: selectors.calculate,
+                includeFullPageSize: Boolean(target.settings.pageId),
+                environment: target.settings.environment,
+                uploadUrl: account.uploadUrl,
+                stitchingServiceUrl: account.stitchingServiceUrl,
+            },
+            logger: checkLogger,
+        });
+        const baseSettings = getBaseCheckSettings({
+            calculatedRegions: selectors.calculate.map((_, index) => {
+                var _a;
+                return ({
+                    regions: (_a = selectorRegions === null || selectorRegions === void 0 ? void 0 : selectorRegions[index]) !== null && _a !== void 0 ? _a : [],
+                });
+            }),
+        });
+        baseSettings.renderId = renderId;
+        baseSettings.stepIndex = index;
+        baseTarget.source = target.target.source; // TODO verify
+        // baseTarget.name = snapshot.title // TODO figure out
+        await eyes.check({
+            target: { ...baseTarget, isTransformed: true },
+            settings: baseSettings,
+            logger: checkLogger,
+        });
+    }
+}
+exports.runOfflineSnapshots = runOfflineSnapshots;
+function uniq(arr) {
+    return [...new Set(arr)];
+}
+function processResults({ testResults, totalTime, saveNewTests = true, failOnDiff = true, }) {
+    let outputStr = '\n';
+    const pluralize = utils.general.pluralize;
+    const testResultsWithErrors = testResults.filter(r => r && r.reason);
+    const unresolved = testResults.filter(r => r.isDifferent && !r.isAborted);
+    const passedOrNew = testResults.filter(r => r.status === 'Passed' || (r.isNew && !r.isAborted));
+    const aborted = testResults.filter(r => r.isAborted);
+    const newTests = testResults.filter(r => r.isNew && !r.isAborted);
+    const failedTests = testResults.filter(r => !r.reason && !r.isNew && !r.isAborted && !r.isDifferent && r.status === 'Failed');
+    const newTestsSize = newTests.length;
+    const warnForUnsavedNewTests = !!(!saveNewTests && newTestsSize);
+    const errMessagesToExclude = ['detected differences', 'Please approve the new baseline', 'is failed! See details at'];
+    const errors = testResultsWithErrors
+        .filter(r => !errMessagesToExclude.some(msg => { var _a, _b; return (_b = (_a = r.reason) === null || _a === void 0 ? void 0 : _a.message) === null || _b === void 0 ? void 0 : _b.includes(msg); }))
+        .map(r => ({
+        error: r.reason,
+        title: r.name,
+    }));
+    const hasResults = unresolved.length || passedOrNew.length || aborted.length;
+    const seeDetailsStr = hasResults && `See details at ${(passedOrNew[0] || unresolved[0] || aborted[0]).appUrls.batch}`;
+    if (hasResults) {
+        outputStr += `${seeDetailsStr}\n\n`;
+    }
+    outputStr += '[EYES: TEST RESULTS]:\n\n';
+    if (passedOrNew.length > 0) {
+        outputStr += testResultsOutput(passedOrNew, warnForUnsavedNewTests);
+    }
+    if (failedTests.length > 0) {
+        outputStr += testResultsOutput(failedTests, warnForUnsavedNewTests);
+    }
+    if (unresolved.length > 0) {
+        outputStr += testResultsOutput(unresolved, warnForUnsavedNewTests);
+    }
+    if (aborted.length > 0) {
+        outputStr += testResultsOutput(aborted, warnForUnsavedNewTests);
+    }
+    if (errors.length) {
+        const sortedErrors = errors.sort((a, b) => a.title.localeCompare(b.title));
+        outputStr += uniq(sortedErrors.map(({ title, error }) => `${title} - ${chalk_1.default.red('Failed')}. ${error.message || error.toString()}`)).join('\n');
+        outputStr += '\n';
+    }
+    if (!errors.length && !hasResults) {
+        outputStr += 'Test is finished but no results returned.\n';
+    }
+    const unresolvedOrFailed = unresolved.concat(failedTests);
+    if (errors.length && !unresolvedOrFailed.length) {
+        outputStr += chalk_1.default.red(`\nA total of ${errors.length} test${pluralize(errors.length)} failed for unexpected error${pluralize(errors.length)}.`);
+    }
+    else if (unresolvedOrFailed.length && !errors.length) {
+        outputStr += chalk_1.default.keyword(failedTests.length ? 'red' : 'orange')(`\nA total of ${unresolvedOrFailed.length} difference${pluralize(unresolvedOrFailed.length, [
+            's were',
+            ' was',
+        ])} found.`);
+    }
+    else if (unresolvedOrFailed.length || errors.length) {
+        outputStr += chalk_1.default.red(`\nA total of ${unresolvedOrFailed.length} difference${pluralize(unresolvedOrFailed.length, [
+            's were',
+            ' was',
+        ])} found and ${errors.length} test${pluralize(errors.length)} failed for ${pluralize(errors.length, [
+            '',
+            'an ',
+        ])}unexpected error${pluralize(errors.length)}.`);
+    }
+    else if (warnForUnsavedNewTests) {
+        const countText = newTestsSize > 1 ? `are ${newTestsSize} new tests` : `is a new test: '${newTests[0].name}'`;
+        outputStr += chalk_1.default.red(`\n'saveNewTests' was set to false and there ${countText}. Please approve ${pluralize(newTestsSize, [
+            'their',
+            'its',
+        ])} baseline${pluralize(newTestsSize)} in Eyes dashboard.\n`);
+    }
+    else if (passedOrNew.length) {
+        outputStr += chalk_1.default.green(`\nNo differences were found!`);
+    }
+    if (hasResults) {
+        outputStr += `\n${seeDetailsStr}\nTotal time: ${Math.round(totalTime / 1000)} seconds\n`;
+    }
+    // if (Number(testConcurrency) === 5) {
+    //   outputStr += `\n${concurrencyMsg}\n`
+    // }
+    let exitCode;
+    if (errors.length) {
+        exitCode = 1;
+    }
+    else if (failOnDiff) {
+        exitCode = !warnForUnsavedNewTests && passedOrNew.length && !unresolvedOrFailed.length ? 0 : 1;
+    }
+    else {
+        exitCode = 0;
+    }
+    return {
+        outputStr,
+        exitCode,
+    };
+}
+function testResultsOutput(results, warnForUnsavedNewTests) {
+    let outputStr = '';
+    const sortedTestResults = results.sort((a, b) => a.name.localeCompare(b.name));
+    sortedTestResults.forEach(result => {
+        const testTitle = `${result.name} [${result.hostApp}] [${result.hostDisplaySize.width}x${result.hostDisplaySize.height}] - `;
+        if (result.isAborted) {
+            outputStr += `${testTitle}${chalk_1.default.keyword('red')(`Aborted`)}\n`;
+        }
+        else if (result.isNew) {
+            const newResColor = warnForUnsavedNewTests ? 'orange' : 'blue';
+            outputStr += `${testTitle}${chalk_1.default.keyword(newResColor)('New')}\n`;
+        }
+        else if (result.status === 'Passed') {
+            outputStr += `${testTitle}${chalk_1.default.green('Passed')}\n`;
+        }
+        else if (result.status === 'Failed') {
+            outputStr += `${testTitle}${chalk_1.default.keyword('red')('Failed')}\n`;
+        }
+        else {
+            outputStr += `${testTitle}${chalk_1.default.keyword('orange')(`Unresolved`)}\n`;
+        }
+    });
+    outputStr += '\n';
+    return outputStr;
+}
+function formatEnvironment(environment) {
+    const env = environment.requested;
+    if (isChromeEmulation(env)) {
+        return `${env.chromeEmulationInfo.deviceName}${env.chromeEmulationInfo.screenOrientation ? ` [${env.chromeEmulationInfo.screenOrientation}]` : ''}`;
+    }
+    else if (isIOSDevice(env)) {
+        return `${env.iosDeviceInfo.deviceName}${env.iosDeviceInfo.screenOrientation ? ` [${env.iosDeviceInfo.screenOrientation}]` : ''}`;
+    }
+    else if (isAndroidDevice(env)) {
+        return `${env.androidDeviceInfo.deviceName}${env.androidDeviceInfo.screenOrientation ? ` [${env.androidDeviceInfo.screenOrientation}]` : ''}`;
+    }
+    else {
+        return `${env.name} [${env.width}x${env.height}]`;
+    }
+    function isChromeEmulation(env) {
+        return env.chromeEmulationInfo;
+    }
+    function isIOSDevice(env) {
+        return env.iosDeviceInfo;
+    }
+    function isAndroidDevice(env) {
+        return env.androidDeviceInfo;
+    }
+}

package/dist/ufg/check.js

@@ -28,29 +28,24 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeCheck = void 0;
 const driver_1 = require("@applitools/driver");
-const take_dom_snapshots_1 = require("./utils/take-dom-snapshots");
-const to_base_check_settings_1 = require("../automation/utils/to-base-check-settings");
-const to_generated_selectors_1 = require("./utils/to-generated-selectors");
 const uniquify_environments_1 = require("../automation/utils/uniquify-environments");
 const to_environment_key_1 = require("../automation/utils/to-environment-key");
 const abort_error_1 = require("../errors/abort-error");
 const utils = __importStar(require("@applitools/utils"));
 const lang = __importStar(require("../lang"));
 const chalk_1 = __importDefault(require("chalk"));
+const take_snapshots_1 = require("./take-snapshots");
+const create_render_target_from_snapshot_1 = require("./create-render-target-from-snapshot");
+const to_base_check_settings_1 = require("../automation/utils/to-base-check-settings");
 function makeCheck({ eyes, target: defaultTarget, environments: defaultEnvironments = [], spec, signal, logger: mainLogger, }) {
     return async function check({ target = defaultTarget, settings = {}, logger = mainLogger, } = {}) {
-        var _a, _b;
+        var _a;
         logger = logger.extend(mainLogger);
         logger.log('Command "check" is called with settings', settings);
         if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
             logger.warn('Command "check" was called after test was already aborted');
             throw new abort_error_1.AbortError('Command "check" was called after test was already aborted');
         }
-        const { elementReferences, getBaseCheckSettings } = (0, to_base_check_settings_1.toBaseCheckSettings)({ settings });
-        const { elementReferencesToMark, getGeneratedSelectors } = (0, to_generated_selectors_1.toGeneratedSelectors)({
-            elementReferences,
-            transformElementReference: elementReference => { var _a; return ((0, driver_1.isSelector)(elementReference) && ((_a = spec === null || spec === void 0 ? void 0 : spec.toSimpleCommonSelector) === null || _a === void 0 ? void 0 : _a.call(spec, elementReference))) || undefined; },
-        });
         const uniqueEnvironments = (0, uniquify_environments_1.uniquifyEnvironments)((_a = settings.environments) !== null && _a !== void 0 ? _a : defaultEnvironments);
         const ufgClient = await eyes.core.getUFGClient({
             settings: {
@@ -61,66 +56,27 @@ function makeCheck({ eyes, target: defaultTarget, environments: defaultEnvironme
             logger,
         });
         let snapshots;
-        let snapshotUrl;
-        let snapshotTitle;
-        let userAgent;
-        const driver = spec && (0, driver_1.isDriver)(target, spec)
-            ? await (0, driver_1.makeDriver)({ spec, driver: target, reset: target === defaultTarget, logger })
-            : undefined;
-        if (driver) {
-            const environment = await driver.getEnvironment();
-            const currentContext = driver.currentContext;
-            await currentContext.setScrollingElement((_b = settings.scrollRootElement) !== null && _b !== void 0 ? _b : null);
-            if (environment.isWeb) {
-                userAgent = await driver.getUserAgentLegacy();
-                snapshots = await (0, take_dom_snapshots_1.takeDomSnapshots)({
-                    driver,
-                    settings: {
-                        ...eyes.test.eyesServer,
-                        waitBeforeCapture: settings.waitBeforeCapture,
-                        disableBrowserFetching: settings.disableBrowserFetching,
-                        layoutBreakpoints: settings.layoutBreakpoints,
-                        environments: uniqueEnvironments,
-                        skipResources: ufgClient.getCachedResourceUrls(),
-                        lazyLoad: settings.lazyLoad,
-                        elementReferences: elementReferencesToMark,
-                    },
-                    provides: {
-                        getChromeEmulationDevices: ufgClient.getChromeEmulationDevices,
-                        getIOSDevices: ufgClient.getIOSDevices,
-                    },
-                    logger,
-                });
-            }
-            else {
-                const nmlClient = await eyes.core.getNMLClient({
-                    driver,
-                    settings: { ...eyes.test.eyesServer, supportedEnvironmentsUrl: eyes.test.supportedEnvironmentsUrl },
-                    logger,
-                });
-                snapshots = (await nmlClient.takeSnapshots({
-                    settings: {
-                        ...eyes.test.eyesServer,
-                        waitBeforeCapture: settings.waitBeforeCapture,
-                        environments: uniqueEnvironments,
-                    },
-                    logger,
-                }));
-            }
-            await currentContext.focus();
-            snapshotUrl = await driver.getUrl();
-            snapshotTitle = await driver.getTitle();
+        let driver;
+        if (spec && (0, driver_1.isDriver)(target, spec)) {
+            const takeSnapshots = (0, take_snapshots_1.makeTakeSnapshots)({ core: eyes.core, spec, signal, logger });
+            driver = await (0, driver_1.makeDriver)({ spec, driver: target, logger });
+            snapshots = await takeSnapshots({
+                driver,
+                account: eyes.test.account,
+                settings: { ...settings, environments: uniqueEnvironments },
+                logger,
+            });
         }
         else {
+            // TODO (amit)
             snapshots = !utils.types.isArray(target) ? Array(uniqueEnvironments.length).fill(target) : target;
-            snapshotUrl = utils.types.has(snapshots[0], 'url') ? snapshots[0].url : undefined;
         }
-        const generatedSelectors = snapshots.map(snapshot => getGeneratedSelectors(utils.types.has(snapshot, 'generatedSelectors') ? snapshot.generatedSelectors : undefined));
-        const promises = uniqueEnvironments.map(async (environment, index) => {
+        const promises = snapshots.map(async (snapshot, i) => {
             var _a, _b, _c, _d, _e, _f, _g, _h, _j;
             const environmentLogger = logger.extend({ tags: [`environment-${utils.general.shortid()}`] });
-            const ufgEnvironment = environment;
-            if (utils.types.has(ufgEnvironment, 'name') && ufgEnvironment.name === 'edge') {
+            const { target } = snapshot;
+            const environment = uniqueEnvironments[i];
+            if (utils.types.has(environment, 'name') && environment.name === 'edge') {
                 environmentLogger.console.log(chalk_1.default.yellow(lang.edgeUfgEnvironmentDeprecatedWarning));
             }
             try {
@@ -128,26 +84,10 @@ function makeCheck({ eyes, target: defaultTarget, environments: defaultEnvironme
                     environmentLogger.warn('Command "check" was aborted before rendering');
                     throw new abort_error_1.AbortError('Command "check" was aborted before rendering');
                 }
-                const { cookies, ...snapshot } = snapshots[index];
-                const selectors = generatedSelectors[index];
-                if (utils.types.has(ufgEnvironment, 'iosDeviceInfo') || utils.types.has(ufgEnvironment, 'androidDeviceInfo')) {
-                    ufgEnvironment.type = utils.types.has(snapshot, 'cdt') ? 'web' : 'native';
+                if (utils.types.has(environment, 'iosDeviceInfo') || utils.types.has(environment, 'androidDeviceInfo')) {
+                    environment.type = utils.types.has(target, 'cdt') ? 'web' : 'native';
                 }
-                const renderTargetPromise = ufgClient.createRenderTarget({
-                    snapshot,
-                    settings: {
-                        environment: ufgEnvironment,
-                        cookies,
-                        headers: {
-                            Referer: snapshotUrl,
-                            'User-Agent': userAgent,
-                            ...settings.headers,
-                        },
-                        proxy: eyes.test.eyesServer.proxy,
-                        autProxy: settings.autProxy,
-                    },
-                    logger: environmentLogger,
-                });
+                const renderTargetPromise = (0, create_render_target_from_snapshot_1.createRenderTargetFromSnapshot)({ ufgClient, snapshot, logger: environmentLogger });
                 const baseEyes = await eyes.getBaseEyes({ settings: { environment, driver }, logger: environmentLogger });
                 try {
                     if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
@@ -167,31 +107,35 @@ function makeCheck({ eyes, target: defaultTarget, environments: defaultEnvironme
                         environmentLogger.warn(`Render on environment with id "${(_c = baseEyes.test.environment) === null || _c === void 0 ? void 0 : _c.environmentId}" was aborted during one of the previous steps`);
                         throw new abort_error_1.AbortError(`Render on environment with id "${(_d = baseEyes.test.environment) === null || _d === void 0 ? void 0 : _d.environmentId}" was aborted during one of the previous steps`);
                     }
+                    const { elementReferences: selectors, getBaseCheckSettings } = (0, to_base_check_settings_1.toBaseCheckSettings)({
+                        settings: snapshot.settings,
+                    });
                     const { renderId, selectorRegions, ...baseTarget } = await ufgClient.render({
                         target: renderTarget,
                         settings: {
-                            ...settings,
-                            region: (_e = selectors.target) !== null && _e !== void 0 ? _e : settings.region,
+                            ...snapshot.settings,
+                            region: (_e = selectors.target) !== null && _e !== void 0 ? _e : snapshot.settings.region,
                             scrollRootElement: selectors.scrolling,
-                            selectorsToCalculate: selectors.calculate.flatMap(({ safeSelector }) => safeSelector !== null && safeSelector !== void 0 ? safeSelector : []),
-                            includeFullPageSize: Boolean(settings.pageId),
-                            environment: { ...ufgEnvironment, environmentId: baseEyes.test.environment.environmentId },
+                            selectorsToCalculate: selectors.calculate,
+                            includeFullPageSize: Boolean(snapshot.settings.pageId),
+                            environment: { ...environment, environmentId: baseEyes.test.environment.environmentId },
                             uploadUrl: baseEyes.test.uploadUrl,
                             stitchingServiceUrl: baseEyes.test.stitchingServiceUrl,
                         },
                         signal,
                         logger: environmentLogger,
                     });
-                    let offset = 0;
                     const baseSettings = getBaseCheckSettings({
-                        calculatedRegions: selectors.calculate.map(({ originalSelector, safeSelector }) => ({
-                            selector: originalSelector !== null && originalSelector !== void 0 ? originalSelector : undefined,
-                            regions: safeSelector ? selectorRegions[offset++] : [],
-                        })),
+                        calculatedRegions: selectors.calculate.map((_, index) => {
+                            var _a;
+                            return ({
+                                regions: (_a = selectorRegions === null || selectorRegions === void 0 ? void 0 : selectorRegions[index]) !== null && _a !== void 0 ? _a : [],
+                            });
+                        }),
                     });
                     baseSettings.renderId = renderId;
-                    baseTarget.source = snapshotUrl;
-                    baseTarget.name = snapshotTitle;
+                    baseTarget.source = snapshot.url;
+                    baseTarget.name = snapshot.title;
                     if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
                         environmentLogger.warn('Command "check" was aborted after rendering');
                         throw new abort_error_1.AbortError('Command "check" was aborted after rendering');
@@ -238,8 +182,8 @@ function makeCheck({ eyes, target: defaultTarget, environments: defaultEnvironme
                 }
             }
             catch (error) {
-                environmentLogger.error(`Environment with id ${ufgEnvironment.environmentId} failed before rendering started due to an error`, error);
-                error.info = { ...error.info, userTestId: eyes.test.userTestId, environment: ufgEnvironment };
+                environmentLogger.error(`Environment with id ${environment.environmentId} failed before rendering started due to an error`, error);
+                error.info = { ...error.info, userTestId: eyes.test.userTestId, environment };
                 throw error;
             }
         });

package/dist/ufg/core.js

@@ -36,10 +36,11 @@ const take_snapshots_1 = require("./take-snapshots");
 const get_ufg_client_1 = require("./get-ufg-client");
 const open_eyes_1 = require("./open-eyes");
 const utils = __importStar(require("@applitools/utils"));
-function makeCore({ spec, clients, base: defaultBase, asyncCache, concurrency, fetchConcurrency, agentId = 'core-ufg', cwd = process.cwd(), logger: defaultLogger, }) {
+function makeCore({ spec, clients, base: defaultBase, asyncCache, concurrency, offlineLocationPath, fetchConcurrency, agentId = 'core-ufg', cwd = process.cwd(), logger: defaultLogger, }) {
     const logger = (0, logger_1.makeLogger)({ logger: defaultLogger, format: { label: 'core-ufg' } });
     logger.log(`Core ufg is initialized ${defaultBase ? 'with' : 'without'} custom base core`);
-    const base = defaultBase !== null && defaultBase !== void 0 ? defaultBase : (0, core_base_1.makeCore)({ agentId, concurrency, cwd, logger });
+    const base = defaultBase !== null && defaultBase !== void 0 ? defaultBase : (0, core_base_1.makeCore)({ agentId, concurrency, cwd, logger, offlineLocationPath });
+    const ufgClient = clients === null || clients === void 0 ? void 0 : clients.ufg;
     return utils.general.extend(base, core => {
         return {
             type: 'ufg',
@@ -50,7 +51,7 @@ function makeCore({ spec, clients, base: defaultBase, asyncCache, concurrency, f
             locate: (0, locate_1.makeLocate)({ spec, core, logger }),
             locateText: (0, locate_text_1.makeLocateText)({ spec, core, logger }),
             extractText: (0, extract_text_1.makeExtractText)({ spec, core, logger }),
-            getUFGClient: (0, get_ufg_client_1.makeGetUFGClient)({ client: clients === null || clients === void 0 ? void 0 : clients.ufg, fetchConcurrency, asyncCache, logger }),
+            getUFGClient: (0, get_ufg_client_1.makeGetUFGClient)({ client: ufgClient, fetchConcurrency, asyncCache, offlineLocationPath, logger }),
             ...(0, get_nml_client_1.makeGetNMLClient)({ client: clients === null || clients === void 0 ? void 0 : clients.nml, logger }),
             openEyes: (0, open_eyes_1.makeOpenEyes)({ spec, core, logger }),
         };

package/dist/ufg/create-render-target-from-snapshot.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRenderTargetFromSnapshot = void 0;
+async function createRenderTargetFromSnapshot({ ufgClient, snapshot, logger, }) {
+    return await ufgClient.createRenderTarget({
+        snapshot: snapshot.target,
+        settings: {
+            environment: snapshot.environment,
+            cookies: snapshot.target.cookies,
+            headers: {
+                Referer: snapshot.url,
+                'User-Agent': snapshot.userAgent,
+                ...snapshot.settings.headers,
+            },
+            proxy: snapshot.account.eyesServer.proxy,
+            autProxy: snapshot.settings.autProxy,
+        },
+        logger,
+    });
+}
+exports.createRenderTargetFromSnapshot = createRenderTargetFromSnapshot;

package/dist/ufg/get-ufg-client.js

@@ -26,7 +26,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeGetUFGClient = void 0;
 const ufg_client_1 = require("@applitools/ufg-client");
 const utils = __importStar(require("@applitools/utils"));
-function makeGetUFGClient({ client, fetchConcurrency, logger: mainLogger, asyncCache }) {
+function makeGetUFGClient({ client, fetchConcurrency, offlineLocationPath, logger: mainLogger, asyncCache, }) {
     // we are caching by the server config, therefor if the user creates another Runner / manager with the same server config but different
     // fetchConcurrency, it will not take any affect.
     const getUFGClientWithCache = utils.general.cachify(getUFGClient, ([options]) => client ? 'default' : [{ ...options.settings, fetchConcurrency: undefined }]);
@@ -39,7 +39,7 @@ function makeGetUFGClient({ client, fetchConcurrency, logger: mainLogger, asyncC
             ? utils.general.getEnvValue('TUNNEL_IDS')
             : undefined;
         return (0, ufg_client_1.makeUFGClient)({
-            settings: { ...settings, fetchConcurrency, tunnelIds, asyncCache },
+            settings: { ...settings, fetchConcurrency, offlineLocationPath, tunnelIds, asyncCache },
             logger,
         });
     }

package/dist/ufg/take-snapshots.js

@@ -28,25 +28,23 @@ const driver_1 = require("@applitools/driver");
 const take_dom_snapshots_1 = require("./utils/take-dom-snapshots");
 const to_safe_check_settings_1 = require("./utils/to-safe-check-settings");
 const to_generated_selectors_1 = require("./utils/to-generated-selectors");
-const uniquify_environments_1 = require("../automation/utils/uniquify-environments");
 const abort_error_1 = require("../errors/abort-error");
 const utils = __importStar(require("@applitools/utils"));
 function makeTakeSnapshots({ core, spec, signal, logger: mainLogger }) {
-    return async function takeSnapshots({ target, settings = {}, environments: defaultEnvironments = [], account, logger = mainLogger, }) {
-        var _a, _b;
+    return async function takeSnapshots({ driver, settings = {}, account, logger = mainLogger, }) {
+        var _a;
         logger = logger.extend(mainLogger);
         logger.log('Command "takeSnapshots" is called with settings', settings);
         if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
             logger.warn('Command "takeSnapshots" was called after test was already aborted');
             throw new abort_error_1.AbortError('Command "takeSnapshots" was called after test was already aborted');
         }
-        const uniqueEnvironments = (0, uniquify_environments_1.uniquifyEnvironments)((_a = settings.environments) !== null && _a !== void 0 ? _a : defaultEnvironments);
-        const driver = spec && target ? await (0, driver_1.makeDriver)({ spec, driver: target, logger }) : null;
+        const uniqueEnvironments = settings.environments;
         if (!driver)
             throw new Error('Cannot create check snapshot without a driver');
         const environment = await driver.getEnvironment();
         const currentContext = driver.currentContext;
-        await currentContext.setScrollingElement((_b = settings.scrollRootElement) !== null && _b !== void 0 ? _b : null);
+        await currentContext.setScrollingElement((_a = settings.scrollRootElement) !== null && _a !== void 0 ? _a : null);
         const { elementReferences, getSafeCheckSettings } = (0, to_safe_check_settings_1.toSafeCheckSettings)({ settings });
         const { elementReferencesToMark, getGeneratedSelectors } = (0, to_generated_selectors_1.toGeneratedSelectors)({
             elementReferences,

package/dist/{log-event.js → utils/ensure-offline-folder.js}

@@ -22,17 +22,21 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeLogEvent = void 0;
-const populate_eyes_server_settings_1 = require("./utils/populate-eyes-server-settings");
+exports.ensureOfflineFolder = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
 const utils = __importStar(require("@applitools/utils"));
-function makeLogEvent({ core, logger: mainLogger }) {
-    return async function logEvent({ settings, logger = mainLogger, }) {
-        logger = logger.extend(mainLogger, { tags: [`log-event-${utils.general.shortid()}`] });
-        (utils.types.isArray(settings) ? settings : [settings]).forEach(settings => {
-            (0, populate_eyes_server_settings_1.populateEyesServerSettings)(settings);
-        });
-        return core.base.logEvent({ settings, logger });
-    };
+function ensureOfflineFolder() {
+    const offlineLocationPath = utils.general.getEnvValue('OFFLINE_LOCATION_PATH')
+        ? path_1.default.resolve(utils.general.getEnvValue('OFFLINE_LOCATION_PATH'), `execution-${Date.now()}`)
+        : undefined;
+    if (offlineLocationPath) {
+        fs_1.default.mkdirSync(offlineLocationPath, { recursive: true });
+    }
+    return offlineLocationPath;
 }
-exports.makeLogEvent = makeLogEvent;
+exports.ensureOfflineFolder = ensureOfflineFolder;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applitools/core",
-  "version": "4.19.0",
+  "version": "4.20.0",
   "homepage": "https://applitools.com",
   "bugs": {
     "url": "https://github.com/applitools/eyes.sdk.javascript1/issues"
@@ -74,11 +74,11 @@
     }
   },
   "dependencies": {
-    "@applitools/core-base": "1.16.1",
+    "@applitools/core-base": "1.17.0",
     "@applitools/dom-capture": "11.5.0",
     "@applitools/dom-snapshot": "4.11.3",
     "@applitools/driver": "1.19.1",
-    "@applitools/ec-client": "1.9.5",
+    "@applitools/ec-client": "1.9.6",
     "@applitools/logger": "2.0.18",
     "@applitools/nml-client": "1.8.11",
     "@applitools/req": "1.7.2",
@@ -86,13 +86,14 @@
     "@applitools/snippets": "2.5.0",
     "@applitools/socket": "1.1.18",
     "@applitools/spec-driver-webdriver": "1.1.13",
-    "@applitools/ufg-client": "1.12.3",
+    "@applitools/ufg-client": "1.13.0",
     "@applitools/utils": "1.7.4",
     "@types/ws": "8.5.5",
     "abort-controller": "3.0.0",
     "chalk": "4.1.2",
     "node-fetch": "2.6.7",
     "semver": "7.6.2",
+    "tar": "7.4.3",
     "webdriver": "7.31.1",
     "ws": "8.17.1",
     "yargs": "17.7.2"

package/types/autonomous/create-render-target.d.ts

@@ -1,5 +1,5 @@
 import type { Core as UFGCore } from '../ufg/types';
-import type { Snapshot, RenderTarget } from './types';
+import type { Snapshot, RenderTargetWithSettings } from './types';
 import { type Logger } from '@applitools/logger';
 type Options = {
     core: UFGCore<any>;
@@ -8,5 +8,5 @@ type Options = {
 export declare function makeCreateRenderTarget({ core, logger: defaultLogger }: Options): ({ snapshot, logger, }: {
     snapshot: Snapshot;
     logger: Logger;
-}) => Promise<RenderTarget>;
+}) => Promise<RenderTargetWithSettings>;
 export {};

package/types/autonomous/start-renders.d.ts

@@ -1,12 +1,12 @@
 import type { Core as UFGCore } from '../ufg/types';
-import type { RenderTarget, StartedRender } from './types';
+import type { RenderTargetWithSettings, StartedRender } from './types';
 import { type Logger } from '@applitools/logger';
 type Options = {
     core: UFGCore<any>;
     logger: Logger;
 };
 export declare function makeStartRenders({ core, logger: defaultLogger }: Options): ({ targets, logger, }: {
-    targets: RenderTarget[];
+    targets: RenderTargetWithSettings[];
     logger: Logger;
 }) => Promise<StartedRender[]>;
 export {};

package/types/autonomous/take-snapshots.d.ts

@@ -1,12 +1,13 @@
 import type { Core as UFGCore } from '../ufg/types';
 import type { DriverTarget, SnapshotSettings, Snapshot } from './types';
 import { type Logger } from '@applitools/logger';
-import { type SpecType } from '@applitools/driver';
+import { type SpecDriver, type SpecType } from '@applitools/driver';
 type Options<TSpec extends SpecType> = {
     core: UFGCore<TSpec>;
+    spec: SpecDriver<TSpec>;
     logger: Logger;
 };
-export declare function makeTakeSnapshots<TSpec extends SpecType>({ core, logger: defaultLogger }: Options<TSpec>): ({ target, settings, logger, }: {
+export declare function makeTakeSnapshots<TSpec extends SpecType>({ core, spec, logger: defaultLogger }: Options<TSpec>): ({ target, settings, logger, }: {
     target: DriverTarget<TSpec>;
     settings: SnapshotSettings<TSpec>;
     logger?: Logger | undefined;

package/types/autonomous/types.d.ts

@@ -2,7 +2,7 @@ import type { Eyes as BaseEyes, ImageTarget as BaseImageTarget, OpenSettings as
 import type * as UFGCore from '../ufg/types';
 import { type Logger } from '@applitools/logger';
 import { type SpecType } from '@applitools/driver';
-import { type RenderTarget as UFGRenderTarget, type StartedRender as UFGStartedRender } from '@applitools/ufg-client';
+import { type RenderTarget, type StartedRender as UFGStartedRender } from '@applitools/ufg-client';
 export * from '../ufg/types';
 export interface AutonomousCore<TSpec extends SpecType> {
     readonly type: 'autonomous';
@@ -14,9 +14,9 @@ export interface AutonomousCore<TSpec extends SpecType> {
     createRenderTarget(options: {
         snapshot: UFGCore.Snapshot;
         logger?: Logger;
-    }): Promise<RenderTarget>;
+    }): Promise<RenderTargetWithSettings>;
     startRenders(options: {
-        targets: RenderTarget[];
+        targets: RenderTargetWithSettings[];
         logger?: Logger;
     }): Promise<StartedRender[]>;
     getRenderResults(options: {
@@ -34,8 +34,8 @@ export interface AutonomousCore<TSpec extends SpecType> {
     }): Promise<BaseEyes>;
 }
 export type SnapshotSettings<TSpec extends SpecType> = UFGCore.SnapshotSettings<TSpec> & UFGCore.EyesServerSettings;
-export type RenderTarget = {
-    target: UFGRenderTarget;
+export type RenderTargetWithSettings = {
+    target: RenderTarget;
     settings: UFGCore.SafeCheckSettings;
     environment: UFGCore.RenderEnvironment;
     account: UFGCore.Account;

package/types/classic/core.d.ts

@@ -13,6 +13,7 @@ type Options<TSpec extends SpecType> = {
     agentId?: string;
     cwd?: string;
     logger?: Logger;
+    offlineLocationPath?: string;
 };
-export declare function makeCore<TSpec extends SpecType>({ spec, clients, base: defaultBase, concurrency, agentId, cwd, logger: defaultLogger, }: Options<TSpec>): Core<TSpec>;
+export declare function makeCore<TSpec extends SpecType>({ spec, clients, base: defaultBase, concurrency, agentId, cwd, logger: defaultLogger, offlineLocationPath, }: Options<TSpec>): Core<TSpec>;
 export {};

package/types/make-manager.d.ts

@@ -17,8 +17,9 @@ type Options<TSpec extends SpecType> = {
     cwd?: string;
     logger: Logger;
     asyncCache?: AsyncCache;
+    offlineLocationPath?: string;
 };
-export declare function makeMakeManager<TSpec extends SpecType>({ spec, clients, core, base: defaultBase, agentId: defaultAgentId, environment, cwd, logger: mainLogger, asyncCache, }: Options<TSpec>): <TType extends "classic" | "ufg" = "classic">({ type, settings, logger, }?: {
+export declare function makeMakeManager<TSpec extends SpecType>({ spec, clients, core, base: defaultBase, agentId: defaultAgentId, environment, cwd, logger: mainLogger, asyncCache, offlineLocationPath, }: Options<TSpec>): <TType extends "classic" | "ufg" = "classic">({ type, settings, logger, }?: {
     type?: TType | undefined;
     settings?: ManagerSettings | undefined;
     logger?: Logger | undefined;

package/types/run-offline-snapshots.d.ts

@@ -0,0 +1,5 @@
+import { type EyesServerSettings } from './types';
+export type OfflineSnapshotsSettings = EyesServerSettings & {
+    offlineLocationPath: string;
+};
+export declare function runOfflineSnapshots(options: OfflineSnapshotsSettings): Promise<void>;

package/types/ufg/core.d.ts

@@ -17,6 +17,7 @@ type Options<TSpec extends SpecType> = {
     agentId?: string;
     cwd?: string;
     logger?: Logger;
+    offlineLocationPath?: string;
 };
-export declare function makeCore<TSpec extends SpecType>({ spec, clients, base: defaultBase, asyncCache, concurrency, fetchConcurrency, agentId, cwd, logger: defaultLogger, }: Options<TSpec>): Core<TSpec>;
+export declare function makeCore<TSpec extends SpecType>({ spec, clients, base: defaultBase, asyncCache, concurrency, offlineLocationPath, fetchConcurrency, agentId, cwd, logger: defaultLogger, }: Options<TSpec>): Core<TSpec>;
 export {};

package/types/ufg/create-render-target-from-snapshot.d.ts

@@ -0,0 +1,8 @@
+import { UFGClient, RenderTarget } from '@applitools/ufg-client';
+import { Snapshot } from './types';
+import { Logger } from '@applitools/logger';
+export declare function createRenderTargetFromSnapshot({ ufgClient, snapshot, logger, }: {
+    ufgClient: UFGClient;
+    snapshot: Snapshot;
+    logger: Logger;
+}): Promise<RenderTarget>;

package/types/ufg/get-ufg-client.d.ts

@@ -5,8 +5,9 @@ type Options = {
     fetchConcurrency?: number;
     logger: Logger;
     asyncCache?: AsyncCache;
+    offlineLocationPath?: string;
 };
-export declare function makeGetUFGClient({ client, fetchConcurrency, logger: mainLogger, asyncCache }: Options): (({ settings, logger }: {
+export declare function makeGetUFGClient({ client, fetchConcurrency, offlineLocationPath, logger: mainLogger, asyncCache, }: Options): (({ settings, logger }: {
     settings: UFGClientSettings;
     logger?: Logger | undefined;
 }) => Promise<UFGClient>) & {

package/types/ufg/take-snapshots.d.ts

@@ -1,18 +1,16 @@
-import type { DriverTarget, Core, SnapshotSettings, Account, Snapshot } from './types';
-import { type Environment as UFGEnvironment } from '@applitools/ufg-client';
+import type { Core, SnapshotSettings, Account, Snapshot } from './types';
 import { type AbortSignal } from 'abort-controller';
 import { type Logger } from '@applitools/logger';
-import { type SpecType, type SpecDriver } from '@applitools/driver';
+import { type SpecType, type SpecDriver, type Driver } from '@applitools/driver';
 type Options<TSpec extends SpecType> = {
     core: Core<TSpec>;
     spec: SpecDriver<TSpec>;
     signal?: AbortSignal;
     logger: Logger;
 };
-export declare function makeTakeSnapshots<TSpec extends SpecType>({ core, spec, signal, logger: mainLogger }: Options<TSpec>): ({ target, settings, environments: defaultEnvironments, account, logger, }: {
-    target: DriverTarget<TSpec>;
+export declare function makeTakeSnapshots<TSpec extends SpecType>({ core, spec, signal, logger: mainLogger }: Options<TSpec>): ({ driver, settings, account, logger, }: {
+    driver: Driver<TSpec>;
     settings?: SnapshotSettings<TSpec> | undefined;
-    environments?: UFGEnvironment[] | undefined;
     account: Account;
     logger?: Logger | undefined;
 }) => Promise<Snapshot[]>;

package/types/ufg/types.d.ts

@@ -1,6 +1,6 @@
 import type { MaybeArray } from '@applitools/utils';
 import type * as AutomationCore from '../automation/types';
-import { type SpecType, type CommonSelector } from '@applitools/driver';
+import { type SpecType, type CommonSelector, type Driver } from '@applitools/driver';
 import { type Logger } from '@applitools/logger';
 import { type Proxy } from '@applitools/req';
 import { type UFGClient, type UFGClientSettings, type Selector as UFGSelector, type Environment as UFGEnvironment, type DomSnapshot as UFGDomSnapshot, type AndroidSnapshot as UFGAndroidSnapshot, type IOSSnapshot as UFGIOSSnapshot } from '@applitools/ufg-client';
@@ -13,7 +13,7 @@ export type DomSnapshot = UFGDomSnapshot & {
 };
 export type AndroidSnapshot = UFGAndroidSnapshot;
 export type IOSSnapshot = UFGIOSSnapshot;
-export type SnapshotTarget = MaybeArray<DomSnapshot> | MaybeArray<AndroidSnapshot> | MaybeArray<IOSSnapshot>;
+export type SnapshotTarget = MaybeArray<Snapshot>;
 export type Target<TSpec extends SpecType> = SnapshotTarget | AutomationCore.Target<TSpec>;
 export interface Core<TSpec extends SpecType> extends AutomationCore.Core<TSpec> {
     readonly type: 'ufg';
@@ -22,7 +22,7 @@ export interface Core<TSpec extends SpecType> extends AutomationCore.Core<TSpec>
         logger?: Logger;
     }): Promise<UFGClient>;
     takeSnapshots?(options: {
-        target: AutomationCore.DriverTarget<TSpec>;
+        driver: Driver<TSpec>;
         settings?: SnapshotSettings<TSpec>;
         account: AutomationCore.Account;
         logger?: Logger;

package/types/utils/ensure-offline-folder.d.ts

@@ -0,0 +1 @@
+export declare function ensureOfflineFolder(): string | undefined;

package/types/log-event.d.ts

@@ -1,12 +0,0 @@
-import type { MaybeArray } from '@applitools/utils';
-import type { Core, LogEventSettings } from './types';
-import { type Logger } from '@applitools/logger';
-type Options = {
-    core: Core<any>;
-    logger: Logger;
-};
-export declare function makeLogEvent({ core, logger: mainLogger }: Options): ({ settings, logger, }: {
-    settings: MaybeArray<LogEventSettings>;
-    logger?: Logger | undefined;
-}) => Promise<void>;
-export {};