@applitools/core 1.2.16 → 1.2.17

package/dist/ufg/get-base-eyes.js

@@ -0,0 +1,56 @@
+"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.makeGetBaseEyes = void 0;
+const utils = __importStar(require("@applitools/utils"));
+function makeGetBaseEyes({ settings: defaultSettings, core, client, eyes, logger: defaultLogger }) {
+    const getBaseEyesWithCache = utils.general.cachify(getBaseEyes, ([options]) => options === null || options === void 0 ? void 0 : options.settings);
+    if (eyes) {
+        eyes.forEach(eyes => getBaseEyesWithCache.setCachedValue(eyes.test.rendererInfo, Promise.resolve([eyes])));
+    }
+    return getBaseEyesWithCache;
+    async function getBaseEyes({ settings, logger = defaultLogger, } = {}) {
+        logger.log(`Command "getBaseEyes" is called with settings`, settings);
+        const environment = await client.bookRenderer({ settings });
+        const eyes = await core.openEyes({ settings: { ...defaultSettings, environment }, logger });
+        const aborted = utils.promises.makeControlledPromise();
+        const queue = [];
+        eyes.check = utils.general.wrap(eyes.check, async (check, options) => {
+            var _a, _b;
+            var _c;
+            const index = options.settings.stepIndex;
+            (_a = queue[index]) !== null && _a !== void 0 ? _a : (queue[index] = utils.promises.makeControlledPromise());
+            if (index > 0)
+                await Promise.race([((_b = queue[_c = index - 1]) !== null && _b !== void 0 ? _b : (queue[_c] = utils.promises.makeControlledPromise())), aborted]);
+            return check(options).finally(queue[index].resolve);
+        });
+        eyes.abort = utils.general.wrap(eyes.abort, async (abort, options) => {
+            aborted.reject(new Error('Command "check" was aborted due to possible error in previous step'));
+            return abort(options);
+        });
+        return [eyes];
+    }
+}
+exports.makeGetBaseEyes = makeGetBaseEyes;

package/dist/ufg/open-eyes.js

@@ -24,133 +24,88 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeOpenEyes = void 0;
-const abort_controller_1 = require("abort-controller");
 const driver_1 = require("@applitools/driver");
 const ufg_client_1 = require("@applitools/ufg-client");
+const get_base_eyes_1 = require("./get-base-eyes");
 const check_1 = require("./check");
 const check_and_close_1 = require("./check-and-close");
 const close_1 = require("./close");
 const abort_1 = require("./abort");
+const abort_controller_1 = require("abort-controller");
 const utils = __importStar(require("@applitools/utils"));
