@applitools/core 4.11.2 → 4.12.0

package/CHANGELOG.md

@@ -1,5 +1,52 @@
 # Changelog
 
+## [4.12.0](https://github.com/Applitools-Dev/sdk/compare/js/core@4.11.2...js/core@4.12.0) (2024-04-10)
+
+
+### Features
+
+* add prefixRenderId to SnapshotSettings ([073c81b](https://github.com/Applitools-Dev/sdk/commit/073c81b7e96411b643fe907a588f0c1ef95c4d48))
+* refactor check to have a modular structure ([#2307](https://github.com/Applitools-Dev/sdk/issues/2307)) ([b9818f4](https://github.com/Applitools-Dev/sdk/commit/b9818f46e0a579ad0a4a6beaf142171aea7ce0fd))
+* upgrade execution-grid-tunnel to 3 ([#2301](https://github.com/Applitools-Dev/sdk/issues/2301)) ([4f0426d](https://github.com/Applitools-Dev/sdk/commit/4f0426d5495142386d54121fde8bc1fb647728a7))
+
+
+### Bug Fixes
+
+* clone the check settings in eyes check ([#2251](https://github.com/Applitools-Dev/sdk/issues/2251)) ([9517d66](https://github.com/Applitools-Dev/sdk/commit/9517d665976949458aecfb31e052c19d7109a0c4))
+
+
+### Dependencies
+
+* @applitools/dom-snapshot bumped to 4.10.0
+  #### Features
+
+  * nested css ([#2296](https://github.com/Applitools-Dev/sdk/issues/2296)) ([16068dc](https://github.com/Applitools-Dev/sdk/commit/16068dcd346ee66ed254f6b2c40f7a76ec5cddb7))
+* @applitools/nml-client bumped to 1.8.0
+  #### Features
+
+  * refactor check to have a modular structure ([#2307](https://github.com/Applitools-Dev/sdk/issues/2307)) ([b9818f4](https://github.com/Applitools-Dev/sdk/commit/b9818f46e0a579ad0a4a6beaf142171aea7ce0fd))
+* @applitools/tunnel-client bumped to 1.5.0
+  #### Features
+
+  * upgrade execution-grid-tunnel to 3 ([#2301](https://github.com/Applitools-Dev/sdk/issues/2301)) ([4f0426d](https://github.com/Applitools-Dev/sdk/commit/4f0426d5495142386d54121fde8bc1fb647728a7))
+* @applitools/ufg-client bumped to 1.11.0
+  #### Features
+
+  * add prefixRenderId to SnapshotSettings ([073c81b](https://github.com/Applitools-Dev/sdk/commit/073c81b7e96411b643fe907a588f0c1ef95c4d48))
+  * refactor check to have a modular structure ([#2307](https://github.com/Applitools-Dev/sdk/issues/2307)) ([b9818f4](https://github.com/Applitools-Dev/sdk/commit/b9818f46e0a579ad0a4a6beaf142171aea7ce0fd))
+* @applitools/ec-client bumped to 1.8.0
+  #### Features
+
+  * upgrade execution-grid-tunnel to 3 ([#2301](https://github.com/Applitools-Dev/sdk/issues/2301)) ([4f0426d](https://github.com/Applitools-Dev/sdk/commit/4f0426d5495142386d54121fde8bc1fb647728a7))
+
+
+
+* @applitools/core-base bumped to 1.11.0
+  #### Features
+
+  * refactor check to have a modular structure ([#2307](https://github.com/Applitools-Dev/sdk/issues/2307)) ([b9818f4](https://github.com/Applitools-Dev/sdk/commit/b9818f46e0a579ad0a4a6beaf142171aea7ce0fd))
+  * report timestamp to backend ([#2278](https://github.com/Applitools-Dev/sdk/issues/2278)) ([3ff74c6](https://github.com/Applitools-Dev/sdk/commit/3ff74c66a33174025e5fab3979b748dfeb53e7b8))
+
 ## [4.11.2](https://github.com/Applitools-Dev/sdk/compare/js/core@4.11.1...js/core@4.11.2) (2024-04-01)
 
 

package/dist/automation/utils/to-base-check-settings.js

@@ -106,6 +106,7 @@ function toBaseCheckSettings({ settings }) {
         else if (target) {
             delete transformedSettings.region;
         }
+        let currRegion = 0;
         regionTypes.forEach(regionType => {
             var _a;
             if (!transformedSettings[`${regionType}Regions`])
@@ -114,7 +115,7 @@ function toBaseCheckSettings({ settings }) {
                 const { region, ...options } = utils.types.has(reference, 'region') ? reference : { region: reference };
                 if (isRegion(region))
                     return reference;
-                const { selector, regions } = calculatedRegions.shift();
+                const { selector, regions } = calculatedRegions[currRegion++];
                 return regions.map(region => ({
                     region,
                     regionId: utils.types.isString(selector) ? selector : selector === null || selector === void 0 ? void 0 : selector.selector,

package/dist/autonomous/core.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeAutonomousCore = void 0;
+const logger_1 = require("@applitools/logger");
+const core_1 = require("../ufg/core");
+const take_snapshots_1 = require("./take-snapshots");
+const create_render_target_1 = require("./create-render-target");
+const start_renders_1 = require("./start-renders");
+const get_render_results_1 = require("./get-render-results");
+const create_render_results_1 = require("./create-render-results");
+const open_eyes_1 = require("./open-eyes");
+function makeAutonomousCore({ spec, clients, base: defaultBase, asyncCache, agentId = 'core-autonomous', cwd, logger: defaultLogger, } = {}) {
+    const logger = (0, logger_1.makeLogger)({ logger: defaultLogger, format: { label: 'core-autonomous' } });
+    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 }),
+        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 }),
+        createRenderResults: (0, create_render_results_1.makeCreateRenderResults)({ core, logger }),
+        openEyes: (0, open_eyes_1.makeOpenEyes)({ core, logger }),
+    };
+}
+exports.makeAutonomousCore = makeAutonomousCore;

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeCreateRenderResults = void 0;
+const ufg_client_1 = require("@applitools/ufg-client");
+const to_base_check_settings_1 = require("../automation/utils/to-base-check-settings");
+function makeCreateRenderResults(_options) {
+    return async function createRenderResults({ renders, rawResults, }) {
+        const results = rawResults.map((rawResult, index) => (0, ufg_client_1.toRenderResult)(rawResult, { renderId: renders[index].render.renderId }));
+        return results.map(({ selectorRegions, renderId, status, error, ...baseTarget }, index) => {
+            const { elementReferences: selectors, getBaseCheckSettings } = (0, to_base_check_settings_1.toBaseCheckSettings)({
+                settings: renders[index].settings,
+            });
+            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;
+            return {
+                status,
+                error,
+                target: { ...baseTarget, isTransformed: true },
+                settings: baseSettings,
+                environment: renders[index].environment,
+                account: renders[index].account,
+            };
+        });
+    };
+}
+exports.makeCreateRenderResults = makeCreateRenderResults;

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeCreateRenderTarget = void 0;
+function makeCreateRenderTarget({ core, logger: defaultLogger }) {
+    return async function createRenderTarget({ snapshot, logger = defaultLogger, }) {
+        const ufgClient = await core.getUFGClient({
+            settings: {
+                ...snapshot.account.ufgServer,
+                eyesServerUrl: snapshot.account.eyesServer.eyesServerUrl,
+                apiKey: snapshot.account.eyesServer.apiKey,
+            },
+            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,
+        });
+        return { ...snapshot, target };
+    };
+}
+exports.makeCreateRenderTarget = makeCreateRenderTarget;

package/dist/autonomous/get-render-results.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeGetRenderResults = void 0;
+const to_base_check_settings_1 = require("../automation/utils/to-base-check-settings");
+function makeGetRenderResults({ core, logger: defaultLogger }) {
+    return async function getRenderResults({ renders, logger = defaultLogger, }) {
+        const clients = await renders.reduce(async (promise, render) => {
+            const ufgClient = await core.getUFGClient({
+                settings: {
+                    ...render.account.ufgServer,
+                    eyesServerUrl: render.account.eyesServer.eyesServerUrl,
+                    apiKey: render.account.eyesServer.apiKey,
+                },
+                logger,
+            });
+            return promise.then(clients => {
+                const targets = clients.get(ufgClient);
+                if (targets) {
+                    targets.push(render);
+                }
+                else {
+                    clients.set(ufgClient, [render]);
+                }
+                return clients;
+            });
+        }, Promise.resolve(new Map()));
+        const results = await Promise.all(Array.from(clients.entries(), async ([ufgClient, renders]) => {
+            const results = await ufgClient.getRenderResults({ renders: renders.map(render => render.render), logger });
+            return results.map(({ selectorRegions, renderId, status, error, ...baseTarget }, index) => {
+                const { elementReferences: selectors, getBaseCheckSettings } = (0, to_base_check_settings_1.toBaseCheckSettings)({
+                    settings: renders[index].settings,
+                });
+                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;
+                return {
+                    status,
+                    error,
+                    target: { ...baseTarget, isTransformed: true },
+                    settings: baseSettings,
+                    environment: renders[index].environment,
+                    account: renders[index].account,
+                };
+            });
+        }));
+        return results.flat();
+    };
+}
+exports.makeGetRenderResults = makeGetRenderResults;

package/dist/autonomous/open-eyes.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeOpenEyes = void 0;
+const populate_eyes_server_settings_1 = require("../utils/populate-eyes-server-settings");
+function makeOpenEyes({ core, logger: defaultLogger }) {
+    return async function openEyes({ settings, logger = defaultLogger, }) {
+        (0, populate_eyes_server_settings_1.populateEyesServerSettings)(settings);
+        return core.base.openEyes({ settings, logger });
+    };
+}
+exports.makeOpenEyes = makeOpenEyes;

package/dist/autonomous/start-renders.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStartRenders = void 0;
+const to_base_check_settings_1 = require("../automation/utils/to-base-check-settings");
+function makeStartRenders({ core, logger: defaultLogger }) {
+    return async function startRenders({ targets, logger = defaultLogger, }) {
+        const clients = await targets.reduce(async (promise, target) => {
+            const ufgClient = await core.getUFGClient({
+                settings: {
+                    ...target.account.ufgServer,
+                    eyesServerUrl: target.account.eyesServer.eyesServerUrl,
+                    apiKey: target.account.eyesServer.apiKey,
+                },
+                logger,
+            });
+            return promise.then(clients => {
+                const targets = clients.get(ufgClient);
+                if (targets) {
+                    targets.push(target);
+                }
+                else {
+                    clients.set(ufgClient, [target]);
+                }
+                return clients;
+            });
+        }, Promise.resolve(new Map()));
+        const renders = await Promise.all(Array.from(clients.entries(), async ([ufgClient, targets]) => {
+            const [renders, ...environments] = await Promise.all([
+                ufgClient.startRenders({
+                    renders: targets.map(target => {
+                        var _a;
+                        const { elementReferences: selectors } = (0, to_base_check_settings_1.toBaseCheckSettings)({ settings: target.settings });
+                        return {
+                            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.environment,
+                                uploadUrl: target.account.uploadUrl,
+                                stitchingServiceUrl: target.account.stitchingServiceUrl,
+                            },
+                        };
+                    }),
+                    logger,
+                }),
+                ...targets.map(target => ufgClient.getActualEnvironment({ settings: { environment: target.environment }, logger })),
+            ]);
+            return renders.map((render, index) => ({
+                render,
+                settings: targets[index].settings,
+                environment: environments[index],
+                account: targets[index].account,
+            }));
+        }));
+        return renders.flat();
+    };
+}
+exports.makeStartRenders = makeStartRenders;

package/dist/autonomous/take-snapshots.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTakeSnapshots = void 0;
+const populate_eyes_server_settings_1 = require("../utils/populate-eyes-server-settings");
+function makeTakeSnapshots({ core, 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 });
+    };
+}
+exports.makeTakeSnapshots = makeTakeSnapshots;

package/dist/autonomous/types.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../ufg/types"), exports);

package/dist/classic/open-eyes.js

@@ -52,6 +52,7 @@ function makeOpenEyes({ core, spec, logger: mainLogger }) {
         }
         const environments = await (0, extract_default_environments_1.extractDefaultEnvironments)({ driver, settings });
         const controller = new abort_controller_1.AbortController();
+        const { signal } = controller;
         const account = await core.getAccountInfo({ settings, logger });
         return utils.general.extend({}, eyes => {
             var _a, _b, _c, _d;
@@ -73,8 +74,8 @@ function makeOpenEyes({ core, spec, logger: mainLogger }) {
                 running: true,
                 storage,
                 getBaseEyes: (0, get_base_eyes_1.makeGetBaseEyes)({ settings, eyes, logger }),
-                check: (0, check_1.makeCheck)({ eyes, target: driver, environments, spec, signal: controller.signal, logger }),
-                checkAndClose: (0, check_and_close_1.makeCheckAndClose)({ eyes, target: driver, environments, spec, signal: controller.signal, logger }),
+                check: (0, check_1.makeCheck)({ eyes, target: driver, environments, spec, signal, logger }),
+                checkAndClose: (0, check_and_close_1.makeCheckAndClose)({ eyes, target: driver, environments, spec, signal, logger }),
                 close: (0, close_1.makeClose)({ eyes, target: driver, environments, spec, logger }),
                 abort: (0, abort_1.makeAbort)({ eyes, target: driver, environments, spec, controller, logger }),
                 getResults: (0, get_results_1.makeGetResults)({ eyes, logger }),

package/dist/index.js

@@ -31,8 +31,10 @@ __exportStar(require("./types"), exports);
 __exportStar(require("./core"), exports);
 __exportStar(require("./universal/core-server"), exports);
 __exportStar(require("./universal/core-server-process"), exports);
+__exportStar(require("./autonomous/core"), exports);
 __exportStar(require("@applitools/driver/dist/debug"), exports);
 exports.formatters = __importStar(require("./utils/format-results"));
 exports.logs = __importStar(require("./troubleshoot/logs"));
+// TODO remove export after every dependency migrated to new distributed ufg submodule
 var take_dom_snapshots_1 = require("./ufg/utils/take-dom-snapshots");
 Object.defineProperty(exports, "takeDomSnapshots", { enumerable: true, get: function () { return take_dom_snapshots_1.takeDomSnapshots; } });

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

@@ -175,8 +175,7 @@ function makeCheckAndClose({ eyes, target: defaultTarget, environments: defaultE
                             scrollRootElement: selectors.scrolling,
                             selectorsToCalculate: selectors.calculate.flatMap(({ safeSelector }) => safeSelector !== null && safeSelector !== void 0 ? safeSelector : []),
                             includeFullPageSize: !!settings.pageId,
-                            environment: ufgEnvironment,
-                            environmentId: baseEyes.test.environment.environmentId,
+                            environment: { ...ufgEnvironment, environmentId: baseEyes.test.environment.environmentId },
                             uploadUrl: baseEyes.test.uploadUrl,
                             stitchingServiceUrl: baseEyes.test.stitchingServiceUrl,
                         },

package/dist/ufg/check.js

@@ -175,8 +175,7 @@ function makeCheck({ eyes, target: defaultTarget, environments: defaultEnvironme
                             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,
+                            environment: { ...ufgEnvironment, environmentId: baseEyes.test.environment.environmentId },
                             uploadUrl: baseEyes.test.uploadUrl,
                             stitchingServiceUrl: baseEyes.test.stitchingServiceUrl,
                         },

package/dist/ufg/core.js

@@ -32,10 +32,11 @@ const locate_1 = require("../automation/locate");
 const locate_text_1 = require("../automation/locate-text");
 const extract_text_1 = require("../automation/extract-text");
 const get_nml_client_1 = require("../automation/get-nml-client");
+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, concurrency, fetchConcurrency, agentId = 'core-ufg', cwd = process.cwd(), logger: defaultLogger, asyncCache, }) {
+function makeCore({ spec, clients, base: defaultBase, asyncCache, concurrency, 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 });
@@ -45,6 +46,7 @@ function makeCore({ spec, clients, base: defaultBase, concurrency, fetchConcurre
             base: base,
             getViewportSize: spec && (0, get_viewport_size_1.makeGetViewportSize)({ spec, logger }),
             setViewportSize: spec && (0, set_viewport_size_1.makeSetViewportSize)({ spec, logger }),
+            takeSnapshots: spec && (0, take_snapshots_1.makeTakeSnapshots)({ spec, core, logger }),
             locate: (0, locate_1.makeLocate)({ spec, core, logger }),
             locateText: (0, locate_text_1.makeLocateText)({ spec, core, logger }),
             extractText: (0, extract_text_1.makeExtractText)({ spec, core, logger }),

package/dist/ufg/open-eyes.js

@@ -52,6 +52,7 @@ function makeOpenEyes({ core, spec, logger: mainLogger }) {
         }
         const environments = await (0, extract_default_environment_1.extractDefaultEnvironments)({ driver });
         const controller = new abort_controller_1.AbortController();
+        const { signal } = controller;
         const account = await core.getAccountInfo({ settings, logger });
         return utils.general.extend({}, eyes => {
             var _a, _b, _c, _d;
@@ -73,8 +74,8 @@ function makeOpenEyes({ core, spec, logger: mainLogger }) {
                 running: true,
                 storage,
                 getBaseEyes: (0, get_base_eyes_1.makeGetBaseEyes)({ settings, eyes, logger }),
-                check: (0, check_1.makeCheck)({ eyes, target: driver, environments, spec, signal: controller.signal, logger }),
-                checkAndClose: (0, check_and_close_1.makeCheckAndClose)({ eyes, target: driver, environments, spec, signal: controller.signal, logger }),
+                check: (0, check_1.makeCheck)({ eyes, target: driver, environments, spec, signal, logger }),
+                checkAndClose: (0, check_and_close_1.makeCheckAndClose)({ eyes, target: driver, environments, spec, signal, logger }),
                 close: (0, close_1.makeClose)({ eyes, target: driver, logger }),
                 abort: (0, abort_1.makeAbort)({ eyes, target: driver, spec, controller, logger }),
                 getResults: (0, get_results_1.makeGetResults)({ eyes, logger }),

package/dist/ufg/take-snapshots.js

@@ -0,0 +1,115 @@
+"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.makeTakeSnapshots = void 0;
+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;
+        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 ufgClient = await core.getUFGClient({
+            settings: {
+                ...account.ufgServer,
+                eyesServerUrl: account.eyesServer.eyesServerUrl,
+                apiKey: account.eyesServer.apiKey,
+            },
+            logger,
+        });
+        const driver = spec && target ? await (0, driver_1.makeDriver)({ spec, driver: target, logger }) : null;
+        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);
+        const { elementReferences, getSafeCheckSettings } = (0, to_safe_check_settings_1.toSafeCheckSettings)({ 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; },
+        });
+        let snapshots;
+        if (environment.isWeb) {
+            snapshots = await (0, take_dom_snapshots_1.takeDomSnapshots)({
+                driver,
+                settings: {
+                    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 core.getNMLClient({
+                driver,
+                settings: { ...account.eyesServer, supportedEnvironmentsUrl: account.supportedEnvironmentsUrl },
+                logger,
+            });
+            snapshots = await nmlClient.takeSnapshots({
+                settings: {
+                    ...account.eyesServer,
+                    waitBeforeCapture: settings.waitBeforeCapture,
+                    environments: uniqueEnvironments,
+                },
+                logger,
+            });
+        }
+        await currentContext.focus();
+        const url = await driver.getUrl();
+        const title = await driver.getTitle();
+        const userAgent = environment.isWeb ? await driver.getUserAgentLegacy() : undefined;
+        return snapshots.map((snapshot, index) => ({
+            target: snapshot,
+            settings: getSafeCheckSettings({
+                selectors: getGeneratedSelectors(utils.types.has(snapshot, 'generatedSelectors') ? snapshot.generatedSelectors : undefined),
+            }),
+            environment: uniqueEnvironments[index],
+            account,
+            url,
+            title,
+            userAgent,
+        }));
+    };
+}
+exports.makeTakeSnapshots = makeTakeSnapshots;

package/dist/ufg/utils/to-safe-check-settings.js

@@ -0,0 +1,69 @@
+"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.toSafeCheckSettings = void 0;
+const utils = __importStar(require("@applitools/utils"));
+const regionTypes = ['ignore', 'layout', 'strict', 'content', 'floating', 'accessibility'];
+function toSafeCheckSettings({ settings }) {
+    const calculate = regionTypes.flatMap(regionType => {
+        var _a;
+        return ((_a = settings[`${regionType}Regions`]) !== null && _a !== void 0 ? _a : []).reduce((regions, reference) => {
+            const { region } = utils.types.has(reference, 'region') ? reference : { region: reference };
+            return !isRegion(region) ? regions.concat(region) : regions;
+        }, []);
+    });
+    const target = !isRegion(settings.region) ? settings.region : undefined;
+    const scrolling = settings.scrollRootElement;
+    return { elementReferences: { target, scrolling, calculate }, getSafeCheckSettings };
+    function getSafeCheckSettings({ selectors, }) {
+        const transformedSettings = { ...settings };
+        regionTypes.forEach(regionType => {
+            var _a;
+            if (!transformedSettings[`${regionType}Regions`])
+                return;
+            transformedSettings[`${regionType}Regions`] = (_a = transformedSettings[`${regionType}Regions`]) === null || _a === void 0 ? void 0 : _a.flatMap(reference => {
+                const { region, ...options } = utils.types.has(reference, 'region') ? reference : { region: reference };
+                if (isRegion(region))
+                    return reference;
+                const { originalSelector, safeSelector } = selectors.calculate.shift();
+                if (!safeSelector)
+                    return [];
+                return {
+                    region: safeSelector,
+                    regionId: utils.types.isString(originalSelector) ? originalSelector : originalSelector === null || originalSelector === void 0 ? void 0 : originalSelector.selector,
+                    ...options,
+                };
+            });
+        });
+        if (!isRegion(transformedSettings.region))
+            transformedSettings.region = selectors.target;
+        transformedSettings.scrollRootElement = selectors.scrolling;
+        return transformedSettings;
+    }
+    function isRegion(region) {
+        return utils.types.has(region, ['x', 'y', 'width', 'height']);
+    }
+}
+exports.toSafeCheckSettings = toSafeCheckSettings;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applitools/core",
-  "version": "4.11.2",
+  "version": "4.12.0",
   "homepage": "https://applitools.com",
   "bugs": {
     "url": "https://github.com/applitools/eyes.sdk.javascript1/issues"
@@ -74,19 +74,19 @@
     }
   },
   "dependencies": {
-    "@applitools/core-base": "1.10.1",
+    "@applitools/core-base": "1.11.0",
     "@applitools/dom-capture": "11.2.6",
-    "@applitools/dom-snapshot": "4.9.2",
+    "@applitools/dom-snapshot": "4.10.0",
     "@applitools/driver": "1.16.5",
-    "@applitools/ec-client": "1.7.32",
+    "@applitools/ec-client": "1.8.0",
     "@applitools/logger": "2.0.14",
-    "@applitools/nml-client": "1.7.5",
+    "@applitools/nml-client": "1.8.0",
     "@applitools/req": "1.6.5",
     "@applitools/screenshoter": "3.8.27",
     "@applitools/snippets": "2.4.25",
     "@applitools/socket": "1.1.14",
     "@applitools/spec-driver-webdriver": "1.1.3",
-    "@applitools/ufg-client": "1.10.2",
+    "@applitools/ufg-client": "1.11.0",
     "@applitools/utils": "1.7.0",
     "@types/ws": "8.5.5",
     "abort-controller": "3.0.0",
@@ -104,7 +104,7 @@
     "@applitools/spec-driver-selenium": "^1.5.74",
     "@applitools/test-server": "^1.2.2",
     "@applitools/test-utils": "^1.5.17",
-    "@applitools/tunnel-client": "^1.4.1",
+    "@applitools/tunnel-client": "^1.5.0",
     "@types/node": "^12.20.55",
     "@types/selenium-webdriver": "^4.1.2",
     "@types/semver": "^7.5.4",

package/types/autonomous/core.d.ts

@@ -0,0 +1,20 @@
+import type { AutonomousCore } from './types';
+import { type AsyncCache, type UFGClient } from '@applitools/ufg-client';
+import { type NMLClient } from '@applitools/nml-client';
+import { type SpecType, type SpecDriver } from '@applitools/driver';
+import { type Logger } from '@applitools/logger';
+import { type Core as BaseCore } from '@applitools/core-base';
+type Options<TSpec extends SpecType> = {
+    spec?: SpecDriver<TSpec>;
+    clients?: {
+        ufg?: UFGClient;
+        nml?: NMLClient;
+    };
+    base?: BaseCore;
+    asyncCache?: AsyncCache;
+    agentId?: string;
+    cwd?: string;
+    logger?: Logger;
+};
+export declare function makeAutonomousCore<TSpec extends SpecType>({ spec, clients, base: defaultBase, asyncCache, agentId, cwd, logger: defaultLogger, }?: Options<TSpec>): AutonomousCore<TSpec>;
+export {};

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

@@ -0,0 +1,13 @@
+import type { Core as UFGCore } from '../ufg/types';
+import type { StartedRender, RenderResult } from './types';
+import { type Logger } from '@applitools/logger';
+type Options = {
+    core: UFGCore<any>;
+    logger: Logger;
+};
+export declare function makeCreateRenderResults(_options: Options): ({ renders, rawResults, }: {
+    renders: StartedRender[];
+    rawResults: any[];
+    logger: Logger;
+}) => Promise<RenderResult[]>;
+export {};

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

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

package/types/autonomous/get-render-results.d.ts

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

package/types/autonomous/open-eyes.d.ts

@@ -0,0 +1,13 @@
+import type { Core as UFGCore } from '../ufg/types';
+import type { OpenSettings } from './types';
+import type { Eyes as BaseEyes } from '@applitools/core-base/types';
+import { type Logger } from '@applitools/logger';
+type Options = {
+    core: UFGCore<any>;
+    logger: Logger;
+};
+export declare function makeOpenEyes({ core, logger: defaultLogger }: Options): ({ settings, logger, }: {
+    settings: OpenSettings;
+    logger: Logger;
+}) => Promise<BaseEyes>;
+export {};

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

@@ -0,0 +1,12 @@
+import type { Core as UFGCore } from '../ufg/types';
+import type { RenderTarget, 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[];
+    logger: Logger;
+}) => Promise<StartedRender[]>;
+export {};

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

@@ -0,0 +1,14 @@
+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';
+type Options<TSpec extends SpecType> = {
+    core: UFGCore<TSpec>;
+    logger: Logger;
+};
+export declare function makeTakeSnapshots<TSpec extends SpecType>({ core, logger: defaultLogger }: Options<TSpec>): ({ target, settings, logger, }: {
+    target: DriverTarget<TSpec>;
+    settings: SnapshotSettings<TSpec>;
+    logger?: Logger | undefined;
+}) => Promise<Snapshot[]>;
+export {};

package/types/autonomous/types.d.ts

@@ -0,0 +1,57 @@
+import type { Eyes as BaseEyes, ImageTarget as BaseImageTarget, OpenSettings as BaseOpenSettings, CheckSettings as BaseCheckSettings } from '@applitools/core-base/types';
+import type * as UFGCore from '../ufg/types';
+import { type Logger } from '@applitools/logger';
+import { type SpecType } from '@applitools/driver';
+import { type Environment as UFGEnvironment, type ActualEnvironment as UFGActualEnvironment, type RenderTarget as UFGRenderTarget, type StartedRender as UFGStartedRender } from '@applitools/ufg-client';
+export * from '../ufg/types';
+export interface AutonomousCore<TSpec extends SpecType> {
+    readonly type: 'autonomous';
+    takeSnapshots?(options: {
+        target: UFGCore.DriverTarget<TSpec>;
+        settings?: Partial<SnapshotSettings<TSpec>>;
+        logger?: Logger;
+    }): Promise<UFGCore.Snapshot[]>;
+    createRenderTarget(options: {
+        snapshot: UFGCore.Snapshot;
+        logger?: Logger;
+    }): Promise<RenderTarget>;
+    startRenders(options: {
+        targets: RenderTarget[];
+        logger?: Logger;
+    }): Promise<StartedRender[]>;
+    getRenderResults(options: {
+        renders: StartedRender[];
+        logger?: Logger;
+    }): Promise<RenderResult[]>;
+    createRenderResults(options: {
+        renders: StartedRender[];
+        rawResults: any[];
+        logger?: Logger;
+    }): Promise<RenderResult[]>;
+    openEyes(options: {
+        settings: Partial<OpenSettings>;
+        logger?: Logger;
+    }): Promise<BaseEyes>;
+}
+export type SnapshotSettings<TSpec extends SpecType> = UFGCore.SnapshotSettings<TSpec> & UFGCore.EyesServerSettings;
+export type RenderTarget = {
+    target: UFGRenderTarget;
+    settings: UFGCore.SafeCheckSettings;
+    environment: UFGEnvironment;
+    account: UFGCore.Account;
+};
+export type StartedRender = {
+    render: UFGStartedRender;
+    settings: UFGCore.SafeCheckSettings;
+    environment: UFGActualEnvironment;
+    account: UFGCore.Account;
+};
+export type RenderResult = {
+    status: 'rendering' | 'rendered' | 'error';
+    error: string;
+    target: BaseImageTarget;
+    settings: BaseCheckSettings;
+    environment: UFGActualEnvironment;
+    account: UFGCore.Account;
+};
+export type OpenSettings = BaseOpenSettings;

package/types/index.d.ts

@@ -2,6 +2,7 @@ export * from './types';
 export * from './core';
 export * from './universal/core-server';
 export * from './universal/core-server-process';
+export * from './autonomous/core';
 export { type SpecType, type SpecDriver, type Selector } from '@applitools/driver';
 export * from '@applitools/driver/dist/debug';
 export * as formatters from './utils/format-results';

package/types/ufg/check-and-close.d.ts

@@ -16,15 +16,16 @@ export declare function makeCheckAndClose<TSpec extends SpecType>({ eyes, target
     settings?: (import("@applitools/core-base").CheckSettings<Region | import("@applitools/driver").ElementReference<TSpec>> & import("./types").ScreenshotSettings<TSpec> & {
         environments?: Environment[] | undefined;
     } & {
-        hooks?: {
-            beforeCaptureScreenshot: string;
-        } | undefined;
         disableBrowserFetching?: boolean | undefined;
         layoutBreakpoints?: {
             breakpoints: boolean | number[];
             reload?: boolean | undefined;
         } | undefined;
+        hooks?: {
+            beforeCaptureScreenshot: string;
+        } | undefined;
         ufgOptions?: Record<string, any> | undefined;
+        prefixRenderId?: string | undefined;
         autProxy?: (import("@applitools/req").Proxy & {
             mode?: "Allow" | "Block" | undefined;
             domains?: string[] | undefined;

package/types/ufg/core.d.ts

@@ -11,12 +11,12 @@ type Options<TSpec extends SpecType> = {
         nml?: NMLClient;
     };
     base?: BaseCore;
+    asyncCache?: AsyncCache;
     concurrency?: number;
     fetchConcurrency?: number;
     agentId?: string;
     cwd?: string;
     logger?: Logger;
-    asyncCache?: AsyncCache;
 };
-export declare function makeCore<TSpec extends SpecType>({ spec, clients, base: defaultBase, concurrency, fetchConcurrency, agentId, cwd, logger: defaultLogger, asyncCache, }: Options<TSpec>): Core<TSpec>;
+export declare function makeCore<TSpec extends SpecType>({ spec, clients, base: defaultBase, asyncCache, concurrency, fetchConcurrency, agentId, cwd, logger: defaultLogger, }: Options<TSpec>): Core<TSpec>;
 export {};

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

@@ -0,0 +1,19 @@
+import type { DriverTarget, Core, SnapshotSettings, Account, Snapshot } from './types';
+import { type Environment as UFGEnvironment } from '@applitools/ufg-client';
+import { type AbortSignal } from 'abort-controller';
+import { type Logger } from '@applitools/logger';
+import { type SpecType, type SpecDriver } 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>;
+    settings?: SnapshotSettings<TSpec> | undefined;
+    environments?: UFGEnvironment[] | undefined;
+    account: Account;
+    logger?: Logger | undefined;
+}) => Promise<Snapshot[]>;
+export {};

package/types/ufg/types.d.ts

@@ -3,7 +3,7 @@ import type * as AutomationCore from '../automation/types';
 import { type SpecType, type CommonSelector } from '@applitools/driver';
 import { type Logger } from '@applitools/logger';
 import { type Proxy } from '@applitools/req';
-import { type UFGClient, type UFGClientSettings, type DomSnapshot as UFGDomSnapshot, type AndroidSnapshot as UFGAndroidSnapshot, type IOSSnapshot as UFGIOSSnapshot } from '@applitools/ufg-client';
+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';
 export * from '../automation/types';
 export type DomSnapshot = UFGDomSnapshot & {
     generatedSelectors?: {
@@ -21,6 +21,12 @@ export interface Core<TSpec extends SpecType> extends AutomationCore.Core<TSpec>
         settings: UFGClientSettings;
         logger?: Logger;
     }): Promise<UFGClient>;
+    takeSnapshots?(options: {
+        target: AutomationCore.DriverTarget<TSpec>;
+        settings?: SnapshotSettings<TSpec>;
+        account: AutomationCore.Account;
+        logger?: Logger;
+    }): Promise<Snapshot[]>;
     openEyes(options: {
         target?: AutomationCore.DriverTarget<TSpec>;
         settings: AutomationCore.OpenSettings;
@@ -42,19 +48,31 @@ export interface Eyes<TSpec extends SpecType> extends AutomationCore.Eyes<TSpec>
         logger?: Logger;
     }): Promise<void>;
 }
-export type CheckSettings<TSpec extends SpecType> = AutomationCore.CheckSettings<TSpec> & {
-    hooks?: {
-        beforeCaptureScreenshot: string;
-    };
+export type SnapshotSettings<TSpec extends SpecType> = AutomationCore.CheckSettings<TSpec> & {
     disableBrowserFetching?: boolean;
     layoutBreakpoints?: {
         breakpoints: number[] | boolean;
         reload?: boolean;
     };
+    hooks?: {
+        beforeCaptureScreenshot: string;
+    };
     ufgOptions?: Record<string, any>;
+    prefixRenderId?: string;
     autProxy?: Proxy & {
         mode?: 'Allow' | 'Block';
         domains?: string[];
     };
     headers?: Record<string, string>;
 };
+export type CheckSettings<TSpec extends SpecType> = SnapshotSettings<TSpec>;
+export type SafeCheckSettings = CheckSettings<SpecType<never, never, UFGSelector, never, never>>;
+export type Snapshot = {
+    target: DomSnapshot | AndroidSnapshot | IOSSnapshot;
+    settings: SafeCheckSettings;
+    environment: UFGEnvironment;
+    account: AutomationCore.Account;
+    url: string;
+    title: string;
+    userAgent?: string;
+};

package/types/ufg/utils/to-generated-selectors.d.ts

@@ -1,29 +1,30 @@
-import { type SpecType, type ElementReference, type CommonSelector } from '@applitools/driver';
+import { type SpecType, type ElementReference } from '@applitools/driver';
+import { type Selector as UFGSelector } from '@applitools/ufg-client';
 export declare function toGeneratedSelectors<TSpec extends SpecType>({ elementReferences, transformElementReference, }: {
     elementReferences: {
         target?: ElementReference<TSpec>;
         scrolling?: ElementReference<TSpec>;
         calculate?: ElementReference<TSpec>[];
     };
-    transformElementReference: (elementReference: ElementReference<TSpec>) => CommonSelector | undefined;
+    transformElementReference: (elementReference: ElementReference<TSpec>) => UFGSelector | undefined;
 }): {
     elementReferencesToMark: (string | TSpec["element"] | TSpec["secondary"]["element"] | TSpec["selector"] | TSpec["secondary"]["selector"] | {
         selector: string | TSpec["selector"] | TSpec["secondary"]["selector"];
         type?: string | undefined;
-        child?: TSpec["selector"] | TSpec["secondary"]["selector"] | CommonSelector<TSpec["selector"] | TSpec["secondary"]["selector"]> | undefined;
-        shadow?: TSpec["selector"] | TSpec["secondary"]["selector"] | CommonSelector<TSpec["selector"] | TSpec["secondary"]["selector"]> | undefined;
-        frame?: TSpec["selector"] | TSpec["secondary"]["selector"] | CommonSelector<TSpec["selector"] | TSpec["secondary"]["selector"]> | undefined;
-        fallback?: TSpec["selector"] | TSpec["secondary"]["selector"] | CommonSelector<TSpec["selector"] | TSpec["secondary"]["selector"]> | undefined;
+        child?: TSpec["selector"] | TSpec["secondary"]["selector"] | import("@applitools/driver").CommonSelector<TSpec["selector"] | TSpec["secondary"]["selector"]> | undefined;
+        shadow?: TSpec["selector"] | TSpec["secondary"]["selector"] | import("@applitools/driver").CommonSelector<TSpec["selector"] | TSpec["secondary"]["selector"]> | undefined;
+        frame?: TSpec["selector"] | TSpec["secondary"]["selector"] | import("@applitools/driver").CommonSelector<TSpec["selector"] | TSpec["secondary"]["selector"]> | undefined;
+        fallback?: TSpec["selector"] | TSpec["secondary"]["selector"] | import("@applitools/driver").CommonSelector<TSpec["selector"] | TSpec["secondary"]["selector"]> | undefined;
     } | (NonNullable<TSpec["element"]> extends infer T ? T extends NonNullable<TSpec["element"]> ? T extends readonly (infer InnerArr)[] ? InnerArr : T : never : never) | (NonNullable<TSpec["secondary"]["element"]> extends infer T_1 ? T_1 extends NonNullable<TSpec["secondary"]["element"]> ? T_1 extends readonly (infer InnerArr)[] ? InnerArr : T_1 : never : never) | (NonNullable<TSpec["selector"]> extends infer T_2 ? T_2 extends NonNullable<TSpec["selector"]> ? T_2 extends readonly (infer InnerArr)[] ? InnerArr : T_2 : never : never) | (NonNullable<TSpec["secondary"]["selector"]> extends infer T_3 ? T_3 extends NonNullable<TSpec["secondary"]["selector"]> ? T_3 extends readonly (infer InnerArr)[] ? InnerArr : T_3 : never : never))[];
     getGeneratedSelectors: (generatedSelectors?: {
-        originalSelector: CommonSelector | null;
-        safeSelector: CommonSelector | null;
+        originalSelector: UFGSelector | null;
+        safeSelector: UFGSelector | null;
     }[]) => {
-        target: CommonSelector | undefined;
-        scrolling: CommonSelector | undefined;
+        target: UFGSelector | undefined;
+        scrolling: UFGSelector | undefined;
         calculate: {
-            originalSelector: CommonSelector | null;
-            safeSelector: CommonSelector | null;
+            originalSelector: UFGSelector | null;
+            safeSelector: UFGSelector | null;
         }[];
     };
 };

package/types/ufg/utils/to-safe-check-settings.d.ts

@@ -0,0 +1,22 @@
+import type { CheckSettings, SafeCheckSettings } from '../types';
+import { type SpecType, type ElementReference, type CommonSelector } from '@applitools/driver';
+import { type Selector as UFGSelector } from '@applitools/ufg-client';
+export declare function toSafeCheckSettings<TSpec extends SpecType>({ settings }: {
+    settings: CheckSettings<TSpec>;
+}): {
+    elementReferences: {
+        target: ElementReference<TSpec> | undefined;
+        scrolling: ElementReference<TSpec> | undefined;
+        calculate: ElementReference<TSpec>[];
+    };
+    getSafeCheckSettings: ({ selectors, }: {
+        selectors: {
+            target: UFGSelector | undefined;
+            scrolling: UFGSelector | undefined;
+            calculate: {
+                originalSelector: CommonSelector | null;
+                safeSelector: UFGSelector | null;
+            }[];
+        };
+    }) => SafeCheckSettings;
+};