@applitools/core 1.4.7 → 2.0.0

package/dist/ufg/check.js

@@ -39,9 +39,9 @@ const chalk_1 = __importDefault(require("chalk"));
 function makeCheck({ eyes, client, target: defaultTarget, spec, signal, logger: defaultLogger, }) {
     return async function check({ target = defaultTarget, settings = {}, logger = defaultLogger, }) {
         var _a, _b, _c, _d, _e;
-        logger === null || logger === void 0 ? void 0 : logger.log('Command "check" is called with settings', settings);
+        logger.log('Command "check" is called with settings', settings);
         if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
-            logger === null || logger === void 0 ? void 0 : logger.warn('Command "check" was called after test was already aborted');
+            logger.warn('Command "check" was called after test was already aborted');
             throw new abort_error_1.AbortError('Command "check" was called after test was already aborted');
         }
         const { elementReferencesToCalculate, elementReferenceToTarget, getBaseCheckSettings } = (0, to_base_check_settings_1.toBaseCheckSettings)({
@@ -132,11 +132,11 @@ function makeCheck({ eyes, client, target: defaultTarget, spec, signal, logger:
         const promises = uniqueRenderers.map(async (renderer, index) => {
             if (utils.types.has(renderer, 'name') && renderer.name === 'edge') {
                 const message = chalk_1.default.yellow(`The 'edge' option that is being used in your browsers' configuration will soon be deprecated. Please change it to either 'edgelegacy' for the legacy version or to 'edgechromium' for the new Chromium-based version. Please note, when using the built-in BrowserType enum, then the values are BrowserType.EDGE_LEGACY and BrowserType.EDGE_CHROMIUM, respectively.`);
-                logger === null || logger === void 0 ? void 0 : logger.console.log(message);
+                logger.console.log(message);
             }
             try {
                 if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
-                    logger === null || logger === void 0 ? void 0 : logger.warn('Command "check" was aborted before rendering');
+                    logger.warn('Command "check" was aborted before rendering');
                     throw new abort_error_1.AbortError('Command "check" was aborted before rendering');
                 }
                 const { cookies, ...snapshot } = snapshots[index];
@@ -158,7 +158,7 @@ function makeCheck({ eyes, client, target: defaultTarget, spec, signal, logger:
                         logger.warn('Command "check" was aborted before rendering');
                         throw new abort_error_1.AbortError('Command "check" was aborted before rendering');
                     }
-                    else if (baseEyes.aborted) {
+                    else if (!baseEyes.running) {
                         logger.warn(`Renderer with id ${baseEyes.test.rendererId} was aborted during one of the previous steps`);
                         throw new abort_error_1.AbortError(`Renderer with id "${baseEyes.test.rendererId}" was aborted during one of the previous steps`);
                     }
@@ -167,7 +167,7 @@ function makeCheck({ eyes, client, target: defaultTarget, spec, signal, logger:
                         logger.warn('Command "check" was aborted before rendering');
                         throw new abort_error_1.AbortError('Command "check" was aborted before rendering');
                     }
-                    else if (baseEyes.aborted) {
+                    else if (!baseEyes.running) {
                         logger.warn(`Renderer with id ${baseEyes.test.rendererId} was aborted during one of the previous steps`);
                         throw new abort_error_1.AbortError(`Renderer with id "${baseEyes.test.rendererId}" was aborted during one of the previous steps`);
                     }
@@ -198,7 +198,7 @@ function makeCheck({ eyes, client, target: defaultTarget, spec, signal, logger:
                         logger.warn('Command "check" was aborted after rendering');
                         throw new abort_error_1.AbortError('Command "check" was aborted after rendering');
                     }
-                    else if (baseEyes.aborted) {
+                    else if (!baseEyes.running) {
                         logger.warn(`Renderer with id ${baseEyes.test.rendererId} was aborted during one of the previous steps`);
                         throw new abort_error_1.AbortError(`Renderer with id "${baseEyes.test.rendererId}" was aborted during one of the previous steps`);
                     }
@@ -207,14 +207,16 @@ function makeCheck({ eyes, client, target: defaultTarget, spec, signal, logger:
                         settings: baseSettings,
                         logger,
                     });
-                    if (baseEyes.aborted) {
+                    if (!baseEyes.running) {
                         logger.warn(`Renderer with id ${baseEyes.test.rendererId} was aborted during one of the previous steps`);
                         throw new abort_error_1.AbortError(`Renderer with id "${baseEyes.test.rendererId}" was aborted during one of the previous steps`);
                     }
                     return { ...result, eyes: baseEyes, renderer };
                 }
                 catch (error) {
-                    await baseEyes.abort({ settings: { testMetadata: await (driver === null || driver === void 0 ? void 0 : driver.getSessionMetadata()) } });
+                    if (baseEyes.running && !(signal === null || signal === void 0 ? void 0 : signal.aborted)) {
+                        await baseEyes.abort({ settings: { testMetadata: await (driver === null || driver === void 0 ? void 0 : driver.getSessionMetadata()) } });
+                    }
                     error.info = { eyes: baseEyes };
                     throw error;
                 }

package/dist/ufg/close.js

@@ -2,29 +2,28 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeClose = void 0;
 const driver_1 = require("@applitools/driver");
-function makeClose({ storage, target, spec, logger: defaultLogger, }) {
-    return async function ({ settings, logger = defaultLogger, } = {}) {
-        const tests = storage.reduce((tests, { renderer, promise }) => {
-            var _a;
-            const key = JSON.stringify(renderer);
-            const promises = (_a = tests.get(key)) !== null && _a !== void 0 ? _a : [];
-            promises.push(promise);
-            return tests.set(key, promises);
-        }, new Map());
-        return Promise.all(Array.from(tests.values(), async (promises) => {
+function makeClose({ storage, target, spec, logger: defaultLogger }) {
+    return async function close({ settings, logger = defaultLogger, } = {}) {
+        logger.log('Command "close" is called with settings', settings);
+        const driver = (0, driver_1.isDriver)(target, spec) ? await (0, driver_1.makeDriver)({ spec, driver: target, logger }) : null;
+        const testMetadata = await (driver === null || driver === void 0 ? void 0 : driver.getSessionMetadata());
+        storage.forEach(async (promises) => {
             var _a, _b;
             try {
-                const [{ eyes, renderer }] = await Promise.all(promises);
-                const driver = (0, driver_1.isDriver)(target, spec) ? await (0, driver_1.makeDriver)({ spec, driver: target, logger }) : null;
-                const testMetadata = await (driver === null || driver === void 0 ? void 0 : driver.getSessionMetadata());
-                const [result] = await eyes.close({ settings: { ...settings, testMetadata }, logger });
-                return { ...result, renderer };
+                const [{ eyes }] = await Promise.all(promises);
+                try {
+                    await eyes.close({ settings: { ...settings, testMetadata }, logger });
+                }
+                catch (error) {
+                    logger.warn('Command "close" received an error during performing, trying to perform abort instead', error);
+                    await eyes.abort({ settings: { ...settings, testMetadata }, logger });
+                }
             }
             catch (error) {
-                await ((_b = (_a = error.info) === null || _a === void 0 ? void 0 : _a.eyes) === null || _b === void 0 ? void 0 : _b.abort({ logger }));
-                throw error;
+                logger.warn('Command "close" received an error during waiting for eyes instances in background', error);
+                await ((_b = (_a = error.info) === null || _a === void 0 ? void 0 : _a.eyes) === null || _b === void 0 ? void 0 : _b.abort({ settings: { ...settings, testMetadata }, logger }));
             }
-        }));
+        });
     };
 }
 exports.makeClose = makeClose;

package/dist/ufg/core.js

@@ -32,6 +32,8 @@ const core_base_1 = require("@applitools/core-base");
 const get_viewport_size_1 = require("../automation/get-viewport-size");
 const set_viewport_size_1 = require("../automation/set-viewport-size");
 const locate_1 = require("../automation/locate");
+const locate_text_1 = require("../automation/locate-text");
+const extract_text_1 = require("../automation/extract-text");
 const open_eyes_1 = require("./open-eyes");
 const utils = __importStar(require("@applitools/utils"));
 const throat_1 = __importDefault(require("throat"));
@@ -74,6 +76,8 @@ function makeCore({ concurrency, spec, client, core, agentId = 'core-ufg', cwd =
         getViewportSize: spec && (0, get_viewport_size_1.makeGetViewportSize)({ spec, logger }),
         setViewportSize: spec && (0, set_viewport_size_1.makeSetViewportSize)({ spec, logger }),
         locate: (0, locate_1.makeLocate)({ spec, core, logger }),
+        locateText: (0, locate_text_1.makeLocateText)({ spec, core, logger }),
+        extractText: (0, extract_text_1.makeExtractText)({ spec, core, logger }),
         openEyes: (0, open_eyes_1.makeOpenEyes)({ spec, client, core, logger }),
     });
 }

package/dist/ufg/get-results.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeGetResults = void 0;
+const abort_error_1 = require("../errors/abort-error");
+function makeGetResults({ storage, logger: defaultLogger }) {
+    return async function getResults({ settings, logger = defaultLogger, } = {}) {
+        logger.log('Command "getResults" is called with settings', settings);
+        return Promise.all(Array.from(storage.values(), async (promises) => {
+            var _a;
+            try {
+                const [{ eyes, renderer }] = await Promise.all(promises);
+                const [result] = await eyes.getResults({ settings, logger });
+                return { ...result, renderer };
+            }
+            catch (error) {
+                if (error instanceof abort_error_1.AbortError && ((_a = error.info) === null || _a === void 0 ? void 0 : _a.eyes)) {
+                    logger.warn('Command "getResults" received an abort error during performing', settings);
+                    const [result] = await error.info.eyes.getResults({ settings, logger });
+                    return { ...result, renderer: error.info.renderer };
+                }
+                logger.fatal('Command "getResults" received an error during performing', settings);
+                throw error;
+            }
+        }));
+    };
+}
+exports.makeGetResults = makeGetResults;

package/dist/ufg/open-eyes.js

@@ -31,9 +31,10 @@ 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 get_results_1 = require("./get-results");
 const abort_controller_1 = require("abort-controller");
 const utils = __importStar(require("@applitools/utils"));
-function makeOpenEyes({ core, client, spec, logger: defaultLogger, }) {
+function makeOpenEyes({ core, client, spec, logger: defaultLogger }) {
     return async function openEyes({ target, settings, eyes, logger = defaultLogger, }) {
         var _a, _b;
         logger.log(`Command "openEyes" is called with ${target ? 'default driver and' : ''}`, ...(settings ? ['settings', settings] : []), eyes ? 'predefined eyes' : '');
@@ -59,9 +60,8 @@ function makeOpenEyes({ core, client, spec, logger: defaultLogger, }) {
         const getBaseEyes = (0, get_base_eyes_1.makeGetBaseEyes)({ settings, eyes, core, client, logger });
         return utils.general.extend({}, eyes => {
             var _a;
-            const storage = [];
-            let closed = false;
-            let aborted = false;
+            const storage = new Map();
+            let running = true;
             return {
                 type: 'ufg',
                 test: {
@@ -72,22 +72,17 @@ function makeOpenEyes({ core, client, spec, logger: defaultLogger, }) {
                     account,
                 },
                 get running() {
-                    return !closed && !aborted;
-                },
-                get closed() {
-                    return closed;
-                },
-                get aborted() {
-                    return aborted;
+                    return running;
                 },
                 getBaseEyes,
                 // check with indexing and storage
                 check: utils.general.wrap((0, check_1.makeCheck)({ eyes, client: client, target: driver, spec, signal: controller.signal, logger }), async (check, options = {}) => {
                     const results = await check(options);
-                    storage.push(...results.map(result => ({
-                        promise: result.promise,
-                        renderer: result.renderer,
-                    })));
+                    results.forEach(result => {
+                        var _a;
+                        const key = JSON.stringify(result.renderer);
+                        storage.set(key, [...((_a = storage.get(key)) !== null && _a !== void 0 ? _a : []), result.promise]);
+                    });
                     return results;
                 }),
                 checkAndClose: (0, check_and_close_1.makeCheckAndClose)({
@@ -98,22 +93,15 @@ function makeOpenEyes({ core, client, spec, logger: defaultLogger, }) {
                     signal: controller.signal,
                     logger,
                 }),
-                locateText: null,
-                extractText: null,
-                // close only once
                 close: utils.general.wrap((0, close_1.makeClose)({ storage, target: driver, logger }), async (close, options) => {
-                    if (closed || aborted)
-                        return [];
-                    closed = true;
+                    running = false;
                     return close(options);
                 }),
-                // abort only once
                 abort: utils.general.wrap((0, abort_1.makeAbort)({ storage, target: driver, spec, controller, logger }), async (abort, options) => {
-                    if (aborted || closed)
-                        return [];
-                    aborted = true;
+                    running = false;
                     return abort(options);
                 }),
+                getResults: (0, get_results_1.makeGetResults)({ storage, logger }),
             };
         });
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applitools/core",
-  "version": "1.4.7",
+  "version": "2.0.0",
   "homepage": "https://applitools.com",
   "bugs": {
     "url": "https://github.com/applitools/eyes.sdk.javascript1/issues"
@@ -56,14 +56,14 @@
     "postversion": "bongo postversion --skip-release-notification"
   },
   "dependencies": {
-    "@applitools/core-base": "1.1.33",
+    "@applitools/core-base": "1.1.34",
     "@applitools/dom-capture": "11.2.1",
     "@applitools/dom-snapshot": "4.7.3",
-    "@applitools/driver": "1.11.28",
+    "@applitools/driver": "1.11.29",
     "@applitools/logger": "1.1.45",
-    "@applitools/nml-client": "1.3.31",
+    "@applitools/nml-client": "1.3.32",
     "@applitools/req": "1.1.30",
-    "@applitools/screenshoter": "3.7.24",
+    "@applitools/screenshoter": "3.7.25",
     "@applitools/snippets": "2.4.15",
     "@applitools/ufg-client": "1.1.24",
     "@applitools/utils": "1.3.30",
@@ -77,9 +77,9 @@
   },
   "devDependencies": {
     "@applitools/bongo": "^2.2.2",
-    "@applitools/spec-driver-puppeteer": "^1.1.39",
-    "@applitools/spec-driver-selenium": "^1.5.26",
-    "@applitools/spec-driver-webdriverio": "^1.4.23",
+    "@applitools/spec-driver-puppeteer": "^1.1.40",
+    "@applitools/spec-driver-selenium": "^1.5.27",
+    "@applitools/spec-driver-webdriverio": "^1.4.24",
     "@applitools/test-server": "^1.1.24",
     "@applitools/test-utils": "^1.5.12",
     "@types/mocha": "^9.1.1",

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

@@ -0,0 +1,16 @@
+import type { MaybeArray } from '@applitools/utils';
+import type { DriverTarget, ImageTarget, ExtractTextSettings } from '../classic/types';
+import type { Core as BaseCore } from '@applitools/core-base';
+import { type Logger } from '@applitools/logger';
+import { type SpecType, type SpecDriver } from '@applitools/driver';
+type Options<TSpec extends SpecType> = {
+    core: BaseCore;
+    spec?: SpecDriver<TSpec>;
+    logger: Logger;
+};
+export declare function makeExtractText<TSpec extends SpecType>({ core, spec, logger: defaultLogger }: Options<TSpec>): ({ target, settings, logger, }: {
+    target: DriverTarget<TSpec> | ImageTarget;
+    settings: MaybeArray<ExtractTextSettings<TSpec>>;
+    logger?: Logger | undefined;
+}) => Promise<string[]>;
+export {};

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

@@ -1,12 +1,12 @@
 import type { DriverTarget } from './types';
 import { type Logger } from '@applitools/logger';
-import { type SpecDriver } from '@applitools/driver';
-type Options<TDriver, TContext, TElement, TSelector> = {
-    spec: SpecDriver<TDriver, TContext, TElement, TSelector>;
+import { type SpecType, type SpecDriver } from '@applitools/driver';
+type Options<TSpec extends SpecType> = {
+    spec: SpecDriver<TSpec>;
     logger: Logger;
 };
-export declare function makeGetViewportSize<TDriver, TContext, TElement, TSelector>({ spec, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): ({ target, logger, }: {
-    target: DriverTarget<TDriver, TContext, TElement, TSelector>;
+export declare function makeGetViewportSize<TSpec extends SpecType>({ spec, logger: defaultLogger }: Options<TSpec>): ({ target, logger, }: {
+    target: DriverTarget<TSpec>;
     logger?: Logger | undefined;
 }) => Promise<import("@applitools/utils").Size>;
 export {};

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

@@ -0,0 +1,15 @@
+import type { DriverTarget, ImageTarget, LocateTextSettings, LocateTextResult } from './types';
+import type { Core as BaseCore } from '@applitools/core-base';
+import { type Logger } from '@applitools/logger';
+import { type SpecType, type SpecDriver } from '@applitools/driver';
+type Options<TSpec extends SpecType> = {
+    core: BaseCore;
+    spec?: SpecDriver<TSpec>;
+    logger: Logger;
+};
+export declare function makeLocateText<TSpec extends SpecType>({ core, spec, logger: defaultLogger }: Options<TSpec>): <TPattern extends string>({ target, settings, logger, }: {
+    target: DriverTarget<TSpec> | ImageTarget;
+    settings: LocateTextSettings<TPattern, TSpec>;
+    logger?: Logger | undefined;
+}) => Promise<LocateTextResult<TPattern>>;
+export {};

package/types/automation/locate.d.ts

@@ -1,15 +1,15 @@
 import type { DriverTarget, ImageTarget, LocateSettings, LocateResult } from './types';
 import type { Core as BaseCore } from '@applitools/core-base';
 import { type Logger } from '@applitools/logger';
-import { type SpecDriver } from '@applitools/driver';
-type Options<TDriver, TContext, TElement, TSelector> = {
+import { type SpecType, type SpecDriver } from '@applitools/driver';
+type Options<TSpec extends SpecType> = {
     core: BaseCore;
-    spec?: SpecDriver<TDriver, TContext, TElement, TSelector>;
+    spec?: SpecDriver<TSpec>;
     logger: Logger;
 };
-export declare function makeLocate<TDriver, TContext, TElement, TSelector>({ spec, core, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): <TLocator extends string>({ settings, target, logger, }: {
-    target: DriverTarget<TDriver, TContext, TElement, TSelector> | ImageTarget;
-    settings: LocateSettings<TLocator, TElement, TSelector>;
+export declare function makeLocate<TSpec extends SpecType>({ spec, core, logger: defaultLogger }: Options<TSpec>): <TLocator extends string>({ settings, target, logger, }: {
+    target: DriverTarget<TSpec> | ImageTarget;
+    settings: LocateSettings<TLocator, TSpec>;
     logger?: Logger | undefined;
 }) => Promise<LocateResult<TLocator>>;
 export {};

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

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

package/types/automation/types.d.ts

@@ -1,72 +1,68 @@
 import type { MaybeArray, Size, Region } from '@applitools/utils';
 import type * as BaseCore from '@applitools/core-base/types';
-import { type Driver, type Selector } from '@applitools/driver';
+import { type SpecType, type Driver, type ElementReference, type ContextReference } from '@applitools/driver';
 import { type Logger } from '@applitools/logger';
 export * from '@applitools/core-base/types';
-export type DriverTarget<TDriver, TContext, TElement, TSelector> = TDriver | Driver<TDriver, TContext, TElement, TSelector>;
-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;
+export type DriverTarget<TSpec extends SpecType> = TSpec['driver'] | Driver<TSpec>;
+export type Target<TSpec extends SpecType> = DriverTarget<TSpec> | BaseCore.Target;
+export interface Core<TSpec extends SpecType, TTarget = Target<TSpec>, TEyes extends Eyes<TSpec, TTarget> = Eyes<TSpec, TTarget>> extends BaseCore.Core<TTarget, TEyes> {
+    isDriver?(driver: any): driver is TSpec['driver'];
+    isElement?(element: any): element is TSpec['element'];
+    isSelector?(selector: any): selector is TSpec['selector'];
     getViewportSize?(options: {
-        target: DriverTarget<TDriver, TContext, TElement, TSelector>;
+        target: DriverTarget<TSpec>;
         logger?: Logger;
     }): Promise<Size>;
     setViewportSize?(options: {
-        target: DriverTarget<TDriver, TContext, TElement, TSelector>;
+        target: DriverTarget<TSpec>;
         size: Size;
         logger?: Logger;
     }): Promise<void>;
     openEyes(options: {
-        target?: DriverTarget<TDriver, TContext, TElement, TSelector>;
+        target?: DriverTarget<TSpec>;
         settings: BaseCore.OpenSettings;
         eyes?: BaseCore.Eyes[];
         logger?: Logger;
     }): Promise<TEyes>;
     locate<TLocator extends string>(options: {
-        target: DriverTarget<TDriver, TContext, TElement, TSelector> | BaseCore.ImageTarget;
-        settings: LocateSettings<TLocator, TElement, TSelector>;
+        target: TTarget;
+        settings: LocateSettings<TLocator, TSpec>;
         logger?: Logger;
     }): Promise<BaseCore.LocateResult<TLocator>>;
+    locateText<TPattern extends string>(options: {
+        target: TTarget;
+        settings: LocateTextSettings<TPattern, TSpec>;
+        logger?: Logger;
+    }): Promise<BaseCore.LocateTextResult<TPattern>>;
+    extractText(options: {
+        target: TTarget;
+        settings: MaybeArray<ExtractTextSettings<TSpec>>;
+        logger?: Logger;
+    }): Promise<string[]>;
 }
-export interface Eyes<TDriver, TContext, TElement, TSelector, TTarget = DriverTarget<TDriver, TContext, TElement, TSelector>> extends BaseCore.Eyes<TTarget> {
+export interface Eyes<TSpec extends SpecType, TTarget = Target<TSpec>> extends BaseCore.Eyes<TTarget> {
     getBaseEyes(options?: {
         logger?: Logger;
     }): Promise<BaseCore.Eyes[]>;
     check(options?: {
         target?: TTarget;
-        settings?: CheckSettings<TElement, TSelector>;
+        settings?: CheckSettings<TSpec>;
         logger?: Logger;
     }): Promise<BaseCore.CheckResult[]>;
     checkAndClose(options?: {
         target?: TTarget;
-        settings?: CheckSettings<TElement, TSelector> & BaseCore.CloseSettings;
+        settings?: CheckSettings<TSpec> & BaseCore.CloseSettings;
         logger?: Logger;
     }): Promise<BaseCore.TestResult[]>;
-    locateText<TPattern extends string>(options: {
-        target?: TTarget;
-        settings: LocateTextSettings<TPattern, TElement, TSelector>;
-        logger?: Logger;
-    }): Promise<BaseCore.LocateTextResult<TPattern>>;
-    extractText(options: {
-        target?: TTarget;
-        settings: MaybeArray<ExtractTextSettings<TElement, TSelector>>;
-        logger?: Logger;
-    }): Promise<string[]>;
 }
-type RegionReference<TElement, TSelector> = Region | ElementReference<TElement, TSelector>;
-type ElementReference<TElement, TSelector> = TElement | Selector<TSelector>;
-type FrameReference<TElement, TSelector> = ElementReference<TElement, TSelector> | string | number;
-type ContextReference<TElement, TSelector> = {
-    frame: FrameReference<TElement, TSelector>;
-    scrollRootElement?: ElementReference<TElement, TSelector>;
-};
-type StitchMode = 'Scroll' | 'CSS';
-export interface ScreenshotSettings<TElement, TSelector> extends BaseCore.ImageSettings<RegionReference<TElement, TSelector>> {
-    frames?: (ContextReference<TElement, TSelector> | FrameReference<TElement, TSelector>)[];
+export interface ScreenshotSettings<TSpec extends SpecType> extends BaseCore.ImageSettings<Region | ElementReference<TSpec>> {
+    frames?: (ContextReference<TSpec> | {
+        frame: ContextReference<TSpec>;
+        scrollRootElement?: ElementReference<TSpec>;
+    })[];
     fully?: boolean;
-    scrollRootElement?: ElementReference<TElement, TSelector>;
-    stitchMode?: StitchMode;
+    scrollRootElement?: ElementReference<TSpec>;
+    stitchMode?: 'Scroll' | 'CSS';
     hideScrollbars?: boolean;
     hideCaret?: boolean;
     overlap?: {
@@ -82,7 +78,7 @@ export interface ScreenshotSettings<TElement, TSelector> extends BaseCore.ImageS
     };
     webview?: boolean | string;
 }
-export type LocateSettings<TLocator extends string, TElement, TSelector> = BaseCore.LocateSettings<TLocator, RegionReference<TElement, TSelector>> & ScreenshotSettings<TElement, TSelector>;
-export type CheckSettings<TElement, TSelector> = BaseCore.CheckSettings<RegionReference<TElement, TSelector>> & ScreenshotSettings<TElement, TSelector>;
-export type LocateTextSettings<TPattern extends string, TElement, TSelector> = BaseCore.LocateTextSettings<TPattern, RegionReference<TElement, TSelector>> & ScreenshotSettings<TElement, TSelector>;
-export type ExtractTextSettings<TElement, TSelector> = BaseCore.ExtractTextSettings<RegionReference<TElement, TSelector>> & ScreenshotSettings<TElement, TSelector>;
+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>;

package/types/automation/utils/take-screenshot.d.ts

@@ -1,19 +1,19 @@
 import type { Region } from '@applitools/utils';
 import type { ScreenshotSettings } from '../../classic/types';
 import { type Logger } from '@applitools/logger';
-import { type Driver, type Element, type ElementReference } from '@applitools/driver';
-export type Screenshot<TElement, TSelector> = {
+import { type Driver, type Element, type ElementReference, type SpecType } from '@applitools/driver';
+export type Screenshot<TSpec extends SpecType> = {
     image: any;
     region: Region;
-    element: Element<unknown, unknown, TElement, TSelector>;
-    scrollingElement: Element<unknown, unknown, TElement, TSelector>;
+    element: Element<TSpec>;
+    scrollingElement: Element<TSpec>;
     restoreState(): Promise<void>;
     calculatedRegions: [];
 };
-export declare function takeScreenshot<TDriver, TContext, TElement, TSelector>({ driver, settings, logger, }: {
-    driver: Driver<TDriver, TContext, TElement, TSelector>;
-    settings: ScreenshotSettings<TElement, TSelector> & {
-        regionsToCalculate?: ElementReference<TElement, TSelector>[];
+export declare function takeScreenshot<TSpec extends SpecType>({ driver, settings, logger, }: {
+    driver: Driver<TSpec>;
+    settings: ScreenshotSettings<TSpec> & {
+        regionsToCalculate?: ElementReference<TSpec>[];
     };
     logger: Logger;
-}): Promise<Screenshot<TElement, TSelector>>;
+}): Promise<Screenshot<TSpec>>;

package/types/automation/utils/to-base-check-settings.d.ts

@@ -1,19 +1,12 @@
 import type { Region } from '@applitools/utils';
-import type { CheckSettings as BaseCheckSettings } from '@applitools/core-base';
 import type { CheckSettings } from '../types';
-import { type Selector } from '@applitools/driver';
-export declare function toBaseCheckSettings<TElement, TSelector>({ settings }: {
-    settings: CheckSettings<TElement, TSelector>;
+import type { CheckSettings as BaseCheckSettings } from '@applitools/core-base';
+import { type SpecType, type ElementReference, type Selector } from '@applitools/driver';
+export declare function toBaseCheckSettings<TSpec extends SpecType>({ settings }: {
+    settings: CheckSettings<TSpec>;
 }): {
-    elementReferencesToCalculate: (TElement | Selector<TSelector>)[];
-    elementReferenceToTarget: string | TElement | TSelector | {
-        selector: string | TSelector;
-        type?: string | undefined;
-        child?: Selector<TSelector> | undefined;
-        shadow?: Selector<TSelector> | undefined;
-        frame?: Selector<TSelector> | undefined;
-        fallback?: Selector<TSelector> | undefined;
-    } | undefined;
+    elementReferencesToCalculate: ElementReference<TSpec>[];
+    elementReferenceToTarget: ElementReference<TSpec> | undefined;
     getBaseCheckSettings: ({ calculatedRegions, preserveTransformation, }: {
         calculatedRegions: {
             selector?: Selector;

package/types/automation/utils/wait-for-lazy-load.d.ts

@@ -1,5 +1,5 @@
 import { type Logger } from '@applitools/logger';
-import { type Context } from '@applitools/driver';
+import { type SpecType, type Context } from '@applitools/driver';
 export type LazyLoadSettings = {
     scrollLength?: number;
     waitingTime?: number;
@@ -7,8 +7,8 @@ export type LazyLoadSettings = {
     executionTimeout?: number;
     pollTimeout?: number;
 };
-export declare function waitForLazyLoad<TContext extends Context<unknown, unknown, unknown, unknown>>({ context, settings, logger, }: {
-    context: TContext;
+export declare function waitForLazyLoad<TSpec extends SpecType>({ context, settings, logger, }: {
+    context: Context<TSpec>;
     settings: LazyLoadSettings;
     logger: Logger;
 }): Promise<void>;

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

@@ -1,20 +1,18 @@
 import type { Target, DriverTarget, Eyes, Config, CheckSettings, CloseSettings, TestResult } from './types';
 import { type Logger } from '@applitools/logger';
-import { type SpecDriver } from '@applitools/driver';
-type Options<TDriver, TContext, TElement, TSelector, TType extends 'classic' | 'ufg'> = {
+import { type SpecType, type SpecDriver } from '@applitools/driver';
+type Options<TSpec extends SpecType, TType extends 'classic' | 'ufg'> = {
     type?: TType;
-    eyes: Eyes<TDriver, TContext, TElement, TSelector, TType>;
-    target?: DriverTarget<TDriver, TContext, TElement, TSelector>;
-    spec?: SpecDriver<TDriver, TContext, TElement, TSelector>;
+    eyes: Eyes<TSpec, TType>;
+    target?: DriverTarget<TSpec>;
+    spec?: SpecDriver<TSpec>;
     logger: Logger;
 };
-export declare function makeCheckAndClose<TDriver, TContext, TElement, TSelector, TDefaultType extends 'classic' | 'ufg' = 'classic'>({ type: defaultType, eyes, target: defaultTarget, spec, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector, TDefaultType>): <TType extends "classic" | "ufg" = TDefaultType>({ type, target, settings, config, logger, }?: {
+export declare function makeCheckAndClose<TSpec extends SpecType, TDefaultType extends 'classic' | 'ufg'>({ type: defaultType, eyes, target: defaultTarget, spec, logger: defaultLogger, }: Options<TSpec, TDefaultType>): <TType extends "classic" | "ufg" = TDefaultType>({ type, target, settings, config, logger, }?: {
     type?: TType | undefined;
-    target?: Target<TDriver, TContext, TElement, TSelector, TType> | undefined;
-    settings?: (CheckSettings<TElement, TSelector, TDefaultType> & (TDefaultType extends "ufg" ? import("@applitools/core-base").CloseSettings : import("@applitools/core-base").CloseSettings) & {
-        throwErr?: boolean | undefined;
-    } & CheckSettings<TElement, TSelector, TType> & (TType extends "ufg" ? import("@applitools/core-base").CloseSettings : import("@applitools/core-base").CloseSettings)) | undefined;
-    config?: (Config<TElement, TSelector, TDefaultType> & Config<TElement, TSelector, TType>) | undefined;
+    target?: Target<TSpec, TType> | undefined;
+    settings?: (CheckSettings<TSpec, TDefaultType> & CloseSettings<TDefaultType> & CheckSettings<TSpec, TType> & CloseSettings<TType>) | undefined;
+    config?: (Config<TSpec, TDefaultType> & Config<TSpec, TType>) | undefined;
     logger?: Logger | undefined;
 }) => Promise<TestResult<TType>[]>;
 export {};