@applitools/core 2.3.14 → 2.3.15

package/dist/ufg/core.js

@@ -34,51 +34,56 @@ 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 get_ufg_client_1 = require("./get-ufg-client");
+const get_nml_client_1 = require("./get-nml-client");
 const open_eyes_1 = require("./open-eyes");
 const utils = __importStar(require("@applitools/utils"));
 const throat_1 = __importDefault(require("throat"));
-function makeCore({ concurrency, spec, clients, core, agentId = 'core-ufg', cwd = process.cwd(), logger, }) {
+function makeCore({ concurrency, spec, clients, base, agentId = 'core-ufg', cwd = process.cwd(), logger: defaultLogger, }) {
     var _a;
-    logger = (_a = logger === null || logger === void 0 ? void 0 : logger.extend({ label: 'core-ufg' })) !== null && _a !== void 0 ? _a : (0, logger_1.makeLogger)({ label: 'core-ufg' });
-    logger.log(`Core ufg is initialized ${core ? 'with' : 'without'} custom base core`);
-    const throttle = (0, throat_1.default)(concurrency);
-    core !== null && core !== void 0 ? core : (core = (0, core_base_1.makeCore)({ agentId, cwd, logger }));
-    // open eyes with concurrency
-    core.openEyes = utils.general.wrap(core.openEyes, (openEyes, options) => {
-        return new Promise((resolve, rejects) => {
-            throttle(() => {
-                return new Promise(async (done) => {
-                    try {
-                        const eyes = await openEyes(options);
-                        resolve(utils.general.extend(eyes, {
-                            // release concurrency slot when closed
-                            close: utils.general.wrap(eyes.close, (close, options) => close(options).finally(done)),
-                            // release concurrency slot when aborted
-                            abort: utils.general.wrap(eyes.abort, (abort, options) => abort(options).finally(done)),
-                            // release concurrency slot when checkAndClose is done
-                            checkAndClose: utils.general.wrap(eyes.checkAndClose, (checkAndClose, options) => checkAndClose(options).finally(done)),
-                        }));
-                    }
-                    catch (error) {
-                        rejects(error);
-                        // release concurrency slot when error thrown
-                        done();
-                    }
-                });
-            });
-        });
-    });
-    return utils.general.extend(core, {
-        type: 'ufg',
-        isDriver: spec && spec.isDriver,
-        isElement: spec && spec.isElement,
-        isSelector: spec && spec.isSelector,
-        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, clients, core, logger }),
+    const logger = (_a = defaultLogger === null || defaultLogger === void 0 ? void 0 : defaultLogger.extend({ label: 'core-ufg' })) !== null && _a !== void 0 ? _a : (0, logger_1.makeLogger)({ label: 'core-ufg' });
+    logger.log(`Core ufg is initialized ${base ? 'with' : 'without'} custom base core`);
+    base !== null && base !== void 0 ? base : (base = (0, core_base_1.makeCore)({ agentId, cwd, logger }));
+    return utils.general.extend(base, core => {
+        const throttle = (0, throat_1.default)(concurrency);
+        return {
+            type: 'ufg',
+            base: utils.general.extend(base, {
+                // open eyes with concurrency
+                openEyes: utils.general.wrap(base.openEyes, (openEyes, options) => {
+                    return new Promise((resolve, rejects) => {
+                        throttle(() => {
+                            return new Promise(async (done) => {
+                                try {
+                                    const eyes = await openEyes(options);
+                                    resolve(utils.general.extend(eyes, {
+                                        // release concurrency slot when closed
+                                        close: utils.general.wrap(eyes.close, (close, options) => close(options).finally(done)),
+                                        // release concurrency slot when aborted
+                                        abort: utils.general.wrap(eyes.abort, (abort, options) => abort(options).finally(done)),
+                                        // release concurrency slot when checkAndClose is done
+                                        checkAndClose: utils.general.wrap(eyes.checkAndClose, (checkAndClose, options) => checkAndClose(options).finally(done)),
+                                    }));
+                                }
+                                catch (error) {
+                                    rejects(error);
+                                    // release concurrency slot when error thrown
+                                    done();
+                                }
+                            });
+                        });
+                    });
+                }),
+            }),
+            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 }),
+            getUFGClient: (0, get_ufg_client_1.makeGetUFGClient)({ client: clients === null || clients === void 0 ? void 0 : clients.ufg, logger }),
+            getNMLClient: (0, get_nml_client_1.makeGetNMLClient)({ client: clients === null || clients === void 0 ? void 0 : clients.nml, logger }),
+            openEyes: (0, open_eyes_1.makeOpenEyes)({ spec, core, logger }),
+        };
     });
 }
 exports.makeCore = makeCore;

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

