@applitools/core 3.9.1 → 3.10.1

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applitools/core",
-  "version": "3.9.1",
+  "version": "3.10.1",
   "homepage": "https://applitools.com",
   "bugs": {
     "url": "https://github.com/applitools/eyes.sdk.javascript1/issues"
@@ -65,20 +65,20 @@
     "compress": "GZip"
   },
   "dependencies": {
-    "@applitools/core-base": "1.5.1",
+    "@applitools/core-base": "1.5.3",
     "@applitools/dom-capture": "11.2.2",
     "@applitools/dom-snapshot": "4.7.10",
-    "@applitools/driver": "1.13.5",
-    "@applitools/ec-client": "1.7.5",
-    "@applitools/logger": "2.0.8",
-    "@applitools/nml-client": "1.5.8",
-    "@applitools/req": "1.5.3",
-    "@applitools/screenshoter": "3.8.8",
+    "@applitools/driver": "1.14.0",
+    "@applitools/ec-client": "1.7.7",
+    "@applitools/logger": "2.0.10",
+    "@applitools/nml-client": "1.5.10",
+    "@applitools/req": "1.6.0",
+    "@applitools/screenshoter": "3.8.10",
     "@applitools/snippets": "2.4.23",
-    "@applitools/socket": "1.1.8",
-    "@applitools/spec-driver-webdriver": "1.0.42",
-    "@applitools/ufg-client": "1.7.1",
-    "@applitools/utils": "1.5.1",
+    "@applitools/socket": "1.1.10",
+    "@applitools/spec-driver-webdriver": "1.0.44",
+    "@applitools/ufg-client": "1.8.0",
+    "@applitools/utils": "1.6.0",
     "@types/ws": "8.5.5",
     "abort-controller": "3.0.0",
     "chalk": "4.1.2",
@@ -89,11 +89,11 @@
   },
   "devDependencies": {
     "@applitools/bongo": "^5.6.1",
-    "@applitools/spec-driver-puppeteer": "^1.1.73",
-    "@applitools/spec-driver-selenium": "^1.5.56",
+    "@applitools/spec-driver-puppeteer": "^1.2.0",
+    "@applitools/spec-driver-selenium": "^1.5.58",
     "@applitools/test-server": "^1.2.2",
     "@applitools/test-utils": "^1.5.17",
-    "@applitools/tunnel-client": "^1.2.0",
+    "@applitools/tunnel-client": "^1.2.2",
     "@types/node": "^12.20.55",
     "@types/selenium-webdriver": "^4.1.2",
     "@types/yargs": "^17.0.22",

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 { MaybeArray, Size, Region, ControlledPromise } 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,40 @@ 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, {
+    eyes: ControlledPromise<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 +141,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/automation/utils/extract-renderer-key.d.ts

@@ -0,0 +1,2 @@
+import type { Renderer } from '../types';
+export declare function extractRendererKey(renderer: Renderer): string;

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 {};

package/types/classic/types.d.ts

@@ -1,4 +1,3 @@
-import type * as BaseCore from '@applitools/core-base/types';
 import type * as AutomationCore from '../automation/types';
 import { type SpecType } from '@applitools/driver';
 import { type Logger } from '@applitools/logger';
@@ -8,7 +7,7 @@ export interface Core<TSpec extends SpecType> extends AutomationCore.Core<TSpec>
     openEyes(options: {
         target?: AutomationCore.DriverTarget<TSpec>;
         settings: OpenSettings;
-        base?: BaseCore.Eyes[];
+        storage?: AutomationCore.EyesStorage;
         logger?: Logger;
     }): Promise<Eyes<TSpec>>;
 }
@@ -19,7 +18,7 @@ export interface Eyes<TSpec extends SpecType> extends AutomationCore.Eyes<TSpec>
         target?: AutomationCore.Target<TSpec>;
         settings?: CheckSettings<TSpec>;
         logger?: Logger;
-    }): Promise<AutomationCore.CheckResult[]>;
+    }): Promise<void>;
     checkAndClose(options?: {
         target?: AutomationCore.Target<TSpec>;
         settings?: CheckSettings<TSpec> & AutomationCore.CloseSettings;
@@ -27,8 +26,8 @@ export interface Eyes<TSpec extends SpecType> extends AutomationCore.Eyes<TSpec>
     }): Promise<void>;
 }
 export type OpenSettings = AutomationCore.OpenSettings & {
-    keepPlatformNameAsIs?: boolean;
     useCeilForViewportSize?: boolean;
+    keepPlatformNameAsIs?: boolean;
 };
 export type CheckSettings<TSpec extends SpecType> = AutomationCore.CheckSettings<TSpec> & {
     retryTimeout?: number;

package/types/classic/utils/extract-default-renderers.d.ts

@@ -0,0 +1,9 @@
+import type { EnvironmentRenderer, Environment } from '../types';
+import { type SpecType, type Driver } from '@applitools/driver';
+export declare function extractDefaultRenderers<TSpec extends SpecType>({ driver, settings, }: {
+    driver?: Driver<TSpec>;
+    settings?: {
+        keepPlatformNameAsIs?: boolean;
+        environment?: Environment;
+    };
+}): Promise<EnvironmentRenderer[]>;

package/types/classic/utils/take-screenshots.d.ts

@@ -0,0 +1,18 @@
+import type { ScreenshotSettings, Renderer } from '../types';
+import type { Target as BaseTarget } from '@applitools/core-base';
+import { type Logger } from '@applitools/logger';
+import { type SpecType, type Driver, type ElementReference } from '@applitools/driver';
+import { type DomCaptureSettings } from './take-dom-capture';
+export type ScreenshotsSettings<TSpec extends SpecType> = ScreenshotSettings<TSpec> & {
+    renderers: Renderer[];
+    regionsToCalculate?: ElementReference<TSpec>[];
+    calculateView?: boolean;
+    domSettings?: DomCaptureSettings;
+};
+export declare function takeScreenshots<TSpec extends SpecType>({ driver, settings, logger, }: {
+    driver: Driver<TSpec>;
+    settings: ScreenshotsSettings<TSpec>;
+    logger: Logger;
+}): Promise<(BaseTarget & {
+    calculatedRegions: any;
+})[]>;

package/types/close.d.ts

@@ -1,11 +1,12 @@
-import type { Eyes, Config, CloseSettings } from './types';
+import type { Eyes, Config, CloseSettings, 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 makeClose<TSpec extends SpecType, TType extends 'classic' | 'ufg'>({ eyes, logger: mainLogger, }: Options<TSpec, TType>): ({ settings, config, logger, }?: {
+export declare function makeClose<TSpec extends SpecType, TType extends 'classic' | 'ufg'>({ eyes, renderers: defaultRenderers, logger: mainLogger, }: Options<TSpec, TType>): ({ settings, config, logger, }?: {
     settings?: CloseSettings<TType> | undefined;
     config?: Config<TSpec, TType> | undefined;
     logger?: Logger | undefined;

package/types/core.d.ts

@@ -1,9 +1,15 @@
 import type { Core } from './types';
 import type { Core as BaseCore } from '@applitools/core-base';
+import { 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';
 type Options<TSpec extends SpecType> = {
     spec?: SpecDriver<TSpec>;
+    clients?: {
+        ufg?: UFGClient;
+        nml?: NMLClient;
+    };
     concurrency?: number;
     base?: BaseCore;
     agentId?: string;
@@ -11,5 +17,5 @@ type Options<TSpec extends SpecType> = {
     cwd?: string;
     logger?: Logger;
 };
-export declare function makeCore<TSpec extends SpecType>({ spec, concurrency, base: defaultBase, environment: defaultEnvironment, agentId, cwd, logger: defaultLogger, }?: Options<TSpec>): Core<TSpec, 'classic' | 'ufg'>;
+export declare function makeCore<TSpec extends SpecType>({ spec, clients, concurrency, base: defaultBase, environment: defaultEnvironment, agentId, cwd, logger: defaultLogger, }?: Options<TSpec>): Core<TSpec, 'classic' | 'ufg'>;
 export {};

package/types/get-typed-eyes.d.ts

@@ -1,6 +1,5 @@
-import type { DriverTarget, TypedCore, TypedEyes, OpenSettings } from './types';
+import type { DriverTarget, TypedCore, TypedEyes, OpenSettings, Renderer } from './types';
 import { type SpecType } from '@applitools/driver';
-import { type RenderEnvironmentSettings } from '@applitools/ufg-client';
 import { type Logger } from '@applitools/logger';
 type Options<TSpec extends SpecType, TType extends 'classic' | 'ufg'> = {
     type: TType;
@@ -11,9 +10,11 @@ type Options<TSpec extends SpecType, TType extends 'classic' | 'ufg'> = {
     };
     logger: Logger;
 };
-export declare function makeGetTypedEyes<TSpec extends SpecType, TDefaultType extends 'classic' | 'ufg'>({ type: defaultType, settings: defaultSettings, target, cores, logger: mainLogger, }: Options<TSpec, TDefaultType>): <TType extends "classic" | "ufg" = TDefaultType>({ type, settings, logger, }?: {
+export declare function makeGetTypedEyes<TSpec extends SpecType, TDefaultType extends 'classic' | 'ufg'>({ type: defaultType, settings: defaultSettings, target, cores, logger: mainLogger, }: Options<TSpec, TDefaultType>): <TType extends "classic" | "ufg" = TDefaultType>({ type, logger, }?: {
     type?: TType | undefined;
-    settings?: RenderEnvironmentSettings[] | undefined;
+    settings?: {
+        renderers?: Renderer[] | undefined;
+    } | undefined;
     logger?: Logger | undefined;
 }) => Promise<TypedEyes<TSpec, TType>>;
 export {};

package/types/make-manager.d.ts

@@ -1,9 +1,15 @@
 import type { Core, EyesManager, ManagerSettings } from './types';
 import type { Core as BaseCore } from '@applitools/core-base';
+import { type UFGClient } from '@applitools/ufg-client';
+import { type NMLClient } from '@applitools/nml-client';
 import { type Logger } from '@applitools/logger';
 import { type SpecType, type SpecDriver } from '@applitools/driver';
 type Options<TSpec extends SpecType> = {
     spec?: SpecDriver<TSpec>;
+    clients?: {
+        ufg?: UFGClient;
+        nml?: NMLClient;
+    };
     concurrency?: number;
     core: Core<TSpec>;
     base?: BaseCore;
@@ -12,7 +18,7 @@ type Options<TSpec extends SpecType> = {
     cwd?: string;
     logger: Logger;
 };
-export declare function makeMakeManager<TSpec extends SpecType>({ spec, concurrency: defaultConcurrency, core, base, agentId: defaultAgentId, environment, cwd, logger: mainLogger, }: Options<TSpec>): <TType extends "classic" | "ufg" = "classic">({ type, settings, logger, }?: {
+export declare function makeMakeManager<TSpec extends SpecType>({ spec, clients, concurrency: defaultConcurrency, core, base, agentId: defaultAgentId, environment, cwd, logger: mainLogger, }: Options<TSpec>): <TType extends "classic" | "ufg" = "classic">({ type, settings, logger, }?: {
     type?: TType | undefined;
     settings?: ManagerSettings | undefined;
     logger?: Logger | undefined;

package/types/open-eyes.d.ts

@@ -1,8 +1,14 @@
 import type { DriverTarget, Core, TypedCore, Batch, Eyes, Config, OpenSettings } from './types';
+import { type UFGClient } from '@applitools/ufg-client';
+import { type NMLClient } from '@applitools/nml-client';
 import { type Logger } from '@applitools/logger';
 import { type SpecType, type SpecDriver } from '@applitools/driver';
 type Options<TSpec extends SpecType, TType extends 'classic' | 'ufg'> = {
     type?: TType;
+    clients?: {
+        ufg?: UFGClient;
+        nml?: NMLClient;
+    };
     concurrency?: number;
     batch?: Batch;
     core: Core<TSpec, TType>;
@@ -13,7 +19,7 @@ type Options<TSpec extends SpecType, TType extends 'classic' | 'ufg'> = {
     environment?: Record<string, any>;
     logger: Logger;
 };
-export declare function makeOpenEyes<TSpec extends SpecType, TDefaultType extends 'classic' | 'ufg' = 'classic'>({ type: defaultType, concurrency, batch, core, cores, spec, environment, logger: mainLogger, }: Options<TSpec, TDefaultType>): <TType extends "classic" | "ufg" = TDefaultType>({ type, settings, config, target, logger, }: {
+export declare function makeOpenEyes<TSpec extends SpecType, TDefaultType extends 'classic' | 'ufg' = 'classic'>({ type: defaultType, clients, concurrency, batch, core, cores, spec, environment, logger: mainLogger, }: Options<TSpec, TDefaultType>): <TType extends "classic" | "ufg" = TDefaultType>({ type, settings, config, target, logger, }: {
     type?: TType | undefined;
     settings?: Partial<OpenSettings<TDefaultType> & OpenSettings<TType>> | undefined;
     config?: (Config<TSpec, TDefaultType> & Config<TSpec, TType>) | undefined;