@applitools/core 4.49.0 → 4.50.0

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [4.50.0](https://github.com/Applitools-Dev/sdk/compare/js/core@4.49.0...js/core@4.50.0) (2025-10-08)
+
+
+### Features
+
+* add calculateEstimatedTime to autonomous core | FLD-3472 ([#3241](https://github.com/Applitools-Dev/sdk/issues/3241)) ([4ab2c36](https://github.com/Applitools-Dev/sdk/commit/4ab2c3602ffcf4cc428ca8e132fadcd955822c0a))
+
+
+### Dependencies
+
+* @applitools/dom-snapshot bumped to 4.13.8
+  #### Bug Fixes
+
+  * support cssom property rule ([#3263](https://github.com/Applitools-Dev/sdk/issues/3263)) ([c142687](https://github.com/Applitools-Dev/sdk/commit/c142687ec075784d0e0fb8f178af01c5e81dad82))
+
 ## [4.49.0](https://github.com/Applitools-Dev/sdk/compare/js/core@4.48.0...js/core@4.49.0) (2025-10-01)
 
 

package/dist/automation/utils/calculate-required-sizes.js

@@ -0,0 +1,70 @@
+"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.calculateRequiredSizesCount = exports.calculateRequiredSizes = void 0;
+const extract_environment_info_1 = require("./extract-environment-info");
+const utils = __importStar(require("@applitools/utils"));
+function calculateBreakpoint({ breakpoints, value }) {
+    const nextBreakpointIndex = breakpoints
+        .sort((item1, item2) => (item1 > item2 ? 1 : -1))
+        .findIndex(breakpoint => breakpoint > value);
+    if (nextBreakpointIndex === -1)
+        return breakpoints[breakpoints.length - 1];
+    else if (nextBreakpointIndex === 0)
+        return breakpoints[0] - 1;
+    else
+        return breakpoints[nextBreakpointIndex - 1];
+}
+async function calculateRequiredSizes(environments, settings, deviceProviders, initialViewportSize = { width: 1024, height: 768 }) {
+    var _a;
+    const isStrictBreakpoints = utils.types.isArray((_a = settings.layoutBreakpoints) === null || _a === void 0 ? void 0 : _a.breakpoints);
+    return await environments.reduce(async (prev, environment, index) => {
+        var _a;
+        const { name, width, height } = await (0, extract_environment_info_1.extractEnvironmentInfo)(environment, deviceProviders);
+        const requiredSizes = await prev;
+        let requiredSize;
+        if ((_a = settings.layoutBreakpoints) === null || _a === void 0 ? void 0 : _a.heightBreakpoints) {
+            const requiredWidth = settings.layoutBreakpoints.breakpoints ? width : initialViewportSize.width;
+            requiredSize = `${requiredWidth},${height}`;
+        }
+        else {
+            const requiredWidth = isStrictBreakpoints
+                ? calculateBreakpoint({ breakpoints: settings.layoutBreakpoints.breakpoints, value: width })
+                : width;
+            requiredSize = `${requiredWidth},${initialViewportSize.height}`;
+        }
+        let environments = requiredSizes.get(requiredSize);
+        if (!environments)
+            requiredSizes.set(requiredSize, (environments = []));
+        environments.push({ name, width, height, index });
+        return requiredSizes;
+    }, Promise.resolve(new Map()));
+}
+exports.calculateRequiredSizes = calculateRequiredSizes;
+async function calculateRequiredSizesCount(environments, settings, deviceProviders, initialViewportSize = { width: 1024, height: 768 }) {
+    const requiredSizes = await calculateRequiredSizes(environments, settings, deviceProviders, initialViewportSize);
+    return requiredSizes.size || 1;
+}
+exports.calculateRequiredSizesCount = calculateRequiredSizesCount;

package/dist/automation/utils/defaults.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_LAZY_LOAD = exports.DEFAULT_WAIT_BEFORE_CAPTURE = void 0;
+exports.DEFAULT_WAIT_BEFORE_CAPTURE = 100;
+exports.DEFAULT_LAZY_LOAD = {
+    scrollLength: 300,
+    waitingTime: 2000,
+    maxAmountToScroll: 15000,
+};

package/dist/automation/utils/extract-environment-info.js

@@ -0,0 +1,45 @@
+"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.extractEnvironmentInfo = void 0;
+const utils = __importStar(require("@applitools/utils"));
+async function extractEnvironmentInfo(environment, provides) {
+    if (utils.types.has(environment, ['width', 'height'])) {
+        const { name, width, height } = environment;
+        return { name: name !== null && name !== void 0 ? name : 'default', width, height };
+    }
+    else if (utils.types.has(environment, 'chromeEmulationInfo')) {
+        const devices = await provides.getChromeEmulationDevices();
+        const { deviceName, screenOrientation = 'portrait' } = environment.chromeEmulationInfo;
+        return { name: deviceName, screenOrientation, ...devices[deviceName][screenOrientation] };
+    }
+    else if (utils.types.has(environment, 'iosDeviceInfo')) {
+        const devices = await provides.getIOSDevices();
+        const { deviceName, screenOrientation = 'portrait' } = environment.iosDeviceInfo;
+        return { name: deviceName, screenOrientation, ...devices[deviceName][screenOrientation] };
+    }
+    throw new Error('Unknown environment type');
+}
+exports.extractEnvironmentInfo = extractEnvironmentInfo;

package/dist/autonomous/calculate-estimated-time.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeCalculateEstimatedTime = void 0;
+const calculate_required_sizes_1 = require("../automation/utils/calculate-required-sizes");
+const defaults_1 = require("../automation/utils/defaults");
+const verify_environment_info_1 = require("../ufg/utils/verify-environment-info");
+const populate_eyes_server_settings_1 = require("../utils/populate-eyes-server-settings");
+function makeCalculateEstimatedTime({ core, logger }) {
+    return async function calculateEstimatedTime({ settings }) {
+        var _a;
+        (0, populate_eyes_server_settings_1.populateEyesServerSettings)(settings);
+        const accountInfo = await core.getAccountInfo({ settings, logger });
+        const ufgClient = await core.getUFGClient({ settings: {
+                ...settings,
+                ufgServerUrl: accountInfo.ufgServer.ufgServerUrl,
+                accessToken: accountInfo.ufgServer.accessToken,
+            }, logger });
+        const deviceProviders = {
+            getChromeEmulationDevices: ufgClient.getChromeEmulationDevices.bind(ufgClient),
+            getIOSDevices: ufgClient.getIOSDevices.bind(ufgClient),
+        };
+        const environments = settings.environments || [];
+        // Validate environments first (same as open() does)
+        await (0, verify_environment_info_1.verifyEnvironmentsInfo)({ environments, ufgClient });
+        const { scrollLength, waitingTime, maxAmountToScroll } = {
+            ...defaults_1.DEFAULT_LAZY_LOAD,
+            ...(typeof settings.lazyLoad === 'object' ? settings.lazyLoad : {}),
+        };
+        // Calculate lazy load time per breakpoint
+        const lazyLoadTimePerBreakpoint = settings.lazyLoad
+            ? Math.ceil(maxAmountToScroll / scrollLength) * waitingTime
+            : 0;
+        // Calculate total times (only handle number case for time estimation, default from defaults.ts)
+        const waitBeforeCapture = Number(settings.waitBeforeCapture) || defaults_1.DEFAULT_WAIT_BEFORE_CAPTURE;
+        // Calculate required sizes count using the same logic as take-dom-snapshots
+        // Match the early return logic: if no layoutBreakpoints.breakpoints, take single snapshot
+        const waitCount = !((_a = settings.layoutBreakpoints) === null || _a === void 0 ? void 0 : _a.breakpoints)
+            ? 1
+            : await (0, calculate_required_sizes_1.calculateRequiredSizesCount)(environments, settings, deviceProviders);
+        // For numberOfBreakpoints, we need to count unique widths regardless of layoutBreakpoints
+        // We can reuse the same logic but ignore layoutBreakpoints settings
+        const settingsForBreakpointCount = { ...settings, layoutBreakpoints: undefined };
+        const numberOfBreakpoints = await (0, calculate_required_sizes_1.calculateRequiredSizesCount)(environments, settingsForBreakpointCount, deviceProviders);
+        const waitBeforeCaptureTime = waitBeforeCapture * waitCount;
+        const lazyLoadTime = lazyLoadTimePerBreakpoint * numberOfBreakpoints;
+        return {
+            totalTime: waitBeforeCaptureTime + lazyLoadTime,
+            breakdown: {
+                lazyLoadTimePerBreakpoint,
+                numberOfBreakpoints,
+                waitBeforeCaptureTime,
+            },
+        };
+    };
+}
+exports.makeCalculateEstimatedTime = makeCalculateEstimatedTime;

package/dist/autonomous/core.js

@@ -11,6 +11,7 @@ const create_render_results_1 = require("./create-render-results");
 const open_eyes_1 = require("./open-eyes");
 const open_check_and_close_1 = require("./open-check-and-close");
 const register_default_scripts_1 = require("../ufg/utils/register-default-scripts");
+const calculate_estimated_time_1 = require("./calculate-estimated-time");
 function makeAutonomousCore({ spec, clients, base: defaultBase, asyncCache, agentId = 'core-autonomous', 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, logger });
@@ -25,6 +26,7 @@ function makeAutonomousCore({ spec, clients, base: defaultBase, asyncCache, agen
         /** @deprecated */
         openEyes: (0, open_eyes_1.makeOpenEyes)({ core, logger }),
         openCheckAndClose: (0, open_check_and_close_1.makeOpenCheckAndClose)({ core, logger }),
+        calculateEstimatedTime: (0, calculate_estimated_time_1.makeCalculateEstimatedTime)({ core, logger }),
     };
 }
 exports.makeAutonomousCore = makeAutonomousCore;

package/dist/check.js

@@ -28,6 +28,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeCheck = void 0;
 const driver_1 = require("@applitools/driver");
+const defaults_1 = require("./automation/utils/defaults");
 const utils = __importStar(require("@applitools/utils"));
 const lang = __importStar(require("./lang"));
 const chalk_1 = __importDefault(require("chalk"));
@@ -39,7 +40,7 @@ function makeCheck({ type: defaultType = 'classic', eyes, target: defaultTarget,
         logger = logger.extend(mainLogger, { tags: [`check-${type}-${utils.general.shortid()}`] });
         settings = { ...config === null || config === void 0 ? void 0 : config.screenshot, ...config === null || config === void 0 ? void 0 : config.check, ...settings };
         (_a = settings.fully) !== null && _a !== void 0 ? _a : (settings.fully = !settings.region && (!settings.frames || settings.frames.length === 0));
-        (_b = settings.waitBeforeCapture) !== null && _b !== void 0 ? _b : (settings.waitBeforeCapture = 100);
+        (_b = settings.waitBeforeCapture) !== null && _b !== void 0 ? _b : (settings.waitBeforeCapture = defaults_1.DEFAULT_WAIT_BEFORE_CAPTURE);
         (_c = settings.hideScrollbars) !== null && _c !== void 0 ? _c : (settings.hideScrollbars = true);
         (_d = settings.hideCaret) !== null && _d !== void 0 ? _d : (settings.hideCaret = true);
         settings.overlap = { top: 10, bottom: 50, ...settings === null || settings === void 0 ? void 0 : settings.overlap };
@@ -58,12 +59,12 @@ function makeCheck({ type: defaultType = 'classic', eyes, target: defaultTarget,
         (_k = (_r = settings).retryTimeout) !== null && _k !== void 0 ? _k : (_r.retryTimeout = 0);
         settings.lazyLoad = settings.lazyLoad === true ? {} : settings.lazyLoad;
         if (settings.lazyLoad) {
-            (_l = (_s = settings.lazyLoad).scrollLength) !== null && _l !== void 0 ? _l : (_s.scrollLength = 300);
-            (_m = (_t = settings.lazyLoad).waitingTime) !== null && _m !== void 0 ? _m : (_t.waitingTime = 2000);
-            (_o = (_u = settings.lazyLoad).maxAmountToScroll) !== null && _o !== void 0 ? _o : (_u.maxAmountToScroll = 15000);
+            (_l = (_s = settings.lazyLoad).scrollLength) !== null && _l !== void 0 ? _l : (_s.scrollLength = defaults_1.DEFAULT_LAZY_LOAD.scrollLength);
+            (_m = (_t = settings.lazyLoad).waitingTime) !== null && _m !== void 0 ? _m : (_t.waitingTime = defaults_1.DEFAULT_LAZY_LOAD.waitingTime);
+            (_o = (_u = settings.lazyLoad).maxAmountToScroll) !== null && _o !== void 0 ? _o : (_u.maxAmountToScroll = defaults_1.DEFAULT_LAZY_LOAD.maxAmountToScroll);
         }
         settings.stepIndex = stepIndex++;
-        (_p = settings.waitBetweenStitches) !== null && _p !== void 0 ? _p : (settings.waitBetweenStitches = utils.types.isObject(settings.lazyLoad) ? settings.lazyLoad.waitingTime : 100);
+        (_p = settings.waitBetweenStitches) !== null && _p !== void 0 ? _p : (settings.waitBetweenStitches = utils.types.isObject(settings.lazyLoad) ? settings.lazyLoad.waitingTime : defaults_1.DEFAULT_WAIT_BEFORE_CAPTURE);
         if (settings.mobileOptions) {
             (_q = (_v = settings.mobileOptions).keepNavigationBar) !== null && _q !== void 0 ? _q : (_v.keepNavigationBar = false);
         }

package/dist/ufg/utils/take-dom-snapshot.js

@@ -43,7 +43,7 @@ async function takeDomSnapshot({ context, settings, logger, }) {
     return snapshot;
     async function takeContextDomSnapshot({ context, isRootFrame, }) {
         // logger.log(`taking dom snapshot. ${context._reference ? `context referece: ${JSON.stringify(context._reference)}` : ''}`)
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         const arg = {
             dontFetchResources: settings === null || settings === void 0 ? void 0 : settings.disableBrowserFetching,
             skipResources: settings === null || settings === void 0 ? void 0 : settings.skipResources,
@@ -79,7 +79,8 @@ async function takeDomSnapshot({ context, settings, logger, }) {
                 .context(reference)
                 .then(context => context.focus())
                 .catch(err => {
-                const srcAttr = cdtNode.attributes.find(attr => attr.name === 'src');
+                var _a;
+                const srcAttr = (_a = cdtNode.attributes) === null || _a === void 0 ? void 0 : _a.find(attr => attr.name === 'src');
                 if (srcAttr)
                     srcAttr.value = '';
                 logger.log(`could not switch to frame during takeDomSnapshot. Path to frame: ${JSON.stringify(reference)}`, err);
@@ -96,7 +97,7 @@ async function takeDomSnapshot({ context, settings, logger, }) {
                     url.searchParams.set('applitools-iframe', utils.general.guid());
                 frameSnapshot.url = url.href;
                 parentSnapshot.frames.push(frameSnapshot);
-                cdtNode.attributes.push({ name: 'data-applitools-src', value: frameSnapshot.url });
+                (_d = cdtNode.attributes) === null || _d === void 0 ? void 0 : _d.push({ name: 'data-applitools-src', value: frameSnapshot.url });
             }
         }
         logSnapshot(logger, snapshot);

package/dist/ufg/utils/take-dom-snapshots.js

@@ -33,6 +33,7 @@ exports.takeDomSnapshots = void 0;
 const take_dom_snapshot_1 = require("./take-dom-snapshot");
 const generate_safe_selectors_1 = require("./generate-safe-selectors");
 const wait_for_lazy_load_1 = require("../../automation/utils/wait-for-lazy-load");
+const calculate_required_sizes_1 = require("../../automation/utils/calculate-required-sizes");
 const chalk_1 = __importDefault(require("chalk"));
 const utils = __importStar(require("@applitools/utils"));
 const lang = __importStar(require("../../lang"));
@@ -55,27 +56,7 @@ async function takeDomSnapshots({ driver, settings, hooks, provides, logger, })
     }
     const isStrictBreakpoints = utils.types.isArray((_b = settings.layoutBreakpoints) === null || _b === void 0 ? void 0 : _b.breakpoints);
     const initialViewportSize = await driver.getViewportSize();
-    const requiredSizes = await settings.environments.reduce(async (prev, environment, index) => {
-        var _a;
-        const { name, width, height } = (await extractEnvironmentInfo(environment));
-        const requiredSizes = await prev;
-        let requiredSize;
-        if ((_a = settings.layoutBreakpoints) === null || _a === void 0 ? void 0 : _a.heightBreakpoints) {
-            const requiredWidth = settings.layoutBreakpoints.breakpoints ? width : initialViewportSize.width;
-            requiredSize = `${requiredWidth},${height}`;
-        }
-        else {
-            const requiredWidth = isStrictBreakpoints
-                ? calculateBreakpoint({ breakpoints: settings.layoutBreakpoints.breakpoints, value: width })
-                : width;
-            requiredSize = `${requiredWidth},${initialViewportSize.height}`;
-        }
-        let environments = requiredSizes.get(requiredSize);
-        if (!environments)
-            requiredSizes.set(requiredSize, (environments = []));
-        environments.push({ name, width, height, index });
-        return requiredSizes;
-    }, Promise.resolve(new Map()));
+    const requiredSizes = await (0, calculate_required_sizes_1.calculateRequiredSizes)(settings.environments, settings, provides, initialViewportSize);
     const smallestBreakpoint = Math.min(...(isStrictBreakpoints ? settings.layoutBreakpoints.breakpoints : []));
     const smallestSize = `${smallestBreakpoint - 1},${initialViewportSize.height}`;
     if (isStrictBreakpoints && requiredSizes.has(smallestSize)) {
@@ -159,32 +140,5 @@ async function takeDomSnapshots({ driver, settings, hooks, provides, logger, })
             await ((_b = driver.executeUserFunction) === null || _b === void 0 ? void 0 : _b.call(driver, settings.waitBeforeCapture));
         }
     }
-    function calculateBreakpoint({ breakpoints, value }) {
-        const nextBreakpointIndex = breakpoints
-            .sort((item1, item2) => (item1 > item2 ? 1 : -1))
-            .findIndex(breakpoint => breakpoint > value);
-        if (nextBreakpointIndex === -1)
-            return breakpoints[breakpoints.length - 1];
-        else if (nextBreakpointIndex === 0)
-            return breakpoints[0] - 1;
-        else
-            return breakpoints[nextBreakpointIndex - 1];
-    }
-    async function extractEnvironmentInfo(environment) {
-        if (utils.types.has(environment, ['width', 'height'])) {
-            const { name, width, height } = environment;
-            return { name: name !== null && name !== void 0 ? name : 'default', width, height };
-        }
-        else if (utils.types.has(environment, 'chromeEmulationInfo')) {
-            const devices = await provides.getChromeEmulationDevices();
-            const { deviceName, screenOrientation = 'portrait' } = environment.chromeEmulationInfo;
-            return { name: deviceName, screenOrientation, ...devices[deviceName][screenOrientation] };
-        }
-        else if (utils.types.has(environment, 'iosDeviceInfo')) {
-            const devices = await provides.getIOSDevices();
-            const { deviceName, screenOrientation = 'portrait' } = environment.iosDeviceInfo;
-            return { name: deviceName, screenOrientation, ...devices[deviceName][screenOrientation] };
-        }
-    }
 }
 exports.takeDomSnapshots = takeDomSnapshots;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applitools/core",
-  "version": "4.49.0",
+  "version": "4.50.0",
   "homepage": "https://applitools.com",
   "bugs": {
     "url": "https://github.com/applitools/eyes.sdk.javascript1/issues"
@@ -81,7 +81,7 @@
   "dependencies": {
     "@applitools/core-base": "1.28.1",
     "@applitools/dom-capture": "11.6.5",
-    "@applitools/dom-snapshot": "4.13.7",
+    "@applitools/dom-snapshot": "4.13.8",
     "@applitools/driver": "1.23.5",
     "@applitools/ec-client": "1.12.9",
     "@applitools/logger": "2.2.4",

package/types/automation/utils/calculate-required-sizes.d.ts

@@ -0,0 +1,17 @@
+import type { Environment } from '../types';
+import type { SpecType } from '@applitools/driver';
+import type { SnapshotSettings } from '../../autonomous/types';
+import { type DeviceProviders } from './extract-environment-info';
+export declare function calculateRequiredSizes<TSpec extends SpecType>(environments: Environment[], settings: Partial<SnapshotSettings<TSpec>>, deviceProviders: DeviceProviders, initialViewportSize?: {
+    width: number;
+    height: number;
+}): Promise<Map<string, {
+    name: string;
+    width: number;
+    height: number;
+    index: number;
+}[]>>;
+export declare function calculateRequiredSizesCount<TSpec extends SpecType>(environments: Environment[], settings: Partial<SnapshotSettings<TSpec>>, deviceProviders: DeviceProviders, initialViewportSize?: {
+    width: number;
+    height: number;
+}): Promise<number>;

package/types/automation/utils/defaults.d.ts

@@ -0,0 +1,6 @@
+export declare const DEFAULT_WAIT_BEFORE_CAPTURE = 100;
+export declare const DEFAULT_LAZY_LOAD: {
+    readonly scrollLength: 300;
+    readonly waitingTime: 2000;
+    readonly maxAmountToScroll: 15000;
+};

package/types/automation/utils/extract-environment-info.d.ts

@@ -0,0 +1,21 @@
+import type { Environment } from '../types';
+export type DeviceProviders = {
+    getChromeEmulationDevices(): Promise<Record<string, Record<string, {
+        width: number;
+        height: number;
+    }>>>;
+    getIOSDevices(): Promise<Record<string, Record<string, {
+        width: number;
+        height: number;
+    }>>>;
+};
+export declare function extractEnvironmentInfo(environment: Environment, provides: DeviceProviders): Promise<{
+    name: string;
+    width: number;
+    height: number;
+} | {
+    width: number;
+    height: number;
+    name: string;
+    screenOrientation: string;
+}>;

package/types/autonomous/calculate-estimated-time.d.ts

@@ -0,0 +1,12 @@
+import type { EstimatedTimeResult, SnapshotSettings } from './types';
+import type { SpecType } from '@applitools/driver';
+import type { EyesServerSettings, Core as UFGCore } from '../ufg/types';
+import type { Logger } from '@applitools/logger';
+type Options<TSpec extends SpecType> = {
+    settings: Partial<SnapshotSettings<TSpec>> & EyesServerSettings;
+};
+export declare function makeCalculateEstimatedTime<TSpec extends SpecType>({ core, logger }: {
+    core: UFGCore<TSpec>;
+    logger: Logger;
+}): ({ settings }: Options<TSpec>) => Promise<EstimatedTimeResult>;
+export {};

package/types/autonomous/types.d.ts

@@ -45,6 +45,19 @@ export interface AutonomousCore<TSpec extends SpecType> {
         closeSettings?: BaseCloseSettings;
         logger?: Logger;
     }): Promise<void>;
+    calculateEstimatedTime(options: {
+        settings: Partial<SnapshotSettings<TSpec>>;
+        provides?: {
+            getChromeEmulationDevices(): Promise<Record<string, Record<string, {
+                width: number;
+                height: number;
+            }>>>;
+            getIOSDevices(): Promise<Record<string, Record<string, {
+                width: number;
+                height: number;
+            }>>>;
+        };
+    }): Promise<EstimatedTimeResult>;
 }
 export type SnapshotSettings<TSpec extends SpecType> = UFGCore.SnapshotSettings<TSpec> & UFGCore.EyesServerSettings;
 export type RenderTargetWithSettings = {
@@ -68,3 +81,11 @@ export type RenderResult = {
     account: UFGCore.Account;
 };
 export type OpenSettings = BaseOpenSettings;
+export type EstimatedTimeResult = {
+    totalTime: number;
+    breakdown: {
+        lazyLoadTimePerBreakpoint: number;
+        numberOfBreakpoints: number;
+        waitBeforeCaptureTime: number;
+    };
+};

package/types/ufg/utils/take-dom-snapshot.d.ts

@@ -1,6 +1,6 @@
-import { type DomSnapshot } from '../types';
-import { type Logger } from '@applitools/logger';
-import { type SpecType, type Context, type Cookie, type ElementReference, type CommonSelector } from '@applitools/driver';
+import type { DomSnapshot } from '../types';
+import type { Logger } from '@applitools/logger';
+import type { SpecType, Context, Cookie, ElementReference, CommonSelector } from '@applitools/driver';
 export type RawDomSnapshot = {
     url: string;
     selector?: string;