@@ -25,23 +25,26 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeGetBaseEyes = void 0;
 const utils = __importStar(require("@applitools/utils"));
-function makeGetBaseEyes({ eyes, settings: defaultSettings, core, baseEyes, logger: defaultLogger }) {
+function makeGetBaseEyes({ settings: defaultSettings, eyes, base, logger: defaultLogger, }) {
     const getBaseEyesWithCache = utils.general.cachify(getBaseEyes, ([options]) => options === null || options === void 0 ? void 0 : options.settings);
-    if (baseEyes) {
-        baseEyes.forEach(baseEyes => getBaseEyesWithCache.setCachedValue(baseEyes.test.rendererInfo, Promise.resolve([baseEyes])));
+    if (base) {
+        base.forEach(baseEyes => getBaseEyesWithCache.setCachedValue(baseEyes.test.rendererInfo, Promise.resolve([baseEyes])));
     }
     return getBaseEyesWithCache;
     async function getBaseEyes({ settings, logger = defaultLogger, } = {}) {
         logger.log(`Command "getBaseEyes" is called with settings`, settings);
         if (!settings)
             throw new Error('');
-        const ufgClient = await eyes.getUFGClient({ logger });
+        const ufgClient = await eyes.core.getUFGClient({
+            config: { ...eyes.test.account, ...eyes.test.account.ufg, proxy: eyes.test.server.proxy },
+            logger,
+        });
         const environment = await ufgClient.bookRenderer({ settings });
-        const eyesBase = await core.openEyes({
+        const baseEyes = await eyes.core.base.openEyes({
             settings: { ...defaultSettings, environment: { ...defaultSettings.environment, ...environment } },
             logger,
         });
-        return [eyesBase];
+        return [baseEyes];
     }
 }
 exports.makeGetBaseEyes = makeGetBaseEyes;

package/dist/ufg/get-nml-client.js

@@ -26,12 +26,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeGetNMLClient = void 0;
 const nml_client_1 = require("@applitools/nml-client");
 const utils = __importStar(require("@applitools/utils"));
-function makeGetNMLClient({ config, client, logger: defaultLogger }) {
-    const getBaseEyesWithCache = utils.general.cachify(getNMLClient, () => 'default');
+function makeGetNMLClient({ client, logger: defaultLogger }) {
+    const getNMLClientWithCache = utils.general.cachify(getNMLClient, ([options]) => client ? 'default' : [options.driver.sessionId, options.config]);
     if (client)
-        getBaseEyesWithCache.setCachedValue('default', Promise.resolve(client));
-    return getBaseEyesWithCache;
-    async function getNMLClient({ driver, logger = defaultLogger }) {
+        getNMLClientWithCache.setCachedValue('default', Promise.resolve(client));
+    return getNMLClientWithCache;
+    async function getNMLClient({ driver, config, logger = defaultLogger, }) {
         const brokerUrl = await driver.extractBrokerUrl();
         if (!brokerUrl)
             return null;

package/dist/ufg/get-ufg-client.js

@@ -26,13 +26,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeGetUFGClient = void 0;
 const ufg_client_1 = require("@applitools/ufg-client");
 const utils = __importStar(require("@applitools/utils"));
-function makeGetUFGClient({ config, concurrency, client, logger: defaultLogger }) {
-    const getBaseEyesWithCache = utils.general.cachify(getUFGClient, () => 'default');
+function makeGetUFGClient({ client, logger: defaultLogger }) {
+    const getUFGClientWithCache = utils.general.cachify(getUFGClient, ([options]) => client ? 'default' : [options.config]);
     if (client)
-        getBaseEyesWithCache.setCachedValue('default', Promise.resolve(client));
-    return getBaseEyesWithCache;
-    async function getUFGClient({ logger = defaultLogger } = {}) {
-        return (0, ufg_client_1.makeUFGClient)({ config, concurrency, logger });
+        getUFGClientWithCache.setCachedValue('default', Promise.resolve(client));
+    return getUFGClientWithCache;
+    async function getUFGClient({ config, concurrency, logger = defaultLogger, }) {
+        return (0, ufg_client_1.makeUFGClient)({ config, concurrency: concurrency || 5, logger });
     }
 }
 exports.makeGetUFGClient = makeGetUFGClient;

package/dist/ufg/open-eyes.js

@@ -25,8 +25,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeOpenEyes = void 0;
 const driver_1 = require("@applitools/driver");
-const get_ufg_client_1 = require("./get-ufg-client");
-const get_nml_client_1 = require("./get-nml-client");
 const get_base_eyes_1 = require("./get-base-eyes");
 const check_1 = require("./check");
 const check_and_close_1 = require("./check-and-close");
@@ -35,12 +33,12 @@ 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, clients, spec, logger: defaultLogger }) {
-    return async function openEyes({ target, settings, eyes, logger = defaultLogger, }) {
+function makeOpenEyes({ core, spec, logger: defaultLogger }) {
+    return async function openEyes({ target, settings, base, logger = defaultLogger, }) {
         var _a;
-        logger.log(`Command "openEyes" is called with ${target ? 'default driver and' : ''}`, ...(settings ? ['settings', settings] : []), eyes ? 'predefined eyes' : '');
+        logger.log(`Command "openEyes" is called with ${target ? 'default driver and' : ''}`, ...(settings ? ['settings', settings] : []), base ? 'predefined eyes' : '');
         const driver = target && (await (0, driver_1.makeDriver)({ spec, driver: target, logger }));
-        if (driver && !eyes) {
+        if (driver && !base) {
             const currentContext = driver.currentContext;
             (_a = settings.environment) !== null && _a !== void 0 ? _a : (settings.environment = {});
             if (driver.isEC) {
@@ -54,11 +52,12 @@ function makeOpenEyes({ core, clients, spec, logger: defaultLogger }) {
         const controller = new abort_controller_1.AbortController();
         const account = await core.getAccountInfo({ settings, logger });
         return utils.general.extend({}, eyes => {
-            var _a, _b;
+            var _a;
             const storage = new Map();
             let running = true;
             return {
                 type: 'ufg',
+                core,
                 test: {
                     userTestId: settings.userTestId,
                     batchId: (_a = settings.batch) === null || _a === void 0 ? void 0 : _a.id,
@@ -69,14 +68,7 @@ function makeOpenEyes({ core, clients, spec, logger: defaultLogger }) {
                 get running() {
                     return running;
                 },
-                getUFGClient: (0, get_ufg_client_1.makeGetUFGClient)({
-                    config: { ...account.ufg, ...account, proxy: settings.proxy },
-                    concurrency: (_b = settings.renderConcurrency) !== null && _b !== void 0 ? _b : 5,
-                    client: clients === null || clients === void 0 ? void 0 : clients.ufg,
-                    logger,
-                }),
-                getNMLClient: (0, get_nml_client_1.makeGetNMLClient)({ config: settings, client: clients === null || clients === void 0 ? void 0 : clients.nml, logger }),
-                getBaseEyes: (0, get_base_eyes_1.makeGetBaseEyes)({ eyes, settings, core, logger }),
+                getBaseEyes: (0, get_base_eyes_1.makeGetBaseEyes)({ settings, eyes, base, logger }),
                 // check with indexing and storage
                 check: utils.general.wrap((0, check_1.makeCheck)({ eyes, target: driver, spec, signal: controller.signal, logger }), async (check, options = {}) => {
                     const results = await check(options);

package/dist/universal/core-server.js

@@ -125,9 +125,10 @@ printStdout = false, ...handlerOptions } = {}) {
             const core = await corePromise;
             return core.extractText(options);
         });
+        // TODO rename to getECClient
         socket.command('Core.makeECClient', async (options) => {
             const core = await corePromise;
-            const client = await core.makeECClient(options);
+            const client = await core.getECClient(options);
             return { url: client.url };
         });
         socket.command('Core.makeManager', async (options) => {

package/dist/universal/core.js

@@ -31,7 +31,8 @@ const utils = __importStar(require("@applitools/utils"));
 //TODO add refer and sanitizing support, solve types issues
 function makeCore(options) {
     const socketPromise = makeClientSocket(options);
-    return {
+    const core = {
+        base: null,
         async getAccountInfo(options) {
             const socket = await socketPromise;
             return socket.request('Core.getAccountInfo', options);
@@ -58,15 +59,15 @@ function makeCore(options) {
         },
         async openEyes(options) {
             const socket = await socketPromise;
-            const eyes = await socket.request('Core.openEyes', options);
-            return makeEyes({ socket, eyes });
+            const eyesRef = await socket.request('Core.openEyes', options);
+            return makeEyes({ socket, core, eyesRef });
         },
         async makeManager(options) {
             const socket = await socketPromise;
-            const manager = await socket.request('Core.makeManager', options);
-            return makeManager({ socket, manager });
+            const managerRef = await socket.request('Core.makeManager', options);
+            return makeManager({ socket, core, managerRef });
         },
-        async makeECClient(options) {
+        async getECClient(options) {
             const socket = await socketPromise;
             return socket.request('Core.makeECClient', options);
         },
@@ -83,24 +84,27 @@ function makeCore(options) {
             return socket.request('Core.logEvent', options);
         },
     };
+    return core;
 }
 exports.makeCore = makeCore;
-function makeManager({ socket, manager, }) {
-    return {
+function makeManager({ socket, core, managerRef, }) {
+    const manager = {
         async openEyes(options) {
-            const eyes = await socket.request('EyesManager.openEyes', { ...options, manager });
-            return makeEyes({ socket, eyes });
+            const eyesRef = await socket.request('EyesManager.openEyes', { ...options, manager: managerRef });
+            return makeEyes({ socket, core, eyesRef });
         },
         async getResults(options) {
-            return socket.request('EyesManager.getResults', { ...options, manager });
+            return socket.request('EyesManager.getResults', { ...options, manager: managerRef });
         },
     };
+    return manager;
 }
 exports.makeManager = makeManager;
-function makeEyes({ socket, eyes, }) {
-    return {
+function makeEyes({ socket, core, eyesRef, }) {
+    const eyes = {
         test: null,
         running: null,
+        core,
         getBaseEyes() {
             return null;
         },
@@ -108,21 +112,22 @@ function makeEyes({ socket, eyes, }) {
             return null;
         },
         async check(options) {
-            return socket.request('Eyes.check', { ...options, eyes });
+            return socket.request('Eyes.check', { ...options, eyes: eyesRef });
         },
         async checkAndClose(options) {
-            return socket.request('Eyes.checkAndClose', { ...options, eyes });
+            return socket.request('Eyes.checkAndClose', { ...options, eyes: eyesRef });
         },
         async close(options) {
-            return socket.request('Eyes.close', { ...options, eyes });
+            return socket.request('Eyes.close', { ...options, eyes: eyesRef });
         },
         async abort(options) {
-            return socket.request('Eyes.abort', { ...options, eyes });
+            return socket.request('Eyes.abort', { ...options, eyes: eyesRef });
         },
         async getResults(options) {
-            return socket.request('Eyes.getResults', { ...options, eyes });
+            return socket.request('Eyes.getResults', { ...options, eyes: eyesRef });
         },
     };
+    return eyes;
 }
 exports.makeEyes = makeEyes;
 async function makeClientSocket({ agentId, spec, }) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applitools/core",
-  "version": "2.3.14",
+  "version": "2.3.15",
   "homepage": "https://applitools.com",
   "bugs": {
     "url": "https://github.com/applitools/eyes.sdk.javascript1/issues"
@@ -50,19 +50,21 @@
     "build:bin:arm64": "pkg . --target node14-linux-arm64 --output ./bin/core-linux-arm64",
     "build:bin:zip": "zip -j ./bin/core.zip $(find ./bin -type f -not -name '*.zip' -not -name '*.tar.gz' | xargs)",
     "build:bin:tgz": "tar -czf ./bin/core.tar.gz $(find ./bin -type f -not -name '*.zip' -not -name '*.tar.gz' | xargs)",
-    "test": "mocha --config .mocharc.cvg.js",
+    "test": "node ../../node_modules/.bin/mocha './test/**/*.spec.ts' --exclude './test/bin/**' --parallel --jobs ${MOCHA_JOBS:-15} --exit",
+    "test:bin": "MOCHA_GROUP=bin node ../../node_modules/mocha/bin/mocha './test/bin/**/*.spec.ts' --parallel --jobs ${MOCHA_JOBS:-15}",
+    "test:e2e": "MOCHA_GROUP=e2e node ../../node_modules/mocha/bin/mocha './test/e2e/**/*.spec.ts' --parallel --jobs ${MOCHA_JOBS:-15} --exit",
+    "test:it": "MOCHA_GROUP=it node ../../node_modules/.bin/mocha './test/it/**/*.spec.ts'",
+    "test:unit": "MOCHA_GROUP=unit node ../../node_modules/.bin/mocha './test/unit/**/*.spec.ts'",
     "test:sanity": "yarn test:unit",
-    "test:bin": "mocha --no-timeouts -r ts-node/register --parallel --jobs 15 './test/bin/**/*.spec.ts'",
-    "test:e2e": "mocha --no-timeouts -r ts-node/register --parallel --jobs 15 './test/e2e/**/*.spec.ts'",
-    "test:it": "mocha --no-timeouts -r ts-node/register './test/it/**/*.spec.ts'",
-    "test:unit": "mocha --no-timeouts -r ts-node/register './test/unit/**/*.spec.ts'",
+    "report": "bongo report --name 'core'",
     "setup": "yarn docker:setup",
     "docker:setup": "node ../../scripts/generate-docker-compose-config.js && docker-compose up -d",
     "docker:teardown": "docker-compose down",
     "deps": "bongo deps",
     "preversion": "bongo preversion --verify-pending-changes --skip-deps",
     "version": "bongo version --with-pending-changes",
-    "postversion": "bongo postversion"
+    "postversion": "bongo postversion",
+    "postpublish": "bongo send-release-notification --name 'core'"
   },
   "pkg": {
     "scripts": "./dist/cli/cli.js",
@@ -73,20 +75,20 @@
     ]
   },
   "dependencies": {
-    "@applitools/core-base": "1.1.39",
+    "@applitools/core-base": "1.1.41",
     "@applitools/dom-capture": "11.2.1",
     "@applitools/dom-snapshot": "4.7.5",
-    "@applitools/driver": "1.11.35",
-    "@applitools/ec-client": "1.2.14",
-    "@applitools/logger": "1.1.46",
-    "@applitools/nml-client": "1.3.38",
-    "@applitools/req": "1.1.30",
-    "@applitools/screenshoter": "3.7.29",
-    "@applitools/snippets": "2.4.15",
-    "@applitools/socket": "1.0.8",
-    "@applitools/spec-driver-webdriver": "1.0.15",
-    "@applitools/ufg-client": "1.2.1",
-    "@applitools/utils": "1.3.30",
+    "@applitools/driver": "1.11.36",
+    "@applitools/ec-client": "1.2.15",
+    "@applitools/logger": "1.1.47",
+    "@applitools/nml-client": "1.3.39",
+    "@applitools/req": "1.1.31",
+    "@applitools/screenshoter": "3.7.30",
+    "@applitools/snippets": "2.4.16",
+    "@applitools/socket": "1.0.9",
+    "@applitools/spec-driver-webdriver": "1.0.16",
+    "@applitools/ufg-client": "1.2.2",
+    "@applitools/utils": "1.3.31",
     "@types/ws": "8.5.4",
     "abort-controller": "3.0.0",
     "chalk": "4.1.2",
@@ -97,20 +99,17 @@
     "yargs": "17.6.2"
   },
   "devDependencies": {
-    "@applitools/bongo": "^2.2.5",
-    "@applitools/sdk-coverage-tests": "^2.7.12",
-    "@applitools/spec-driver-puppeteer": "^1.1.47",
-    "@applitools/spec-driver-selenium": "^1.5.32",
-    "@applitools/spec-driver-webdriverio": "^1.4.30",
-    "@applitools/test-server": "^1.1.26",
-    "@applitools/test-utils": "^1.5.12",
-    "@types/mocha": "^9.1.1",
-    "@types/node": "12",
+    "@applitools/bongo": "^3.0.1",
+    "@applitools/sdk-coverage-tests": "^3.0.0",
+    "@applitools/spec-driver-puppeteer": "^1.1.48",
+    "@applitools/spec-driver-selenium": "^1.5.33",
+    "@applitools/spec-driver-webdriverio": "^1.4.31",
+    "@applitools/test-server": "^1.1.27",
+    "@applitools/test-utils": "^1.5.13",
+    "@types/node": "^12.20.55",
     "@types/selenium-webdriver": "^4.1.2",
     "@types/yargs": "^17.0.22",
     "chromedriver": "^106.0.0",
-    "mocha": "^10.0.0",
-    "mocha-multi": "^1.1.7",
     "nock": "^13.2.8",
     "pkg": "^5.8.0",
     "png-async": "^0.9.4",

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

@@ -1,15 +1,14 @@
 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 { Target, Core, ExtractTextSettings } from '../classic/types';
 import { type Logger } from '@applitools/logger';
 import { type SpecType, type SpecDriver } from '@applitools/driver';
 type Options<TSpec extends SpecType> = {
-    core: BaseCore;
+    core: Core<TSpec>;
     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;
+    target: Target<TSpec>;
     settings: MaybeArray<ExtractTextSettings<TSpec>>;
     logger?: Logger | undefined;
 }) => Promise<string[]>;

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

@@ -1,14 +1,13 @@
-import type { DriverTarget, ImageTarget, LocateTextSettings, LocateTextResult } from './types';
-import type { Core as BaseCore } from '@applitools/core-base';
+import type { Target, Core, LocateTextSettings, LocateTextResult } from './types';
 import { type Logger } from '@applitools/logger';
 import { type SpecType, type SpecDriver } from '@applitools/driver';
 type Options<TSpec extends SpecType> = {
-    core: BaseCore;
+    core: Core<TSpec>;
     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;
+    target: Target<TSpec>;
     settings: LocateTextSettings<TPattern, TSpec>;
     logger?: Logger | undefined;
 }) => Promise<LocateTextResult<TPattern>>;

package/types/automation/locate.d.ts

@@ -1,14 +1,13 @@
-import type { DriverTarget, ImageTarget, LocateSettings, LocateResult } from './types';
-import type { Core as BaseCore } from '@applitools/core-base';
+import type { Target, Core, LocateSettings, LocateResult } from './types';
 import { type Logger } from '@applitools/logger';
 import { type SpecType, type SpecDriver } from '@applitools/driver';
 type Options<TSpec extends SpecType> = {
-    core: BaseCore;
+    core: Core<TSpec>;
     spec?: SpecDriver<TSpec>;
     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;
+    target: Target<TSpec>;
     settings: LocateSettings<TLocator, TSpec>;
     logger?: Logger | undefined;
 }) => Promise<LocateResult<TLocator>>;

package/types/automation/types.d.ts

@@ -5,10 +5,8 @@ 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 interface Core<TSpec extends SpecType> extends BaseCore.Core {
+    readonly base: BaseCore.Core;
     getViewportSize?(options: {
         target: DriverTarget<TSpec>;
         logger?: Logger;
@@ -21,36 +19,37 @@ export interface Core<TSpec extends SpecType, TTarget = Target<TSpec>, TEyes ext
     openEyes(options: {
         target?: DriverTarget<TSpec>;
         settings: BaseCore.OpenSettings;
-        eyes?: BaseCore.Eyes[];
+        base?: BaseCore.Eyes[];
         logger?: Logger;
-    }): Promise<TEyes>;
+    }): Promise<Eyes<TSpec>>;
     locate<TLocator extends string>(options: {
-        target: TTarget;
+        target: Target<TSpec>;
         settings: LocateSettings<TLocator, TSpec>;
         logger?: Logger;
     }): Promise<BaseCore.LocateResult<TLocator>>;
     locateText<TPattern extends string>(options: {
-        target: TTarget;
+        target: Target<TSpec>;
         settings: LocateTextSettings<TPattern, TSpec>;
         logger?: Logger;
     }): Promise<BaseCore.LocateTextResult<TPattern>>;
     extractText(options: {
-        target: TTarget;
+        target: Target<TSpec>;
         settings: MaybeArray<ExtractTextSettings<TSpec>>;
         logger?: Logger;
     }): Promise<string[]>;
 }
-export interface Eyes<TSpec extends SpecType, TTarget = Target<TSpec>> extends BaseCore.Eyes<TTarget> {
+export interface Eyes<TSpec extends SpecType> extends BaseCore.Eyes {
+    readonly core: Core<TSpec>;
     getBaseEyes(options?: {
         logger?: Logger;
     }): Promise<BaseCore.Eyes[]>;
     check(options?: {
-        target?: TTarget;
+        target?: Target<TSpec>;
         settings?: CheckSettings<TSpec>;
         logger?: Logger;
     }): Promise<BaseCore.CheckResult[]>;
     checkAndClose(options?: {
-        target?: TTarget;
+        target?: Target<TSpec>;
         settings?: CheckSettings<TSpec> & BaseCore.CloseSettings;
         logger?: Logger;
     }): Promise<BaseCore.TestResult[]>;

package/types/classic/core.d.ts

@@ -4,10 +4,10 @@ import { type Logger } from '@applitools/logger';
 import { type Core as BaseCore } from '@applitools/core-base';
 type Options<TSpec extends SpecType> = {
     spec?: SpecDriver<TSpec>;
-    core?: BaseCore;
+    base?: BaseCore;
     agentId?: string;
     cwd?: string;
     logger?: Logger;
 };
-export declare function makeCore<TSpec extends SpecType>({ spec, core, agentId, cwd, logger: defaultLogger, }: Options<TSpec>): Core<TSpec>;
+export declare function makeCore<TSpec extends SpecType>({ spec, base, agentId, cwd, logger: defaultLogger, }: Options<TSpec>): Core<TSpec>;
 export {};

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

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

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

@@ -1,16 +1,16 @@
-import type { DriverTarget, Eyes, OpenSettings } from './types';
-import type { Core as BaseCore, Eyes as BaseEyes } from '@applitools/core-base';
+import type { Core, DriverTarget, Eyes, OpenSettings } from './types';
+import type { Eyes as BaseEyes } 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;
+    core: Core<TSpec>;
     spec?: SpecDriver<TSpec>;
     logger: Logger;
 };
-export declare function makeOpenEyes<TSpec extends SpecType>({ core, spec, logger: defaultLogger }: Options<TSpec>): ({ target, settings, eyes, logger, }: {
+export declare function makeOpenEyes<TSpec extends SpecType>({ core, spec, logger: defaultLogger }: Options<TSpec>): ({ target, settings, base, logger, }: {
     target?: DriverTarget<TSpec> | undefined;
     settings: OpenSettings;
-    eyes?: BaseEyes<import("@applitools/core-base").ImageTarget>[] | undefined;
+    base?: BaseEyes[] | undefined;
     logger?: Logger | undefined;
 }) => Promise<Eyes<TSpec>>;
 export {};