@applitools/core 1.4.9 → 1.4.10

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.log('Command "check" is called with settings', settings);
+        logger === null || logger === void 0 ? void 0 : logger.log('Command "check" is called with settings', settings);
         if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
-            logger.warn('Command "check" was called after test was already aborted');
+            logger === null || logger === void 0 ? void 0 : 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.console.log(message);
+                logger === null || logger === void 0 ? void 0 : logger.console.log(message);
             }
             try {
                 if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
-                    logger.warn('Command "check" was aborted before rendering');
+                    logger === null || logger === void 0 ? void 0 : 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.running) {
+                    else if (baseEyes.aborted) {
                         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.running) {
+                    else if (baseEyes.aborted) {
                         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.running) {
+                    else if (baseEyes.aborted) {
                         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,16 +207,14 @@ function makeCheck({ eyes, client, target: defaultTarget, spec, signal, logger:
                         settings: baseSettings,
                         logger,
                     });
-                    if (!baseEyes.running) {
+                    if (baseEyes.aborted) {
                         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) {
-                    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()) } });
-                    }
+                    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,28 +2,29 @@
 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 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) => {
+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) => {
             var _a, _b;
             try {
-                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 });
-                }
+                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 };
             }
             catch (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 }));
+                await ((_b = (_a = error.info) === null || _a === void 0 ? void 0 : _a.eyes) === null || _b === void 0 ? void 0 : _b.abort({ logger }));
+                throw error;
             }
-        });
+        }));
     };
 }
 exports.makeClose = makeClose;

package/dist/ufg/core.js

@@ -32,8 +32,6 @@ 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"));
@@ -76,8 +74,6 @@ 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/open-eyes.js

@@ -31,10 +31,9 @@ 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' : '');
@@ -60,8 +59,9 @@ 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 = new Map();
-            let running = true;
+            const storage = [];
+            let closed = false;
+            let aborted = false;
             return {
                 type: 'ufg',
                 test: {
@@ -72,17 +72,22 @@ function makeOpenEyes({ core, client, spec, logger: defaultLogger }) {
                     account,
                 },
                 get running() {
-                    return 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: client, target: driver, spec, signal: controller.signal, logger }), async (check, options = {}) => {
                     const results = await check(options);
-                    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]);
-                    });
+                    storage.push(...results.map(result => ({
+                        promise: result.promise,
+                        renderer: result.renderer,
+                    })));
                     return results;
                 }),
                 checkAndClose: (0, check_and_close_1.makeCheckAndClose)({
@@ -93,15 +98,22 @@ 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) => {
-                    running = false;
+                    if (closed || aborted)
+                        return [];
+                    closed = true;
                     return close(options);
                 }),
+                // abort only once
                 abort: utils.general.wrap((0, abort_1.makeAbort)({ storage, target: driver, spec, controller, logger }), async (abort, options) => {
-                    running = false;
+                    if (aborted || closed)
+                        return [];
+                    aborted = true;
                     return abort(options);
                 }),
