@applitools/core 3.9.0 → 3.10.0

package/dist/ufg/utils/extract-default-renderers.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractDefaultRenderers = void 0;
+async function extractDefaultRenderers({ driver, }) {
+    if (!driver)
+        return [];
+    const currentContext = driver.currentContext;
+    try {
+        const environment = await driver.getEnvironment();
+        if (environment.isWeb) {
+            const viewportSize = await driver.getViewportSize();
+            return [{ name: 'chrome', ...viewportSize }];
+        }
+        else {
+            return [];
+        }
+    }
+    finally {
+        await currentContext.focus();
+    }
+}
+exports.extractDefaultRenderers = extractDefaultRenderers;

package/dist/universal/core.js

@@ -112,6 +112,7 @@ function makeEyes({ socket, core, eyesRef, }) {
     const eyes = {
         test: null,
         running: null,
+        storage: null,
         core,
         getBaseEyes() {
             return null;

package/dist/universal/spec-driver.js

@@ -27,7 +27,6 @@ exports.makeSpec = void 0;
 const utils = __importStar(require("@applitools/utils"));
 function makeSpec({ socket, spec, }) {
     const commands = {
-        // #region UTILITY
         isDriver(driver) {
             return utils.types.has(driver, 'applitools-ref-id');
         },
@@ -44,32 +43,17 @@ function makeSpec({ socket, spec, }) {
                     utils.types.has(selector, 'selector') &&
                     (utils.types.isString(selector.selector) || utils.types.has(selector, 'applitools-ref-id'))));
         },
-        extractContext(driver) {
-            return driver.context;
-        },
-        extractSelector(element) {
-            return element.selector;
-        },
-        extractHostName(driver) {
-            var _a;
-            return (_a = driver.hostname) !== null && _a !== void 0 ? _a : null;
-        },
-        isStaleElementError(error) {
-            return error === null || error === void 0 ? void 0 : error.isStaleElementError;
-        },
         async isEqualElements(context, element1, element2) {
             return socket.request('Driver.isEqualElements', { context, element1, element2 });
         },
-        // #endregion
-        // #region COMMANDS
-        async mainContext(context) {
-            return socket.request('Driver.mainContext', { context });
+        isStaleElementError(error) {
+            return error === null || error === void 0 ? void 0 : error.isStaleElementError;
         },
-        async parentContext(context) {
-            return socket.request('Driver.parentContext', { context });
+        extractContext(driver) {
+            return driver.context;
         },
-        async childContext(context, element) {
-            return socket.request('Driver.childContext', { context, element });
+        extractSelector(element) {
+            return element.selector;
         },
         async executeScript(context, script, arg) {
             return socket.request('Driver.executeScript', { context, script: script.toString(), arg });
@@ -89,20 +73,26 @@ function makeSpec({ socket, spec, }) {
         async setElementText(context, element, text) {
             return socket.request('Driver.setElementText', { context, element, text });
         },
-        async getWindowSize(driver) {
-            return socket.request('Driver.getWindowSize', { driver });
+        async getElementRegion(context, element) {
+            return socket.request('Driver.getElementRegion', { context, element });
         },
-        async setWindowSize(driver, size) {
-            return socket.request('Driver.setWindowSize', { driver, size });
+        async getElementAttribute(context, element, attr) {
+            return socket.request('Driver.getElementAttribute', { context, element, attr });
         },
-        async getViewportSize(driver) {
-            return socket.request('Driver.getViewportSize', { driver });
+        async hover(context, element) {
+            return socket.request('Driver.hover', { context, element });
         },
-        async setViewportSize(driver, size) {
-            return socket.request('Driver.setViewportSize', { driver, size });
+        async click(context, element) {
+            return socket.request('Driver.click', { context, element });
         },
-        async getCookies(driver, context) {
-            return socket.request('Driver.getCookies', { driver, context });
+        async mainContext(context) {
+            return socket.request('Driver.mainContext', { context });
+        },
+        async parentContext(context) {
+            return socket.request('Driver.parentContext', { context });
+        },
+        async childContext(context, element) {
+            return socket.request('Driver.childContext', { context, element });
         },
         async getCapabilities(driver) {
             return socket.request('Driver.getCapabilities', { driver });
@@ -110,23 +100,18 @@ function makeSpec({ socket, spec, }) {
         async getDriverInfo(driver) {
             return socket.request('Driver.getDriverInfo', { driver });
         },
-        async getTitle(driver) {
-            return socket.request('Driver.getTitle', { driver });
-        },
-        async getUrl(driver) {
-            return socket.request('Driver.getUrl', { driver });
+        async getWindowSize(driver) {
+            return socket.request('Driver.getWindowSize', { driver });
         },
-        async takeScreenshot(driver) {
-            return socket.request('Driver.takeScreenshot', { driver });
+        async setWindowSize(driver, size) {
+            return socket.request('Driver.setWindowSize', { driver, size });
         },
-        async click(context, element) {
-            return socket.request('Driver.click', { context, element });
+        async getViewportSize(driver) {
+            return socket.request('Driver.getViewportSize', { driver });
         },
-        async visit(driver, url) {
-            return socket.request('Driver.visit', { driver, url });
+        async setViewportSize(driver, size) {
+            return socket.request('Driver.setViewportSize', { driver, size });
         },
-        // #endregion
-        // #region NATIVE COMMANDS
         async getSystemBars(driver) {
             return socket.request('Driver.getSystemBars', { driver });
         },
@@ -136,15 +121,24 @@ function makeSpec({ socket, spec, }) {
         async setOrientation(driver, orientation) {
             return socket.request('Driver.setOrientation', { driver, orientation });
         },
-        async getElementRegion(driver, element) {
-            return socket.request('Driver.getElementRegion', { driver, element });
+        async getCookies(driver, context) {
+            return socket.request('Driver.getCookies', { driver, context });
+        },
+        async getTitle(driver) {
+            return socket.request('Driver.getTitle', { driver });
+        },
+        async getUrl(driver) {
+            return socket.request('Driver.getUrl', { driver });
         },
-        async getElementAttribute(driver, element, attr) {
-            return socket.request('Driver.getElementAttribute', { driver, element, attr });
+        async takeScreenshot(driver) {
+            return socket.request('Driver.takeScreenshot', { driver });
         },
         async performAction(driver, steps) {
             return socket.request('Driver.performAction', { driver, steps });
         },
+        async visit(driver, url) {
+            return socket.request('Driver.visit', { driver, url });
+        },
         async getCurrentWorld(driver) {
             return socket.request('Driver.getCurrentWorld', { driver });
         },
@@ -154,7 +148,6 @@ function makeSpec({ socket, spec, }) {
         async switchWorld(driver, name) {
             return socket.request('Driver.switchWorld', { driver, name });
         },
-        // #endregion
     };
     return spec.reduce((spec, name) => {
         return Object.assign(spec, { [name]: commands[name] });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applitools/core",
-  "version": "3.9.0",
+  "version": "3.10.0",
   "homepage": "https://applitools.com",
   "bugs": {
     "url": "https://github.com/applitools/eyes.sdk.javascript1/issues"
@@ -46,8 +46,8 @@
     "build:dist": "run --top-level tsc --project ./tsconfig.build.json",
     "build:x64": "yarn build:dist && yarn build:bin:x64",
     "build:arm64": "yarn build:dist && yarn build:bin:arm64",
-    "build:bin:x64": "pkg . --target node14-linux-x64,node14-alpine-x64,node14-macos-x64,node14-win-x64",
-    "build:bin:arm64": "pkg . --target node14-linux-arm64 --output ./bin/core-linux-arm64",
+    "build:bin:x64": "rm -rf ../spec-driver-webdriver/node_modules/webdriver && pkg . --target node14-linux-x64,node14-alpine-x64,node14-macos-x64,node14-win-x64",
+    "build:bin:arm64": "rm -rf ../spec-driver-webdriver/node_modules/webdriver && pkg . --target node14-linux-arm64 --output ./bin/core-linux-arm64",
     "build:bin:zip": "zip -j ./bin/core.zip $(find ./bin -type f -not -name '*.zip' -not -name '*.tar.gz' | xargs)",
     "build:bin:tgz": "tar -czf ./bin/core.tar.gz $(find ./bin -type f -not -name '*.zip' -not -name '*.tar.gz' | xargs)",
     "test": "run --top-level mocha './test/**/*.spec.ts' --exclude './test/bin/**' --parallel --jobs ${MOCHA_JOBS:-15} --exit",
@@ -62,52 +62,47 @@
   "pkg": {
     "scripts": "./dist/cli/cli.js",
     "outputPath": "./bin",
-    "compress": "GZip",
-    "assets": [
-      "./node_modules/vm2/lib/setup-sandbox.js"
-    ]
+    "compress": "GZip"
   },
   "dependencies": {
-    "@applitools/core-base": "1.5.0",
+    "@applitools/core-base": "1.5.2",
     "@applitools/dom-capture": "11.2.2",
     "@applitools/dom-snapshot": "4.7.10",
-    "@applitools/driver": "1.13.4",
-    "@applitools/ec-client": "1.7.4",
-    "@applitools/logger": "2.0.7",
-    "@applitools/nml-client": "1.5.7",
-    "@applitools/req": "1.5.2",
-    "@applitools/screenshoter": "3.8.7",
-    "@applitools/snippets": "2.4.22",
-    "@applitools/socket": "1.1.7",
-    "@applitools/spec-driver-webdriver": "1.0.41",
-    "@applitools/ufg-client": "1.7.0",
-    "@applitools/utils": "1.5.0",
+    "@applitools/driver": "1.13.6",
+    "@applitools/ec-client": "1.7.6",
+    "@applitools/logger": "2.0.9",
+    "@applitools/nml-client": "1.5.9",
+    "@applitools/req": "1.5.4",
+    "@applitools/screenshoter": "3.8.9",
+    "@applitools/snippets": "2.4.23",
+    "@applitools/socket": "1.1.9",
+    "@applitools/spec-driver-webdriver": "1.0.43",
+    "@applitools/ufg-client": "1.7.2",
+    "@applitools/utils": "1.5.2",
     "@types/ws": "8.5.5",
     "abort-controller": "3.0.0",
     "chalk": "4.1.2",
     "node-fetch": "2.6.7",
-    "webdriver": "7.30.0",
+    "webdriver": "7.31.1",
     "ws": "8.13.0",
     "yargs": "17.7.2"
   },
   "devDependencies": {
-    "@applitools/bongo": "^5.4.3",
-    "@applitools/spec-driver-puppeteer": "^1.1.72",
-    "@applitools/spec-driver-selenium": "^1.5.55",
-    "@applitools/spec-driver-webdriverio": "^1.5.10",
+    "@applitools/bongo": "^5.6.1",
+    "@applitools/spec-driver-puppeteer": "^1.1.74",
+    "@applitools/spec-driver-selenium": "^1.5.57",
     "@applitools/test-server": "^1.2.2",
     "@applitools/test-utils": "^1.5.17",
-    "@applitools/tunnel-client": "^1.1.3",
+    "@applitools/tunnel-client": "^1.2.1",
     "@types/node": "^12.20.55",
     "@types/selenium-webdriver": "^4.1.2",
     "@types/yargs": "^17.0.22",
-    "chromedriver": "^114.0.3",
+    "chromedriver": "^115.0.1",
     "nock": "^13.3.2",
     "pkg": "^5.8.0",
     "png-async": "^0.9.4",
     "puppeteer": "^19.11.1",
-    "selenium-webdriver": "4.4",
-    "webdriverio": "^7.25.0"
+    "selenium-webdriver": "4.4"
   },
   "engines": {
     "node": ">=12.13.0"

package/types/abort.d.ts

@@ -0,0 +1,13 @@
+import type { Eyes, AbortSettings, Renderer } from './types';
+import { type SpecType } from '@applitools/driver';
+import { type Logger } from '@applitools/logger';
+type Options<TSpec extends SpecType, TType extends 'classic' | 'ufg'> = {
+    eyes: Eyes<TSpec, TType>;
+    renderers?: Renderer[];
+    logger: Logger;
+};
+export declare function makeAbort<TSpec extends SpecType, TType extends 'classic' | 'ufg'>({ eyes, renderers: defaultRenderers, logger: mainLogger, }: Options<TSpec, TType>): ({ settings, logger, }?: {
+    settings?: AbortSettings<TType> | undefined;
+    logger?: Logger | undefined;
+}) => Promise<void>;
+export {};

package/types/{classic → automation}/abort.d.ts

@@ -1,15 +1,16 @@
-import type { AbortSettings } from './types';
-import type { Eyes } from './types';
+import type { DriverTarget, Eyes, AbortSettings, Renderer } from './types';
 import { type Logger } from '@applitools/logger';
-import type { DriverTarget } from './types';
+import { type AbortController } from 'abort-controller';
 import { type SpecType, type SpecDriver } from '@applitools/driver';
 type Options<TSpec extends SpecType> = {
     eyes: Eyes<TSpec>;
     target?: DriverTarget<TSpec>;
+    controller: AbortController;
+    renderers?: Renderer[];
     spec?: SpecDriver<TSpec>;
     logger: Logger;
 };
-export declare function makeAbort<TSpec extends SpecType>({ eyes, target, spec, logger: mainLogger }: Options<TSpec>): ({ settings, logger, }?: {
+export declare function makeAbort<TSpec extends SpecType>({ eyes, target, controller, renderers: defaultRenderers, spec, logger: mainLogger, }: Options<TSpec>): ({ settings, logger, }?: {
     settings?: AbortSettings | undefined;
     logger?: Logger | undefined;
 }) => Promise<void>;

package/types/{classic → automation}/close.d.ts

@@ -1,15 +1,14 @@
-import type { CloseSettings } from './types';
-import type { Eyes } from './types';
+import type { DriverTarget, Eyes, CloseSettings, Renderer } from '../ufg/types';
 import { type Logger } from '@applitools/logger';
-import type { DriverTarget } from './types';
 import { type SpecType, type SpecDriver } from '@applitools/driver';
 type Options<TSpec extends SpecType> = {
     eyes: Eyes<TSpec>;
     target?: DriverTarget<TSpec>;
+    renderers?: Renderer[];
     spec?: SpecDriver<TSpec>;
     logger: Logger;
 };
-export declare function makeClose<TSpec extends SpecType>({ eyes, target, spec, logger: mainLogger }: Options<TSpec>): ({ settings, logger, }?: {
+export declare function makeClose<TSpec extends SpecType>({ eyes, target, renderers: defaultRenderers, spec, logger: mainLogger, }: Options<TSpec>): ({ settings, logger, }?: {
     settings?: CloseSettings | undefined;
     logger?: Logger | undefined;
 }) => Promise<void>;

package/types/automation/get-nml-client.d.ts

@@ -1,13 +1,13 @@
 import { type SpecType, type Driver } from '@applitools/driver';
 import { type Logger } from '@applitools/logger';
-import { type NMLClient, type NMLRequestsConfig } from '@applitools/nml-client';
+import { type NMLClient, type NMLClientSettings } from '@applitools/nml-client';
 type Options = {
     client?: NMLClient;
     logger: Logger;
 };
-export declare function makeGetNMLClient({ client, logger: mainLogger }: Options): (({ driver, config, logger, }: {
+export declare function makeGetNMLClient({ client, logger: mainLogger }: Options): (({ driver, settings, logger, }: {
     driver: Driver<SpecType>;
-    config: Omit<NMLRequestsConfig, 'brokerUrl'>;
+    settings: Omit<NMLClientSettings, 'brokerUrl'>;
     logger?: Logger | undefined;
 }) => Promise<NMLClient>) & {
     getCachedValues(): Promise<NMLClient>[];

package/types/automation/get-results.d.ts

@@ -0,0 +1,11 @@
+import type { Eyes, GetResultsSettings, TestResult } from '../ufg/types';
+import { type Logger } from '@applitools/logger';
+type Options = {
+    eyes: Eyes<any>;
+    logger: Logger;
+};
+export declare function makeGetResults({ eyes, logger: mainLogger }: Options): ({ settings, logger, }?: {
+    settings?: GetResultsSettings | undefined;
+    logger?: Logger | undefined;
+}) => Promise<TestResult[]>;
+export {};

package/types/automation/types.d.ts

@@ -1,11 +1,48 @@
 import type { MaybeArray, Size, Region } from '@applitools/utils';
 import type * as BaseCore from '@applitools/core-base/types';
 import { type SpecType, type Driver, type ElementReference, type ContextReference } from '@applitools/driver';
+import { type NMLClient, type NMLClientSettings } from '@applitools/nml-client';
 import { type Logger } from '@applitools/logger';
-import { type NMLClient, type NMLRequestsConfig } from '@applitools/nml-client';
 export type * from '@applitools/core-base/types';
 export type DriverTarget<TSpec extends SpecType> = TSpec['driver'] | Driver<TSpec>;
 export type Target<TSpec extends SpecType> = DriverTarget<TSpec> | BaseCore.Target;
+export interface DesktopBrowserRenderer {
+    name?: 'chrome' | 'chrome-one-version-back' | 'chrome-two-versions-back' | 'firefox' | 'firefox-one-version-back' | 'firefox-two-versions-back' | 'safari' | 'safari-earlyaccess' | 'safari-one-version-back' | 'safari-two-versions-back' | 'edgechromium' | 'edgechromium-one-version-back' | 'edgechromium-two-versions-back' | 'edge' | 'edgelegacy' | 'ie' | 'ie10';
+    width: number;
+    height: number;
+}
+export interface ChromeEmulationDeviceRenderer {
+    chromeEmulationInfo: {
+        deviceName: 'Kindle Fire HDX' | 'Blackberry PlayBook' | 'BlackBerry Z30' | 'Galaxy Note 2' | 'Galaxy S3' | 'Galaxy Note 3' | 'Galaxy Note 4' | 'Galaxy A5' | 'Galaxy S5' | 'Galaxy S8' | 'Galaxy S8 Plus' | 'Galaxy Note 8' | 'Galaxy S9' | 'Galaxy S9 Plus' | 'Galaxy Note 9' | 'Galaxy S10' | 'Galaxy S10 Plus' | 'Galaxy Note 10' | 'Galaxy Note 10 Plus' | 'Galaxy S20' | 'Galaxy S21' | 'Galaxy S21 Ultra' | 'Galaxy S22' | 'Galaxy S22 Ultra' | 'Galaxy Tab S7' | 'iPhone 4' | 'iPhone 5/SE' | 'iPhone 6/7/8' | 'iPhone 6/7/8 Plus' | 'iPhone X' | 'iPhone XR' | 'iPhone XS' | 'iPhone XS Max' | 'iPhone 11' | 'iPhone 11 Pro' | 'iPhone 11 Pro Max' | 'iPad' | 'iPad 6th Gen' | 'iPad 7th Gen' | 'iPad Air 2' | 'iPad Mini' | 'iPad Pro' | 'LG G6' | 'LG Optimus L70' | 'Nexus 10' | 'Nexus 4' | 'Nexus 5' | 'Nexus 5X' | 'Nexus 6' | 'Nexus 6P' | 'Nexus 7' | 'Pixel 2' | 'Pixel 2 XL' | 'Pixel 3' | 'Pixel 3 XL' | 'Pixel 4' | 'Pixel 4 XL' | 'Pixel 5' | 'Sony Xperia 10 II' | 'Huawei Mate 50 Pro' | 'Huawei Matepad 11' | 'OnePlus 7T' | 'OnePlus 7T Pro' | 'Nokia N9' | 'Nokia Lumia 520' | 'Microsoft Lumia 550' | 'Microsoft Lumia 950' | 'Laptop with HiDPI screen' | 'Laptop with MDPI screen' | 'Laptop with touch';
+        screenOrientation?: 'portrait' | 'landscape';
+    };
+}
+export interface IOSDeviceRenderer {
+    iosDeviceInfo: {
+        deviceName: 'iPhone 6s' | 'iPhone 6s Plus' | 'iPhone 7' | 'iPhone 7 Plus' | 'iPhone 8' | 'iPhone 8 Plus' | 'iPhone X' | 'iPhone XR' | 'iPhone Xs' | 'iPhone Xs Max' | 'iPhone 11' | 'iPhone 11 Pro' | 'iPhone 11 Pro Max' | 'iPhone 12' | 'iPhone 12 mini' | 'iPhone 12 Pro' | 'iPhone 12 Pro Max' | 'iPhone 13' | 'iPhone 13 mini' | 'iPhone 13 Pro' | 'iPhone 13 Pro Max' | 'iPhone 14' | 'iPhone 14 Plus' | 'iPhone 14 Pro' | 'iPhone 14 Pro Max' | 'iPhone SE (1st generation)' | 'iPhone SE (2nd generation)' | 'iPhone SE (3rd generation)' | 'iPad (5th generation)' | 'iPad (6th generation)' | 'iPad (7th generation)' | 'iPad (8th generation)' | 'iPad (9th generation)' | 'iPad (10th generation)' | 'iPad Air 2' | 'iPad Air (3rd generation)' | 'iPad Air (4th generation)' | 'iPad Air (5th generation)' | 'iPad mini 4' | 'iPad mini (5th generation)' | 'iPad mini (6th generation)' | 'iPad Pro (9.7-inch)' | 'iPad Pro (10.5-inch)' | 'iPad Pro (11-inch) (1st generation)' | 'iPad Pro (12.9-inch) (1st generation)' | 'iPad Pro (11-inch) (2nd generation)' | 'iPad Pro (12.9-inch) (2nd generation)' | 'iPad Pro (11-inch) (3rd generation)' | 'iPad Pro (12.9-inch) (3rd generation)' | 'iPad Pro (11-inch) (4th generation)' | 'iPad Pro (12.9-inch) (4th generation)' | 'iPad Pro (12.9-inch) (5th generation)' | 'iPad Pro (12.9-inch) (6th generation)' | 'iPod touch (7th generation)';
+        version?: string;
+        screenOrientation?: 'portrait' | 'landscape';
+    };
+}
+export interface AndroidDeviceRenderer {
+    androidDeviceInfo: {
+        deviceName: 'Pixel 3 XL' | 'Pixel 4' | 'Pixel 4 XL' | 'Pixel 5' | 'Pixel 6' | 'Galaxy S10' | 'Galaxy S10 Plus' | 'Galaxy Note 10' | 'Galaxy Note 10 Plus' | 'Galaxy S20' | 'Galaxy S20 Plus' | 'Galaxy S21' | 'Galaxy S21 Plus' | 'Galaxy S21 Ultra' | 'Galaxy S22' | 'Galaxy S22 Plus' | 'Galaxy Tab S7' | 'Galaxy Tab S8' | 'Xiaomi Redmi Note 10 JE' | 'Xiaomi Redmi Note 11' | 'Xiaomi Redmi Note 11 Pro' | 'Sony Xperia 1 II' | 'Sony Xperia 10 II' | 'Sony Xperia Ace II' | 'Huawei P30 Lite';
+        version?: string;
+        screenOrientation?: 'portrait' | 'landscape';
+    };
+}
+export interface EnvironmentRenderer {
+    environment: BaseCore.Environment;
+}
+export type Renderer = (DesktopBrowserRenderer | ChromeEmulationDeviceRenderer | IOSDeviceRenderer | AndroidDeviceRenderer | EnvironmentRenderer) & {
+    properties?: BaseCore.CustomProperty[];
+    /**
+     * The id of the renderer
+     * Used to identify the renderer if the same renderer is used multiple times
+     * @internal
+     **/
+    id?: string;
+};
 export interface Core<TSpec extends SpecType> extends BaseCore.Core {
     readonly base: BaseCore.Core;
     getViewportSize?(options: {
@@ -18,14 +55,14 @@ export interface Core<TSpec extends SpecType> extends BaseCore.Core {
         logger?: Logger;
     }): Promise<void>;
     getNMLClient(options: {
-        config: Omit<NMLRequestsConfig, 'brokerUrl'>;
+        settings: Omit<NMLClientSettings, 'brokerUrl'>;
         driver: Driver<TSpec>;
         logger?: Logger;
     }): Promise<NMLClient>;
     openEyes(options: {
         target?: DriverTarget<TSpec>;
         settings: BaseCore.OpenSettings;
-        base?: BaseCore.Eyes[];
+        storage?: EyesStorage;
         logger?: Logger;
     }): Promise<Eyes<TSpec>>;
     locate<TLocator extends string>(options: {
@@ -46,19 +83,41 @@ export interface Core<TSpec extends SpecType> extends BaseCore.Core {
 }
 export interface Eyes<TSpec extends SpecType> extends BaseCore.Eyes {
     readonly core: Core<TSpec>;
-    getBaseEyes(options?: {
+    readonly storage: EyesStorage;
+    getBaseEyes(options: {
+        settings: GetBaseEyesSettings;
         logger?: Logger;
-    }): Promise<BaseCore.Eyes[]>;
+    }): Promise<BaseCore.Eyes>;
     check(options?: {
         target?: Target<TSpec>;
         settings?: CheckSettings<TSpec>;
         logger?: Logger;
-    }): Promise<BaseCore.CheckResult[]>;
+    }): Promise<void>;
     checkAndClose(options?: {
         target?: Target<TSpec>;
         settings?: CheckSettings<TSpec> & BaseCore.CloseSettings;
         logger?: Logger;
     }): Promise<void>;
+    close(options?: {
+        settings?: CloseSettings;
+        logger?: Logger;
+    }): Promise<void>;
+    abort(options?: {
+        settings?: AbortSettings;
+        logger?: Logger;
+    }): Promise<void>;
+    getResults(options?: {
+        settings?: BaseCore.GetResultsSettings;
+        logger?: Logger;
+    }): Promise<TestResult[]>;
+}
+export type EyesStorage = Map<string, {
+    renderer?: Renderer;
+    eyes: Promise<BaseCore.Eyes>;
+    jobs: Promise<void>[];
+}>;
+export interface GetBaseEyesSettings {
+    renderer: Renderer;
 }
 export interface ScreenshotSettings<TSpec extends SpecType> extends BaseCore.ImageSettings<Region | ElementReference<TSpec>> {
     webview?: boolean | string;
@@ -83,8 +142,20 @@ export interface ScreenshotSettings<TSpec extends SpecType> extends BaseCore.Ima
         waitingTime?: number;
         maxAmountToScroll?: number;
     };
+    sendDom?: boolean;
 }
 export type LocateSettings<TLocator extends string, TSpec extends SpecType> = BaseCore.LocateSettings<TLocator, Region | ElementReference<TSpec>> & ScreenshotSettings<TSpec>;
 export type LocateTextSettings<TPattern extends string, TSpec extends SpecType> = BaseCore.LocateTextSettings<TPattern, Region | ElementReference<TSpec>> & ScreenshotSettings<TSpec>;
 export type ExtractTextSettings<TSpec extends SpecType> = BaseCore.ExtractTextSettings<Region | ElementReference<TSpec>> & ScreenshotSettings<TSpec>;
-export type CheckSettings<TSpec extends SpecType> = BaseCore.CheckSettings<Region | ElementReference<TSpec>> & ScreenshotSettings<TSpec>;
+export type CheckSettings<TSpec extends SpecType> = BaseCore.CheckSettings<Region | ElementReference<TSpec>> & ScreenshotSettings<TSpec> & {
+    renderers?: Renderer[];
+};
+export type CloseSettings = BaseCore.CloseSettings & {
+    renderers?: Renderer[];
+};
+export type AbortSettings = BaseCore.AbortSettings & {
+    renderers?: Renderer[];
+};
+export type TestResult = BaseCore.TestResult & {
+    readonly renderer: Renderer;
+};

package/types/{ufg → automation}/utils/uniquify-renderers.d.ts

@@ -1,2 +1,2 @@
-import { type Renderer } from '@applitools/ufg-client';
+import type { Renderer } from '../types';
 export declare function uniquifyRenderers<TRenderer extends Renderer>(renderers: TRenderer[]): TRenderer[];

package/types/check.d.ts

@@ -1,4 +1,4 @@
-import type { Target, DriverTarget, Eyes, Config, CheckSettings, CheckResult } from './types';
+import type { Target, DriverTarget, Eyes, Config, CheckSettings } from './types';
 import { type Logger } from '@applitools/logger';
 import { type SpecType, type SpecDriver } from '@applitools/driver';
 type Options<TSpec extends SpecType, TType extends 'classic' | 'ufg'> = {
@@ -14,5 +14,5 @@ export declare function makeCheck<TSpec extends SpecType, TDefaultType extends '
     settings?: CheckSettings<TSpec, TType> | undefined;
     config?: Config<TSpec, TType> | undefined;
     logger?: Logger | undefined;
-}) => Promise<CheckResult<TType>[]>;
+}) => Promise<void>;
 export {};

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

@@ -1,19 +1,26 @@
-import type { Target, DriverTarget, Eyes, CheckSettings, CloseSettings } from './types';
-import type { CheckSettings as BaseCheckSettings } from '@applitools/core-base';
+import type { Target, DriverTarget, Eyes, CheckSettings, CloseSettings, Renderer } from './types';
+import type { CheckSettings as BaseCheckSettings, CloseSettings as BaseCloseSettings } from '@applitools/core-base';
+import { type AbortSignal } from 'abort-controller';
 import { type Logger } from '@applitools/logger';
 import { type SpecType, type SpecDriver } from '@applitools/driver';
 import * as utils from '@applitools/utils';
 type Options<TSpec extends SpecType> = {
     eyes: Eyes<TSpec>;
     target?: DriverTarget<TSpec>;
+    renderers?: Renderer[];
     spec?: SpecDriver<TSpec>;
+    signal?: AbortSignal;
     logger: Logger;
 };
-export declare function makeCheckAndClose<TSpec extends SpecType>({ eyes, target: defaultTarget, spec, logger: mainLogger, }: Options<TSpec>): ({ target, settings, logger, }?: {
+export declare function makeCheckAndClose<TSpec extends SpecType>({ eyes, target: defaultTarget, renderers: defaultRenderers, spec, signal, logger: mainLogger, }: Options<TSpec>): ({ target, settings, logger, }?: {
     target?: Target<TSpec> | undefined;
     settings?: (BaseCheckSettings<utils.Region | import("@applitools/driver").ElementReference<TSpec>> & import("./types").ScreenshotSettings<TSpec> & {
+        renderers?: Renderer[] | undefined;
+    } & {
         retryTimeout?: number | undefined;
-    } & CloseSettings) | undefined;
+    } & BaseCloseSettings & {
+        renderers?: Renderer[] | undefined;
+    }) | undefined;
     logger?: Logger | undefined;
 }) => Promise<void>;
 export {};

package/types/classic/check.d.ts

@@ -1,15 +1,18 @@
-import type { Target, DriverTarget, Eyes, CheckSettings, CheckResult } from './types';
+import type { Target, DriverTarget, Eyes, CheckSettings, Renderer } from './types';
+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> = {
     eyes: Eyes<TSpec>;
     target?: DriverTarget<TSpec>;
+    renderers?: Renderer[];
     spec?: SpecDriver<TSpec>;
+    signal?: AbortSignal;
     logger: Logger;
 };
-export declare function makeCheck<TSpec extends SpecType>({ eyes, target: defaultTarget, spec, logger: mainLogger, }: Options<TSpec>): ({ target, settings, logger, }?: {
+export declare function makeCheck<TSpec extends SpecType>({ eyes, target: defaultTarget, renderers: defaultRenderers, spec, signal, logger: mainLogger, }: Options<TSpec>): ({ target, settings, logger, }?: {
     target?: Target<TSpec> | undefined;
     settings?: CheckSettings<TSpec> | undefined;
     logger?: Logger | undefined;
-}) => Promise<CheckResult[]>;
+}) => Promise<void>;
 export {};

package/types/classic/core.d.ts

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

package/types/classic/get-base-eyes.d.ts

@@ -1,18 +1,14 @@
-import type { Eyes, OpenSettings } from './types';
+import type { Eyes, GetBaseEyesSettings, OpenSettings } from './types';
 import type { Eyes as BaseEyes } from '@applitools/core-base';
 import { type SpecType } from '@applitools/driver';
 import { type Logger } from '@applitools/logger';
 type Options<TSpec extends SpecType> = {
     settings: OpenSettings;
     eyes: Eyes<TSpec>;
-    base?: BaseEyes[];
     logger: Logger;
 };
-export declare function makeGetBaseEyes<TSpec extends SpecType>({ settings, eyes, base, logger: mainLogger }: Options<TSpec>): (({ logger }?: {
+export declare function makeGetBaseEyes<TSpec extends SpecType>({ settings: defaultSettings, eyes, logger: mainLogger, }: Options<TSpec>): ({ settings, logger, }: {
+    settings: GetBaseEyesSettings;
     logger?: Logger | undefined;
-}) => Promise<BaseEyes[]>) & {
-    getCachedValues(): Promise<BaseEyes[]>[];
-    setCachedValue(key: any, value: Promise<BaseEyes[]>): void;
-    clearCache(): void;
-};
+}) => Promise<BaseEyes>;
 export {};

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

@@ -1,5 +1,4 @@
-import type { Core, DriverTarget, Eyes, OpenSettings } from './types';
-import type { Eyes as BaseEyes } from '@applitools/core-base';
+import type { DriverTarget, Core, Eyes, EyesStorage, OpenSettings } from './types';
 import { type Logger } from '@applitools/logger';
 import { type SpecType, type SpecDriver } from '@applitools/driver';
 type Options<TSpec extends SpecType> = {
@@ -7,10 +6,10 @@ type Options<TSpec extends SpecType> = {
     spec?: SpecDriver<TSpec>;
     logger: Logger;
 };
-export declare function makeOpenEyes<TSpec extends SpecType>({ core, spec, logger: mainLogger }: Options<TSpec>): ({ target, settings, base, logger, }: {
+export declare function makeOpenEyes<TSpec extends SpecType>({ core, spec, logger: mainLogger }: Options<TSpec>): ({ target, settings, storage, logger, }: {
     target?: DriverTarget<TSpec> | undefined;
     settings: OpenSettings;
-    base?: BaseEyes[] | undefined;
+    storage?: EyesStorage | undefined;
     logger?: Logger | undefined;
 }) => Promise<Eyes<TSpec>>;
 export {};