-function makeOpenEyes({ spec, core, client, logger: defaultLogger, }) {
-    return async function openEyes({ target, settings, logger = defaultLogger, }) {
-        var _a, _b, _c;
-        logger.log(`Command "openEyes" is called with ${(spec === null || spec === void 0 ? void 0 : spec.isDriver(target)) ? 'default driver and' : ''} settings`, settings);
-        if (spec === null || spec === void 0 ? void 0 : spec.isDriver(target)) {
-            const driver = await (0, driver_1.makeDriver)({ spec, driver: target, logger, customConfig: { disableHelper: true } });
+function makeOpenEyes({ core, client, spec, logger: defaultLogger, }) {
+    return async function openEyes({ settings, eyes, driver, target, logger = defaultLogger, }) {
+        var _a, _b;
+        logger.log(`Command "openEyes" is called with ${(spec === null || spec === void 0 ? void 0 : spec.isDriver(target)) ? 'default driver and' : ''}`, ...(settings ? ['settings', settings] : []), eyes ? 'predefined eyes' : '');
+        driver !== null && driver !== void 0 ? driver : (driver = (spec === null || spec === void 0 ? void 0 : spec.isDriver(target))
+            ? await (0, driver_1.makeDriver)({ spec, driver: target, logger, customConfig: { disableHelper: true } })
+            : null);
+        if (driver && !eyes) {
             const currentContext = driver.currentContext;
             if ((_a = settings.environment) === null || _a === void 0 ? void 0 : _a.viewportSize) {
                 await driver.setViewportSize(settings.environment.viewportSize);
             }
             await currentContext.focus();
         }
+        const controller = new abort_controller_1.AbortController();
         const account = await core.getAccountInfo({ settings, logger });
-        const test = {
-            userTestId: settings.userTestId,
-            batchId: (_b = settings.batch) === null || _b === void 0 ? void 0 : _b.id,
-            keepBatchOpen: settings.keepBatchOpen,
-            server: { serverUrl: settings.serverUrl, apiKey: settings.apiKey, proxy: settings.proxy },
-            account,
-        };
         client !== null && client !== void 0 ? client : (client = (0, ufg_client_1.makeUFGClient)({
             config: { ...account.ufg, ...account, proxy: settings.proxy },
-            concurrency: (_c = settings.renderConcurrency) !== null && _c !== void 0 ? _c : 5,
+            concurrency: (_b = settings.renderConcurrency) !== null && _b !== void 0 ? _b : 5,
             logger,
         }));
-        const controller = new abort_controller_1.AbortController();
-        // get eyes per environment
-        const getEyes = utils.general.cachify(async ({ rawEnvironment }) => {
-            const eyes = await core.openEyes({ settings: { ...settings, environment: { rawEnvironment } }, logger });
-            const aborted = makeHolderPromise();
-            const queue = [];
-            eyes.check = utils.general.wrap(eyes.check, async (check, options) => {
-                var _a, _b;
-                var _c;
-                const index = options.settings.index;
-                (_a = queue[index]) !== null && _a !== void 0 ? _a : (queue[index] = makeHolderPromise());
-                if (index > 0)
-                    await Promise.race([((_b = queue[_c = index - 1]) !== null && _b !== void 0 ? _b : (queue[_c] = makeHolderPromise())), aborted]);
-                return check(options).finally(queue[index].resolve);
-            });
-            eyes.abort = utils.general.wrap(eyes.abort, async (abort, options) => {
-                aborted.reject(new Error('Command "check" was aborted due to possible error in previous step'));
-                return abort(options);
-            });
-            return eyes;
-        });
-        const storage = [];
-        let index = 0;
-        // check with indexing and storage
-        const check = utils.general.wrap((0, check_1.makeCheck)({ spec, getEyes, client, signal: controller.signal, test, target, logger }), async (check, options = {}) => {
+        const getBaseEyes = (0, get_base_eyes_1.makeGetBaseEyes)({ settings, eyes, core, client, logger });
+        return utils.general.extend({}, eyes => {
             var _a;
-            (_a = options.settings) !== null && _a !== void 0 ? _a : (options.settings = {});
-            options.settings.index = index++;
-            const results = await check(options);
-            storage.push(...results.map(result => ({ promise: result.promise, renderer: result.renderer })));
-            return results;
+            const storage = [];
+            let stepIndex = 0;
+            let closed = false;
+            let aborted = false;
+            return {
+                type: 'ufg',
+                test: {
+                    userTestId: settings.userTestId,
+                    batchId: (_a = settings.batch) === null || _a === void 0 ? void 0 : _a.id,
+                    keepBatchOpen: settings.keepBatchOpen,
+                    server: { serverUrl: settings.serverUrl, apiKey: settings.apiKey, proxy: settings.proxy },
+                    account,
+                },
+                get running() {
+                    return !closed && !aborted;
+                },
+                get closed() {
+                    return closed;
+                },
+                get aborted() {
+                    return aborted;
+                },
+                getBaseEyes,
+                // check with indexing and storage
+                check: utils.general.wrap((0, check_1.makeCheck)({ eyes, client, driver, spec, signal: controller.signal, logger }), async (check, options = {}) => {
+                    var _a;
+                    (_a = options.settings) !== null && _a !== void 0 ? _a : (options.settings = {});
+                    options.settings.stepIndex = stepIndex++;
+                    const results = await check(options);
+                    storage.push(...results.map(result => ({ promise: result.promise, renderer: result.renderer })));
+                    return results;
+                }),
+                checkAndClose: (0, check_and_close_1.makeCheckAndClose)({ eyes, client, driver, spec, signal: controller.signal, logger }),
+                // close only once
+                close: utils.general.wrap((0, close_1.makeClose)({ storage, logger }), async (close, options) => {
+                    if (closed || aborted)
+                        return [];
+                    closed = true;
+                    return close(options);
+                }),
+                // abort only once
+                abort: utils.general.wrap((0, abort_1.makeAbort)({ storage, controller, logger }), async (abort, options) => {
+                    if (aborted || closed)
+                        return [];
+                    aborted = true;
+                    return abort(options);
+                }),
+            };
         });
-        let closed = false;
-        // close only once
-        const close = utils.general.wrap((0, close_1.makeClose)({ storage, logger }), async (close, options) => {
-            if (closed || aborted)
-                return [];
-            closed = true;
-            return close(options);
-        });
-        let aborted = false;
-        // abort only once
-        const abort = utils.general.wrap((0, abort_1.makeAbort)({ storage, controller, logger }), async (abort, options) => {
-            if (aborted || closed)
-                return [];
-            aborted = true;
-            return abort(options);
-        });
-        return {
-            test,
-            get running() {
-                return !closed && !aborted;
-            },
-            get closed() {
-                return closed;
-            },
-            get aborted() {
-                return aborted;
-            },
-            check,
-            checkAndClose: (0, check_and_close_1.makeCheckAndClose)({ spec, getEyes, client, test, target, logger }),
-            close,
-            abort,
-        };
     };
 }
 exports.makeOpenEyes = makeOpenEyes;
-function makeHolderPromise() {
-    let promise;
-    let resolve;
-    let reject;
-    let result;
-    return {
-        then(onFulfilled, onRejected) {
-            if (!promise) {
-                promise = new Promise((...args) => ([resolve, reject] = args));
-                if ((result === null || result === void 0 ? void 0 : result.status) === 'fulfilled')
-                    resolve();
-                else if ((result === null || result === void 0 ? void 0 : result.status) === 'rejected')
-                    reject(result.reason);
-            }
-            return promise.then(onFulfilled, onRejected);
-        },
-        resolve() {
-            if (resolve)
-                resolve();
-            else
-                result !== null && result !== void 0 ? result : (result = { status: 'fulfilled' });
-        },
-        reject(reason) {
-            if (reject)
-                reject(reason);
-            else
-                result !== null && result !== void 0 ? result : (result = { status: 'rejected', reason });
-        },
-    };
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applitools/core",
-  "version": "1.2.16",
+  "version": "1.2.17",
   "homepage": "https://applitools.com",
   "bugs": {
     "url": "https://github.com/applitools/eyes.sdk.javascript1/issues"
@@ -61,27 +61,27 @@
     }
   },
   "dependencies": {
-    "@applitools/core-base": "1.1.15",
+    "@applitools/core-base": "1.1.16",
     "@applitools/dom-capture": "11.2.0",
     "@applitools/dom-snapshot": "4.7.1",
-    "@applitools/driver": "1.11.9",
-    "@applitools/logger": "1.1.30",
-    "@applitools/nml-client": "1.3.12",
-    "@applitools/req": "1.1.17",
-    "@applitools/screenshoter": "3.7.10",
-    "@applitools/snippets": "2.4.8",
-    "@applitools/ufg-client": "1.1.6",
-    "@applitools/utils": "1.3.16",
+    "@applitools/driver": "1.11.12",
+    "@applitools/logger": "1.1.31",
+    "@applitools/nml-client": "1.3.13",
+    "@applitools/req": "1.1.18",
+    "@applitools/screenshoter": "3.7.12",
+    "@applitools/snippets": "2.4.9",
+    "@applitools/ufg-client": "1.1.7",
+    "@applitools/utils": "1.3.17",
     "abort-controller": "3.0.0",
     "throat": "6.0.1"
   },
   "devDependencies": {
     "@applitools/bongo": "^2.2.0",
     "@applitools/sdk-fake-eyes-server": "^2.1.3",
-    "@applitools/spec-driver-puppeteer": "^1.1.23",
-    "@applitools/spec-driver-selenium": "^1.5.9",
-    "@applitools/spec-driver-webdriverio": "^1.4.7",
-    "@applitools/test-server": "^1.1.11",
+    "@applitools/spec-driver-puppeteer": "^1.1.25",
+    "@applitools/spec-driver-selenium": "^1.5.11",
+    "@applitools/spec-driver-webdriverio": "^1.4.9",
+    "@applitools/test-server": "^1.1.12",
     "@applitools/test-utils": "^1.5.2",
     "@types/mocha": "^9.1.1",
     "@types/node": "12",

package/types/automation/get-viewport-size.d.ts

@@ -1,11 +1,9 @@
+import type { Core } from './types';
 import { type Logger } from '@applitools/logger';
 import { type SpecDriver } from '@applitools/driver';
 declare type Options<TDriver, TContext, TElement, TSelector> = {
     spec: SpecDriver<TDriver, TContext, TElement, TSelector>;
     logger?: Logger;
 };
-export declare function makeGetViewportSize<TDriver, TContext, TElement, TSelector>({ spec, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): ({ target, logger }: {
-    target: TDriver;
-    logger?: Logger;
-}) => Promise<import("@applitools/utils").Size>;
+export declare function makeGetViewportSize<TDriver, TContext, TElement, TSelector>({ spec, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): Core<TDriver, TContext, TElement, TSelector>['getViewportSize'];
 export {};

package/types/automation/locate.d.ts

@@ -1,16 +1,12 @@
-import type { Target, LocateSettings, LocateResult } from './types';
-import type { Core as BaseCore, Target as BaseTarget } from '@applitools/core-base';
+import type { Core, Target } from './types';
+import type { Core as BaseCore } from '@applitools/core-base';
 import { type Logger } from '@applitools/logger';
 import { type SpecDriver } from '@applitools/driver';
 declare type Options<TDriver, TContext, TElement, TSelector> = {
-    spec: SpecDriver<TDriver, TContext, TElement, TSelector>;
     core: BaseCore;
+    spec: SpecDriver<TDriver, TContext, TElement, TSelector>;
     target?: Target<TDriver>;
     logger?: Logger;
 };
-export declare function makeLocate<TDriver, TContext, TElement, TSelector>({ spec, core, target: defaultTarget, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): <TLocator extends string>({ target, settings, logger, }?: {
-    target?: Target<TDriver> | BaseTarget;
-    settings?: LocateSettings<TLocator, TElement, TSelector>;
-    logger?: Logger;
-}) => Promise<LocateResult<TLocator>>;
+export declare function makeLocate<TDriver, TContext, TElement, TSelector>({ spec, core, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): Core<TDriver, TContext, TElement, TSelector>['locate'];
 export {};

package/types/automation/set-viewport-size.d.ts

@@ -1,13 +1,9 @@
-import type { Size } from '@applitools/utils';
+import type { Core } from './types';
 import { type Logger } from '@applitools/logger';
 import { type SpecDriver } from '@applitools/driver';
 declare type Options<TDriver, TContext, TElement, TSelector> = {
     spec: SpecDriver<TDriver, TContext, TElement, TSelector>;
     logger?: Logger;
 };
-export declare function makeSetViewportSize<TDriver, TContext, TElement, TSelector>({ spec, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): ({ target, size, logger }: {
-    target: TDriver;
-    size: Size;
-    logger?: Logger;
-}) => Promise<void>;
+export declare function makeSetViewportSize<TDriver, TContext, TElement, TSelector>({ spec, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): Core<TDriver, TContext, TElement, TSelector>['setViewportSize'];
 export {};

package/types/automation/types.d.ts

@@ -1,49 +1,104 @@
 import type { MaybeArray, Size, Region } from '@applitools/utils';
 import type * as BaseCore from '@applitools/core-base/types';
-import { type Selector } from '@applitools/driver';
+import { type Driver, type Selector } from '@applitools/driver';
 import { type Logger } from '@applitools/logger';
 export * from '@applitools/core-base/types';
 export declare type Screenshot = BaseCore.Target;
 export declare type Target<TDriver> = TDriver;
-export interface Core<TDriver, TElement, TSelector, TEyes = Eyes<TDriver, TElement, TSelector>> extends BaseCore.Core<TEyes> {
+export interface Core<TDriver, TContext, TElement, TSelector, TEyes = Eyes<TDriver, TContext, TElement, TSelector>> extends BaseCore.Core<TEyes> {
     isDriver(driver: any): driver is TDriver;
     isElement(element: any): element is TElement;
     isSelector(selector: any): selector is TSelector;
+    getViewportSize(options: {
+        driver: Driver<TDriver, TContext, TElement, TSelector>;
+        logger?: Logger;
+    }): Promise<Size>;
     getViewportSize(options: {
         target: TDriver;
         logger?: Logger;
     }): Promise<Size>;
+    setViewportSize(options: {
+        driver: Driver<TDriver, TContext, TElement, TSelector>;
+        size: Size;
+        logger?: Logger;
+    }): Promise<void>;
     setViewportSize(options: {
         target: TDriver;
         size: Size;
         logger?: Logger;
     }): Promise<void>;
     openEyes(options: {
-        target?: TDriver;
+        driver?: Driver<TDriver, TContext, TElement, TSelector>;
         settings: BaseCore.OpenSettings;
         logger?: Logger;
     }): Promise<TEyes>;
+    openEyes(options: {
+        target?: TDriver;
+        settings?: BaseCore.OpenSettings;
+        logger?: Logger;
+    }): Promise<TEyes>;
+    /** @internal */
+    openEyes(options: {
+        driver?: Driver<TDriver, TContext, TElement, TSelector>;
+        eyes: BaseCore.Eyes[];
+        logger?: Logger;
+    }): Promise<TEyes>;
+    /** @internal */
+    openEyes(options: {
+        target?: TDriver;
+        eyes: BaseCore.Eyes[];
+        logger?: Logger;
+    }): Promise<TEyes>;
     locate<TLocator extends string>(options: {
-        target?: Target<TDriver> | Screenshot;
+        driver: Driver<TDriver, TContext, TElement, TSelector>;
+        settings: LocateSettings<TLocator, TElement, TSelector>;
+        logger?: Logger;
+    }): Promise<BaseCore.LocateResult<TLocator>>;
+    locate<TLocator extends string>(options: {
+        target: Target<TDriver> | Screenshot;
         settings: LocateSettings<TLocator, TElement, TSelector>;
         logger?: Logger;
     }): Promise<BaseCore.LocateResult<TLocator>>;
 }
-export interface Eyes<TDriver, TElement, TSelector, TTarget = Target<TDriver>> extends BaseCore.Eyes<TTarget> {
+export interface Eyes<TDriver, TContext, TElement, TSelector, TTarget = Target<TDriver>> extends BaseCore.Eyes<TTarget> {
+    getBaseEyes(options?: {
+        logger?: Logger;
+    }): Promise<BaseCore.Eyes[]>;
+    check(options: {
+        driver?: Driver<TDriver, TContext, TElement, TSelector>;
+        settings?: CheckSettings<TElement, TSelector>;
+        logger?: Logger;
+    }): Promise<BaseCore.CheckResult[]>;
     check(options: {
         target?: TTarget;
         settings?: CheckSettings<TElement, TSelector>;
+        logger?: Logger;
     }): Promise<BaseCore.CheckResult[]>;
+    checkAndClose(options: {
+        driver?: Driver<TDriver, TContext, TElement, TSelector>;
+        settings?: CheckSettings<TElement, TSelector> & BaseCore.CloseSettings;
+        logger?: Logger;
+    }): Promise<BaseCore.TestResult[]>;
     checkAndClose(options: {
         target?: TTarget;
         settings?: CheckSettings<TElement, TSelector> & BaseCore.CloseSettings;
         logger?: Logger;
     }): Promise<BaseCore.TestResult[]>;
+    locateText?<TPattern extends string>(options: {
+        driver?: Driver<TDriver, TContext, TElement, TSelector>;
+        settings: LocateTextSettings<TPattern, TElement, TSelector>;
+        logger?: Logger;
+    }): Promise<BaseCore.LocateTextResult<TPattern>>;
     locateText?<TPattern extends string>(options: {
         target?: TTarget;
         settings: LocateTextSettings<TPattern, TElement, TSelector>;
         logger?: Logger;
     }): Promise<BaseCore.LocateTextResult<TPattern>>;
+    extractText?(options: {
+        driver?: Driver<TDriver, TContext, TElement, TSelector>;
+        settings: MaybeArray<ExtractTextSettings<TElement, TSelector>>;
+        logger?: Logger;
+    }): Promise<string[]>;
     extractText?(options: {
         target?: TTarget;
         settings: MaybeArray<ExtractTextSettings<TElement, TSelector>>;

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

@@ -2,11 +2,16 @@ import type { Target, Config, CheckSettings, CloseSettings, TestResult } from '.
 import type { Eyes as ClassicEyes } from './classic/types';
 import type { Eyes as UFGEyes } from './ufg/types';
 import { type Logger } from '@applitools/logger';
-declare type Options<TDriver, TElement, TSelector> = {
-    eyes: ClassicEyes<TDriver, TElement, TSelector> | UFGEyes<TDriver, TElement, TSelector>;
+declare type Options<TDriver, TContext, TElement, TSelector> = {
+    type?: 'classic' | 'ufg';
+    getTypedEyes<TType extends 'classic' | 'ufg'>(options: {
+        type: TType;
+        renderers: any[];
+    }): Promise<TType extends 'ufg' ? UFGEyes<TDriver, TContext, TElement, TSelector> : ClassicEyes<TDriver, TContext, TElement, TSelector>>;
     logger: Logger;
 };
-export declare function makeCheckAndClose<TDriver, TElement, TSelector, TType extends 'classic' | 'ufg' = 'classic' | 'ufg'>({ eyes, logger: defaultLogger, }: Options<TDriver, TElement, TSelector>): ({ target, settings, config, logger, }?: {
+export declare function makeCheckAndClose<TDriver, TContext, TElement, TSelector, TType extends 'classic' | 'ufg' = 'classic' | 'ufg'>({ type: defaultType, getTypedEyes, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): ({ type, target, settings, config, logger, }?: {
+    type?: TType;
     target?: Target<TDriver, TType>;
     settings?: CheckSettings<TElement, TSelector, TType> & CloseSettings<TType>;
     config?: Config<TElement, TSelector, TType>;

package/types/check.d.ts

@@ -2,11 +2,16 @@ import type { Target, Config, CheckSettings, CheckResult } from './types';
 import type { Eyes as ClassicEyes } from './classic/types';
 import type { Eyes as UFGEyes } from './ufg/types';
 import { type Logger } from '@applitools/logger';
-declare type Options<TDriver, TElement, TSelector> = {
-    eyes: ClassicEyes<TDriver, TElement, TSelector> | UFGEyes<TDriver, TElement, TSelector>;
+declare type Options<TDriver, TContext, TElement, TSelector> = {
+    type?: 'classic' | 'ufg';
+    getTypedEyes<TType extends 'classic' | 'ufg'>(options: {
+        type: TType;
+        renderers: any[];
+    }): Promise<TType extends 'ufg' ? UFGEyes<TDriver, TContext, TElement, TSelector> : ClassicEyes<TDriver, TContext, TElement, TSelector>>;
     logger?: Logger;
 };
-export declare function makeCheck<TDriver, TElement, TSelector, TType extends 'classic' | 'ufg'>({ eyes, logger: defaultLogger, }: Options<TDriver, TElement, TSelector>): ({ target, settings, config, logger, }?: {
+export declare function makeCheck<TDriver, TContext, TElement, TSelector, TType extends 'classic' | 'ufg'>({ type: defaultType, getTypedEyes, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): ({ type, target, settings, config, logger, }?: {
+    type?: TType;
     target?: Target<TDriver, TType>;
     settings?: CheckSettings<TElement, TSelector, TType>;
     config?: Config<TElement, TSelector, TType>;

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

@@ -1,16 +1,11 @@
-import type { Target, CheckSettings, CloseSettings, TestResult } from './types';
-import type { Eyes as BaseEyes } from '@applitools/core-base';
+import type { Eyes } from './types';
 import { type Logger } from '@applitools/logger';
-import { type SpecDriver } from '@applitools/driver';
+import { type Driver, type SpecDriver } from '@applitools/driver';
 declare type Options<TDriver, TContext, TElement, TSelector> = {
-    spec: SpecDriver<TDriver, TContext, TElement, TSelector>;
-    eyes: BaseEyes;
-    target?: Target<TDriver>;
+    eyes: Eyes<TDriver, TContext, TElement, TSelector>;
+    driver?: Driver<TDriver, TContext, TElement, TSelector>;
+    spec?: SpecDriver<TDriver, TContext, TElement, TSelector>;
     logger?: Logger;
 };
-export declare function makeCheckAndClose<TDriver, TContext, TElement, TSelector>({ spec, eyes, target: defaultTarget, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): ({ target, settings, logger, }?: {
-    target?: Target<TDriver>;
-    settings?: CheckSettings<TElement, TSelector> & CloseSettings;
-    logger?: Logger;
-}) => Promise<TestResult[]>;
+export declare function makeCheckAndClose<TDriver, TContext, TElement, TSelector>({ eyes, driver: defaultDriver, spec, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): Eyes<TDriver, TContext, TElement, TSelector>['checkAndClose'];
 export {};

package/types/classic/check.d.ts

@@ -1,16 +1,11 @@
-import type { Target, CheckSettings, CheckResult } from './types';
-import type { Eyes as BaseEyes } from '@applitools/core-base';
+import type { Eyes } from './types';
 import { type Logger } from '@applitools/logger';
-import { type SpecDriver } from '@applitools/driver';
+import { type Driver, type SpecDriver } from '@applitools/driver';
 declare type Options<TDriver, TContext, TElement, TSelector> = {
-    spec: SpecDriver<TDriver, TContext, TElement, TSelector>;
-    eyes: BaseEyes;
-    target?: Target<TDriver>;
+    eyes: Eyes<TDriver, TContext, TElement, TSelector>;
+    driver?: Driver<TDriver, TContext, TElement, TSelector>;
+    spec?: SpecDriver<TDriver, TContext, TElement, TSelector>;
     logger?: Logger;
 };
-export declare function makeCheck<TDriver, TContext, TElement, TSelector>({ spec, eyes, target: defaultTarget, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): ({ target, settings, logger, }?: {
-    target?: Target<TDriver>;
-    settings?: CheckSettings<TElement, TSelector>;
-    logger?: Logger;
-}) => Promise<CheckResult[]>;
+export declare function makeCheck<TDriver, TContext, TElement, TSelector>({ eyes, driver: defaultDriver, spec, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): Eyes<TDriver, TContext, TElement, TSelector>['check'];
 export {};

package/types/classic/core.d.ts

@@ -3,11 +3,11 @@ import { type SpecDriver } from '@applitools/driver';
 import { type Logger } from '@applitools/logger';
 import { type Core as BaseCore } from '@applitools/core-base';
 declare type Options<TDriver, TContext, TElement, TSelector> = {
-    spec: SpecDriver<TDriver, TContext, TElement, TSelector>;
+    spec?: SpecDriver<TDriver, TContext, TElement, TSelector>;
     core?: BaseCore;
     agentId?: string;
     cwd?: string;
     logger?: Logger;
 };
-export declare function makeCore<TDriver, TContext, TElement, TSelector>({ spec, core, agentId, cwd, logger, }: Options<TDriver, TContext, TElement, TSelector>): Core<TDriver, TElement, TSelector>;
+export declare function makeCore<TDriver, TContext, TElement, TSelector>({ spec, core, agentId, cwd, logger, }: Options<TDriver, TContext, TElement, TSelector>): Core<TDriver, TContext, TElement, TSelector>;
 export {};

package/types/classic/extract-text.d.ts

@@ -1,17 +1,11 @@
-import type { MaybeArray } from '@applitools/utils';
-import type { Target, ExtractTextSettings } from './types';
-import type { Eyes as BaseEyes } from '@applitools/core-base';
+import type { Eyes } from './types';
 import { type Logger } from '@applitools/logger';
-import { type SpecDriver } from '@applitools/driver';
+import { type Driver, type SpecDriver } from '@applitools/driver';
 declare type Options<TDriver, TContext, TElement, TSelector> = {
-    spec: SpecDriver<TDriver, TContext, TElement, TSelector>;
-    eyes: BaseEyes;
-    target?: Target<TDriver>;
+    eyes: Eyes<TDriver, TContext, TElement, TSelector>;
+    driver?: Driver<TDriver, TContext, TElement, TSelector>;
+    spec?: SpecDriver<TDriver, TContext, TElement, TSelector>;
     logger?: Logger;
 };
-export declare function makeExtractText<TDriver, TContext, TElement, TSelector>({ spec, eyes, target: defaultTarget, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): ({ target, settings, logger, }?: {
-    target?: Target<TDriver>;
-    settings?: MaybeArray<ExtractTextSettings<TElement, TSelector>>;
-    logger?: Logger;
-}) => Promise<string[]>;
+export declare function makeExtractText<TDriver, TContext, TElement, TSelector>({ eyes, driver: defaultDriver, spec, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): Eyes<TDriver, TContext, TElement, TSelector>['extractText'];
 export {};

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

@@ -0,0 +1,17 @@
+import type { OpenSettings } from './types';
+import type { Core as BaseCore, Eyes as BaseEyes } from '@applitools/core-base';
+import { type Logger } from '@applitools/logger';
+declare type Options = {
+    settings?: OpenSettings;
+    eyes?: BaseEyes[];
+    core?: BaseCore;
+    logger?: Logger;
+};
+export declare function makeGetBaseEyes({ settings, core, eyes, logger: defaultLogger }: Options): (({ logger }?: {
+    logger?: Logger;
+}) => Promise<BaseEyes[]>) & {
+    getCachedValues(): Promise<BaseEyes<import("@applitools/core-base").Target>[]>[];
+    setCachedValue(key: any, value: Promise<BaseEyes<import("@applitools/core-base").Target>[]>): void;
+    clearCache(): void;
+};
+export {};

package/types/classic/locate-text.d.ts

@@ -1,16 +1,11 @@
-import type { Target, LocateTextSettings, LocateTextResult } from './types';
-import type { Eyes as BaseEyes } from '@applitools/core-base';
+import type { Eyes } from './types';
 import { type Logger } from '@applitools/logger';
-import { type SpecDriver } from '@applitools/driver';
+import { type Driver, type SpecDriver } from '@applitools/driver';
 declare type Options<TDriver, TContext, TElement, TSelector> = {
-    spec: SpecDriver<TDriver, TContext, TElement, TSelector>;
-    eyes: BaseEyes;
-    target?: Target<TDriver>;
+    eyes: Eyes<TDriver, TContext, TElement, TSelector>;
+    driver?: Driver<TDriver, TContext, TElement, TSelector>;
+    spec?: SpecDriver<TDriver, TContext, TElement, TSelector>;
     logger?: Logger;
 };
-export declare function makeLocateText<TDriver, TContext, TElement, TSelector>({ spec, eyes, target: defaultTarget, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): <TPattern extends string>({ target, settings, logger, }?: {
-    target?: Target<TDriver>;
-    settings?: LocateTextSettings<TPattern, TElement, TSelector>;
-    logger?: Logger;
-}) => Promise<LocateTextResult<TPattern>>;
+export declare function makeLocateText<TDriver, TContext, TElement, TSelector>({ spec, driver: defaultDriver, eyes, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): Eyes<TDriver, TContext, TElement, TSelector>['locateText'];
 export {};