-                getResults: (0, get_results_1.makeGetResults)({ storage, logger }),
             };
         });
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applitools/core",
-  "version": "1.4.9",
+  "version": "1.4.10",
   "homepage": "https://applitools.com",
   "bugs": {
     "url": "https://github.com/applitools/eyes.sdk.javascript1/issues"
@@ -51,19 +51,17 @@
     "docker:setup": "node ../../scripts/generate-docker-compose-config.js && docker-compose up -d",
     "docker:teardown": "docker-compose down",
     "deps": "bongo deps",
-    "preversion": "bongo preversion",
-    "version": "bongo version",
-    "postversion": "bongo postversion --skip-release-notification"
+    "version": "bongo version"
   },
   "dependencies": {
-    "@applitools/core-base": "1.1.35",
+    "@applitools/core-base": "1.1.33",
     "@applitools/dom-capture": "11.2.1",
     "@applitools/dom-snapshot": "4.7.3",
-    "@applitools/driver": "1.11.29",
+    "@applitools/driver": "1.11.28",
     "@applitools/logger": "1.1.45",
-    "@applitools/nml-client": "1.3.32",
+    "@applitools/nml-client": "1.3.31",
     "@applitools/req": "1.1.30",
-    "@applitools/screenshoter": "3.7.25",
+    "@applitools/screenshoter": "3.7.24",
     "@applitools/snippets": "2.4.15",
     "@applitools/ufg-client": "1.1.24",
     "@applitools/utils": "1.3.30",
@@ -77,9 +75,9 @@
   },
   "devDependencies": {
     "@applitools/bongo": "^2.2.2",
-    "@applitools/spec-driver-puppeteer": "^1.1.40",
-    "@applitools/spec-driver-selenium": "^1.5.27",
-    "@applitools/spec-driver-webdriverio": "^1.4.24",
+    "@applitools/spec-driver-puppeteer": "^1.1.39",
+    "@applitools/spec-driver-selenium": "^1.5.26",
+    "@applitools/spec-driver-webdriverio": "^1.4.23",
     "@applitools/test-server": "^1.1.24",
     "@applitools/test-utils": "^1.5.12",
     "@types/mocha": "^9.1.1",

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

package/types/automation/types.d.ts

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

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

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

@@ -1,12 +1,19 @@
 import type { Region } from '@applitools/utils';
-import type { CheckSettings } from '../types';
 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>;
+import type { CheckSettings } from '../types';
+import { type Selector } from '@applitools/driver';
+export declare function toBaseCheckSettings<TElement, TSelector>({ settings }: {
+    settings: CheckSettings<TElement, TSelector>;
 }): {
-    elementReferencesToCalculate: ElementReference<TSpec>[];
-    elementReferenceToTarget: ElementReference<TSpec> | undefined;
+    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;
     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 SpecType, type Context } from '@applitools/driver';
+import { 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<TSpec extends SpecType>({ context, settings, logger, }: {
-    context: Context<TSpec>;
+export declare function waitForLazyLoad<TContext extends Context<unknown, unknown, unknown, unknown>>({ context, settings, logger, }: {
+    context: TContext;
     settings: LazyLoadSettings;
     logger: Logger;
 }): Promise<void>;

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

@@ -1,18 +1,20 @@
 import type { Target, DriverTarget, Eyes, Config, CheckSettings, CloseSettings, TestResult } 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'> = {
+import { type SpecDriver } from '@applitools/driver';
+type Options<TDriver, TContext, TElement, TSelector, TType extends 'classic' | 'ufg'> = {
     type?: TType;
-    eyes: Eyes<TSpec, TType>;
-    target?: DriverTarget<TSpec>;
-    spec?: SpecDriver<TSpec>;
+    eyes: Eyes<TDriver, TContext, TElement, TSelector, TType>;
+    target?: DriverTarget<TDriver, TContext, TElement, TSelector>;
+    spec?: SpecDriver<TDriver, TContext, TElement, TSelector>;
     logger: 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, }?: {
+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, }?: {
     type?: 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;
+    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;
     logger?: Logger | undefined;
 }) => Promise<TestResult<TType>[]>;
 export {};

package/types/check.d.ts

@@ -1,18 +1,18 @@
 import type { Target, DriverTarget, Eyes, Config, CheckSettings, CheckResult } 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'> = {
+import { type SpecDriver } from '@applitools/driver';
+type Options<TDriver, TContext, TElement, TSelector, TType extends 'classic' | 'ufg'> = {
     type?: TType;
-    eyes: Eyes<TSpec, TType>;
-    target?: DriverTarget<TSpec>;
-    spec?: SpecDriver<TSpec>;
+    eyes: Eyes<TDriver, TContext, TElement, TSelector, TType>;
+    target?: DriverTarget<TDriver, TContext, TElement, TSelector>;
+    spec?: SpecDriver<TDriver, TContext, TElement, TSelector>;
     logger: Logger;
 };
-export declare function makeCheck<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, }?: {
+export declare function makeCheck<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, }?: {
     type?: TType | undefined;
-    target?: Target<TSpec, TType> | undefined;
-    settings?: CheckSettings<TSpec, TType> | undefined;
-    config?: Config<TSpec, TType> | undefined;
+    target?: Target<TDriver, TContext, TElement, TSelector, TType> | undefined;
+    settings?: CheckSettings<TElement, TSelector, TType> | undefined;
+    config?: Config<TElement, TSelector, TType> | undefined;
     logger?: Logger | undefined;
 }) => Promise<CheckResult<TType>[]>;
 export {};

package/types/classic/abort.d.ts

@@ -1,16 +1,16 @@
-import type { AbortSettings } from './types';
+import type { AbortSettings, TestResult } from './types';
 import type { Eyes } from './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>;
-    spec?: SpecDriver<TSpec>;
+import { type SpecDriver } from '@applitools/driver';
+type Options<TDriver, TContext, TElement, TSelector> = {
+    eyes: Eyes<TDriver, TContext, TElement, TSelector>;
+    target?: DriverTarget<TDriver, TContext, TElement, TSelector>;
+    spec?: SpecDriver<TDriver, TContext, TElement, TSelector>;
     logger: Logger;
 };
-export declare function makeAbort<TSpec extends SpecType>({ eyes, target, spec, logger: defaultLogger }: Options<TSpec>): ({ settings, logger, }?: {
+export declare function makeAbort<TDriver, TContext, TElement, TSelector>({ eyes, target, spec, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): ({ settings, logger, }?: {
     settings?: AbortSettings | undefined;
     logger?: Logger | undefined;
-}) => Promise<void>;
+}) => Promise<TestResult[]>;
 export {};