@applitools/core 1.0.0 → 1.0.2

package/dist/check.js

@@ -31,15 +31,15 @@ function makeCheck({ eyes, logger: defaultLogger, }) {
         var _r, _s, _t, _u;
         settings = { ...config === null || config === void 0 ? void 0 : config.screenshot, ...config === null || config === void 0 ? void 0 : config.check, ...settings };
         (_a = settings.fully) !== null && _a !== void 0 ? _a : (settings.fully = !settings.region && (!settings.frames || settings.frames.length === 0));
-        (_b = settings.sendDom) !== null && _b !== void 0 ? _b : (settings.sendDom = true);
-        (_c = settings.waitBeforeCapture) !== null && _c !== void 0 ? _c : (settings.waitBeforeCapture = 100);
-        (_d = settings.stitchMode) !== null && _d !== void 0 ? _d : (settings.stitchMode = 'Scroll');
-        (_e = settings.hideScrollbars) !== null && _e !== void 0 ? _e : (settings.hideScrollbars = true);
-        (_f = settings.hideCaret) !== null && _f !== void 0 ? _f : (settings.hideCaret = true);
-        (_g = settings.overlap) !== null && _g !== void 0 ? _g : (settings.overlap = { top: 10, bottom: 50 });
-        (_h = settings.matchLevel) !== null && _h !== void 0 ? _h : (settings.matchLevel = 'Strict');
-        (_j = settings.ignoreCaret) !== null && _j !== void 0 ? _j : (settings.ignoreCaret = true);
-        (_k = settings.useDom) !== null && _k !== void 0 ? _k : false;
+        (_b = settings.waitBeforeCapture) !== null && _b !== void 0 ? _b : (settings.waitBeforeCapture = 100);
+        (_c = settings.stitchMode) !== null && _c !== void 0 ? _c : (settings.stitchMode = 'Scroll');
+        (_d = settings.hideScrollbars) !== null && _d !== void 0 ? _d : (settings.hideScrollbars = true);
+        (_e = settings.hideCaret) !== null && _e !== void 0 ? _e : (settings.hideCaret = true);
+        (_f = settings.overlap) !== null && _f !== void 0 ? _f : (settings.overlap = { top: 10, bottom: 50 });
+        (_g = settings.matchLevel) !== null && _g !== void 0 ? _g : (settings.matchLevel = 'Strict');
+        (_h = settings.ignoreCaret) !== null && _h !== void 0 ? _h : (settings.ignoreCaret = true);
+        (_j = settings.sendDom) !== null && _j !== void 0 ? _j : (settings.sendDom = true);
+        (_k = settings.useDom) !== null && _k !== void 0 ? _k : (settings.useDom = false);
         (_l = (_r = settings).retryTimeout) !== null && _l !== void 0 ? _l : (_r.retryTimeout = 2000);
         settings.lazyLoad = settings.lazyLoad === true ? {} : settings.lazyLoad;
         if (settings.lazyLoad) {

package/dist/classic/locate.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeLocate = void 0;
+const driver_1 = require("@applitools/driver");
+const take_screenshot_1 = require("./utils/take-screenshot");
+function makeLocate({ spec, eyes, target: defaultTarget, logger: defaultLogger, }) {
+    return async function locate({ target = defaultTarget, settings, logger = defaultLogger, } = {}) {
+        logger.log('Command "check" is called with settings', settings);
+        if (!spec.isDriver(target)) {
+            return eyes.locate({ target, settings: settings, logger });
+        }
+        // TODO driver custom config
+        const driver = await (0, driver_1.makeDriver)({ spec, driver: target, logger });
+        const screenshot = await (0, take_screenshot_1.takeScreenshot)({ driver, settings, logger });
+        const baseTarget = {
+            image: await screenshot.image.toPng(),
+        };
+        const results = await eyes.locate({ target: baseTarget, settings: settings, logger });
+        return results;
+    };
+}
+exports.makeLocate = makeLocate;

package/dist/classic/utils/take-screenshot.js

@@ -0,0 +1,54 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.takeScreenshot = void 0;
+const screenshoter_1 = require("@applitools/screenshoter");
+const utils = __importStar(require("@applitools/utils"));
+async function takeScreenshot({ driver, settings, logger, }) {
+    return (0, screenshoter_1.takeScreenshot)({
+        driver,
+        frames: settings.frames?.map(frame => {
+            return utils.types.has(frame, 'frame')
+                ? { reference: frame.frame, scrollingElement: frame.scrollRootElement }
+                : { reference: frame };
+        }),
+        region: settings.region,
+        fully: settings.fully,
+        hideScrollbars: settings.hideScrollbars,
+        hideCaret: settings.hideCaret,
+        scrollingMode: settings.stitchMode?.toLowerCase(),
+        overlap: settings.overlap,
+        wait: settings.waitBeforeCapture,
+        framed: driver.isNative,
+        stabilization: settings.normalization && {
+            crop: settings.normalization.cut,
+            scale: settings.normalization.scaleRatio,
+            rotation: settings.normalization.rotation,
+        },
+        debug: settings.debugImages,
+        logger,
+    });
+}
+exports.takeScreenshot = takeScreenshot;

package/dist/core.js

@@ -28,7 +28,7 @@ const logger_1 = require("@applitools/logger");
 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_1 = require("./locate");
 const open_eyes_1 = require("./open-eyes");
 const make_manager_1 = require("./make-manager");
 const utils = __importStar(require("@applitools/utils"));

package/dist/locate.js

@@ -1,10 +1,39 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeLocate = void 0;
-function makeLocate({ core, logger: defaultLogger, }) {
+const core_1 = require("./classic/core");
+const utils = __importStar(require("@applitools/utils"));
+function makeLocate({ spec, core, logger: defaultLogger, }) {
     return async function locate({ target, settings, config, logger = defaultLogger, }) {
+        var _a, _b, _c;
         settings = { ...config === null || config === void 0 ? void 0 : config.open, ...config === null || config === void 0 ? void 0 : config.screenshot, ...settings };
-        const results = await core.locate({ target: target, settings, logger });
+        (_a = settings.serverUrl) !== null && _a !== void 0 ? _a : (settings.serverUrl = (_b = utils.general.getEnvValue('SERVER_URL')) !== null && _b !== void 0 ? _b : 'https://eyesapi.applitools.com');
+        (_c = settings.apiKey) !== null && _c !== void 0 ? _c : (settings.apiKey = utils.general.getEnvValue('API_KEY'));
+        const classicCore = (0, core_1.makeCore)({ spec, core, logger });
+        const results = await classicCore.locate({ target, settings, logger });
         return results;
     };
 }

package/dist/ufg/check.js

@@ -22,6 +22,9 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeCheck = void 0;
 const driver_1 = require("@applitools/driver");
@@ -30,6 +33,7 @@ const wait_for_lazy_load_1 = require("../utils/wait-for-lazy-load");
 const to_base_check_settings_1 = require("../utils/to-base-check-settings");
 const generate_safe_selectors_1 = require("./utils/generate-safe-selectors");
 const utils = __importStar(require("@applitools/utils"));
+const chalk_1 = __importDefault(require("chalk"));
 function makeCheck({ spec, getEyes, client, test, signal, target: defaultTarget, logger: defaultLogger, }) {
     return async function check({ target = defaultTarget, settings = {}, logger = defaultLogger, }) {
         var _a, _b;
@@ -101,6 +105,10 @@ function makeCheck({ spec, getEyes, client, test, signal, target: defaultTarget,
             safeSelector: selector,
         })));
         const promises = settings.renderers.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);
+            }
             try {
                 if (signal.aborted) {
                     logger.warn('Command "check" was aborted before rendering');

package/dist/ufg/utils/generate-selectors.js

@@ -0,0 +1,60 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSelectors = void 0;
+const snippets = __importStar(require("@applitools/snippets"));
+const utils = __importStar(require("@applitools/utils"));
+async function generateSelectors({ context, elementReferences, }) {
+    const mapping = {
+        elements: [],
+        ids: [],
+    };
+    for (const elementReference of elementReferences) {
+        const elements = await context.elements(elementReference);
+        mapping.elements.push(elements);
+        mapping.ids.push(Array(elements.length).fill(utils.general.guid()));
+    }
+    const generatedSelectors = await context.execute(snippets.addElementIds, [mapping.elements.flat(), mapping.ids.flat()]);
+    let offset = 0;
+    const selectors = mapping.elements.map(elements => {
+        if (elements.length === 0)
+            return null;
+        const generatedSelector = generatedSelectors[offset].reduce((selector, value) => {
+            return selector ? { ...selector, shadow: { type: 'css', selector: value } } : { type: 'css', selector: value };
+        }, null);
+        offset += elements.length;
+        return { generatedSelector, originalSelector: elements[0].commonSelector };
+    });
+    return {
+        selectors,
+        cleanupGeneratedSelectors,
+    };
+    async function cleanupGeneratedSelectors() {
+        if (!mapping.elements.length)
+            return;
+        await context.execute(snippets.cleanupElementIds, [mapping.elements]);
+    }
+}
+exports.generateSelectors = generateSelectors;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applitools/core",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "homepage": "https://applitools.com",
   "bugs": {
     "url": "https://github.com/applitools/eyes.sdk.javascript1/issues"
@@ -57,17 +57,17 @@
     }
   },
   "dependencies": {
-    "@applitools/core-base": "1.0.1",
+    "@applitools/core-base": "1.0.3",
     "@applitools/dom-capture": "11.1.2",
     "@applitools/dom-snapshot": "4.6.2",
-    "@applitools/driver": "1.9.28",
-    "@applitools/logger": "1.1.20",
-    "@applitools/nml-client": "1.2.1",
-    "@applitools/req": "1.1.4",
-    "@applitools/screenshoter": "3.5.2",
+    "@applitools/driver": "1.9.31",
+    "@applitools/logger": "1.1.21",
+    "@applitools/nml-client": "1.2.2",
+    "@applitools/req": "1.1.5",
+    "@applitools/screenshoter": "3.5.3",
     "@applitools/snippets": "2.4.5",
-    "@applitools/types": "1.5.13",
-    "@applitools/ufg-client": "1.0.1",
+    "@applitools/types": "1.5.14",
+    "@applitools/ufg-client": "1.0.3",
     "@applitools/utils": "1.3.12",
     "abort-controller": "3.0.0",
     "throat": "6.0.1"

package/types/classic/locate.d.ts

@@ -0,0 +1,16 @@
+import type { SpecDriver, Region } from '@applitools/types';
+import type { Eyes as BaseEyes } from '@applitools/types/base';
+import type { Target, LocateSettings } from '@applitools/types/classic';
+import { type Logger } from '@applitools/logger';
+declare type Options<TDriver, TContext, TElement, TSelector> = {
+    spec: SpecDriver<TDriver, TContext, TElement, TSelector>;
+    eyes: BaseEyes;
+    target: Target<TDriver>;
+    logger: Logger;
+};
+export declare function makeLocate<TDriver, TContext, TElement, TSelector>({ spec, eyes, target: defaultTarget, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): <TLocator extends string>({ target, settings, logger, }?: {
+    target?: Target<TDriver>;
+    settings?: LocateSettings<TLocator, TElement, TSelector>;
+    logger?: Logger;
+}) => Promise<Record<TLocator, Region[]>>;
+export {};

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

@@ -0,0 +1,15 @@
+import type { Region } from '@applitools/types';
+import { ScreenshotSettings } from '@applitools/types/classic';
+import { type Logger } from '@applitools/logger';
+import { type Driver, type Element } from '@applitools/driver';
+export declare type Screenshot = {
+    image: any;
+    region: Region;
+    scrollingElement: Element<unknown, unknown, unknown, unknown>;
+    restoreState(): Promise<void>;
+};
+export declare function takeScreenshot<TDriver, TContext, TElement, TSelector>({ driver, settings, logger, }: {
+    driver: Driver<TDriver, TContext, TElement, TSelector>;
+    settings: ScreenshotSettings<TElement, TSelector>;
+    logger: Logger;
+}): Promise<Screenshot>;

package/types/eyes.d.ts

@@ -0,0 +1 @@
+export {};

package/types/locate.d.ts

@@ -1,13 +1,14 @@
-import type { Region, Target, Config, LocateSettings } from '@applitools/types';
-import type { Core as ClassicCore } from '@applitools/types/classic';
-import type { Core as UFGCore } from '@applitools/types/ufg';
+import type { Region, SpecDriver, Config, LocateSettings } from '@applitools/types';
+import type { Core as BaseCore } from '@applitools/types/base';
+import type { Screenshot } from '@applitools/types/classic';
 import { type Logger } from '@applitools/logger';
-declare type Options<TDriver, TElement, TSelector> = {
-    core: ClassicCore<TDriver, TElement, TSelector> | UFGCore<TDriver, TElement, TSelector>;
+declare type Options<TDriver, TContext, TElement, TSelector> = {
+    spec: SpecDriver<TDriver, TContext, TElement, TSelector>;
+    core: BaseCore;
     logger: Logger;
 };
-export declare function makeLocate<TDriver, TElement, TSelector, TType extends 'classic' | 'ufg'>({ core, logger: defaultLogger, }: Options<TDriver, TElement, TSelector>): <TLocator extends string>({ target, settings, config, logger, }: {
-    target?: Target<TDriver, TType>;
+export declare function makeLocate<TDriver, TContext, TElement, TSelector, TType extends 'classic' | 'ufg'>({ spec, core, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): <TLocator extends string>({ target, settings, config, logger, }: {
+    target?: TDriver | Screenshot;
     settings: LocateSettings<TLocator, TElement, TSelector>;
     config?: Config<TElement, TSelector, TType>;
     logger?: Logger;

package/types/server/req-eyes.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import { Proxy } from '@applitools/types';
+import { Request } from 'node-fetch';
+import { Req, Options } from './req';
+import { Logger } from '@applitools/logger';
+export declare type ReqEyesConfig = {
+    serverUrl: string;
+    apiKey: string;
+    proxy?: Proxy;
+    agentId?: string;
+    connectionTimeout?: number;
+    removeSession?: boolean;
+};
+export declare type ReqEyesOptions = Options & {
+    name: string;
+    expected?: number | number[];
+};
+export declare type ReqEyes = Req & ((input: string | URL | Request, options?: ReqEyesOptions) => ReturnType<Req>);
+export declare function makeReqEyes({ config, logger }: {
+    config: ReqEyesConfig;
+    logger?: Logger;
+}): ReqEyes;

package/types/server/req.d.ts

@@ -0,0 +1,172 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import globalFetch, { Request, Response } from 'node-fetch';
+declare const stop: unique symbol;
+export declare type Options = {
+    /**
+     * Providing this value will allow usage of relative urls for input
+     * @example 'http://localhost:2107/api/'
+     */
+    baseUrl?: string;
+    /**
+     * Uppercase method name. This will override method provided in `Request` object
+     * @example 'GET'
+     */
+    method?: string;
+    /**
+     * Query parameters to add to the url, all undefined params won't be added.
+     * It won't override the whole `search` part of the url, but instead merge with it
+     * @example {string: 'value', number: 21, boolean: true, noop: undefined}
+     */
+    query?: Record<string, string | boolean | number | undefined>;
+    /**
+     * Headers to send in the request, all undefined headers won't be sent.
+     * This will merge with headers provided in `Request` object
+     * @example {'x-my-header': 'value', 'x-noop-header': undefined}
+     */
+    headers?: Record<string, string | undefined>;
+    /**
+     * Body of the request, plain objects will be transformed to JSON strings
+     * @example {data: true}
+     * @example Buffer.from('S3lyeWxv', 'base64')
+     */
+    body?: NodeJS.ReadableStream | ArrayBufferView | string | Record<string, any>;
+    /**
+     * Proxy settings for the request. Auth credentials specified in the object will override ones specified in url
+     * @example {url: 'http://localhost:2107', username: 'kyrylo', password: 'pass'}
+     */
+    proxy?: {
+        url: string;
+        username: string;
+        password: string;
+    };
+    /**
+     * Connection timeout in ms
+     * @example 7000
+     */
+    timeout?: number;
+    /**
+     * Retry settings for the request. If specified as an array the retries are applied in the order
+     * @see Retry
+     * @example {limit: 5, statuses: [500, 501], codes: ['ECONRESET'], timeout: 1000}
+     */
+    retry?: Retry | Retry[];
+    /**
+     * Hooks of the request
+     * @see Hooks
+     */
+    hooks?: Hooks | Hooks[];
+    fetch?: typeof globalFetch;
+};
+export declare type Retry = {
+    /**
+     * Max number of attempts for specified condition
+     */
+    limit?: number;
+    /**
+     * Timeout before retrying the request. If specified as an array each element specifies the timeout for specific attempt,
+     * and the last one will be default for all next attempts
+     * @example [1000, 1000, 5000, 10_000]
+     */
+    timeout?: number | number[];
+    /**
+     * Status codes of the response to retry on.
+     * @example [500]
+     */
+    statuses?: number[];
+    /**
+     * Error codes of the request to retry on.
+     * @example ['ECONRESET']
+     */
+    codes?: string[];
+    /**
+     * Number of the current attempt for specified condition
+     * @internal
+     */
+    attempt?: number;
+};
+export declare type Hooks = {
+    /**
+     * Hook that will be executed before sending the request, after all, modifications of the `Request` object are already passed
+     * @example
+     * ```
+     * {
+     *   beforeRequest({request}) {
+     *      request.headers.set('Expires', 'Tue, 24 Aug 2022 00:00:00 GMT')
+     *   }
+     * }
+     * ```
+     */
+    beforeRequest?(options: {
+        request: Request;
+        options: Options;
+    }): Request | void | Promise<Request | void>;
+    /**
+     * Hook that will be executed before retrying the request. If this hook will return {@link req.stop}
+     * it will prevent request from retrying and execution of other hooks
+     * @example
+     * ```
+     * {
+     *   async beforeRetry({request, response, attempt}) {
+     *      const data = await response?.json()
+     *      if (data.error) return req.stop
+     *      request.headers.set('x-attempt', attempt)
+     *   }
+     * }
+     * ```
+     */
+    beforeRetry?(options: {
+        request: Request;
+        attempt: number;
+        response?: Response;
+        error?: Error;
+        options: Options;
+    }): Request | typeof stop | void | Promise<Request | void | typeof stop>;
+    /**
+     * Hook that will be executed after getting the final response of the request (after all of the retries)
+     * @example
+     * ```
+     * {
+     *   async afterResponse({request, response, options}) {
+     *      if (!response.ok) return req(request, options)
+     *   }
+     * }
+     * ```
+     */
+    afterResponse?(options: {
+        request: Request;
+        response: Response;
+        options: Options;
+    }): Response | void | Promise<Response | void>;
+    /**
+     * Hook that will be executed after request will throw an error
+     * @example
+     * ```
+     * {
+     *   async afterError({request, error}) {
+     *      error.request = request
+     *   }
+     * }
+     * ```
+     */
+    afterError?(options: {
+        request: Request;
+        error: Error;
+        options: Options;
+    }): Error | void | Promise<Error | void>;
+};
+/**
+ * Helper function that will properly merge two {@link Options} objects
+ */
+export declare function mergeOptions(baseOption: Options, options: Options): Options;
+/**
+ * Helper function that will create {@link req} function with predefined options
+ * @example const req = makeReq({baseUrl: 'http://localhost:2107'})
+ */
+export declare function makeReq(baseOption?: Options): typeof req;
+export declare function req(input: string | URL | Request, options?: Options): Promise<Response>;
+export declare namespace req {
+    var stop: unique symbol;
+}
+export declare type Req = typeof req;
+export default req;

package/types/server/requests.d.ts

@@ -0,0 +1,73 @@
+import type { Region, TextRegion, Batch } from '@applitools/types';
+import type { Target, Core, Eyes, ServerSettings, CheckSettings, LocateSettings, LocateTextSettings, ExtractTextSettings, CloseSettings, DeleteTestSettings, CloseBatchSettings, CheckResult, TestResult, OpenSettings } from '@applitools/types/types/core-base';
+import { type Logger } from '@applitools/logger';
+import { type ReqEyes } from './req-eyes';
+interface AccountInfo {
+    renderUrl: string;
+    renderToken: string;
+    uploadUrl: string;
+    maxImageHeight: number;
+    maxImageArea: number;
+}
+interface Test {
+    testId: string;
+    batchId: string;
+    baselineId: string;
+    sessionId: string;
+    resultsUrl: string;
+    isNew: boolean;
+}
+export interface CoreRequests extends Core {
+    openEyes(options: {
+        settings: OpenSettings;
+    }): Promise<EyesRequests>;
+    getAccountInfo(options: {
+        settings: ServerSettings;
+    }): Promise<AccountInfo>;
+    getBatch(options: {
+        settings: ServerSettings & {
+            batchId: string;
+        };
+    }): Promise<Batch>;
+    closeBatch(options: {
+        settings: CloseBatchSettings;
+    }): Promise<void>;
+    deleteTest(options: {
+        settings: DeleteTestSettings;
+    }): Promise<void>;
+}
+export interface EyesRequests extends Eyes {
+    check(options: {
+        target: Target;
+        settings?: CheckSettings;
+    }): Promise<CheckResult[]>;
+    checkAndClose(options: {
+        target: Target;
+        settings?: CheckSettings;
+    }): Promise<TestResult[]>;
+    locate<TLocator extends string>(options: {
+        target: Target;
+        settings: LocateSettings<TLocator>;
+    }): Promise<Record<TLocator, Region[]>>;
+    locateText<TPattern extends string>(options: {
+        target: Target;
+        settings: LocateTextSettings<TPattern>;
+    }): Promise<Record<TPattern, TextRegion[]>>;
+    extractText(options: {
+        target: Target;
+        settings: ExtractTextSettings;
+    }): Promise<string[]>;
+    close(options: {
+        settings: CloseSettings;
+    }): Promise<TestResult[]>;
+    abort(): Promise<TestResult[]>;
+}
+export declare function makeCoreCommands({ logger }: {
+    logger?: Logger;
+}): CoreRequests;
+export declare function makeEyesCommands({ test, req, logger }: {
+    test: Test;
+    req: ReqEyes;
+    logger?: Logger;
+}): EyesRequests;
+export {};

package/types/ufg/utils/generate-selectors.d.ts

@@ -0,0 +1,12 @@
+import type { Selector } from '@applitools/types';
+import { type Context } from '@applitools/driver';
+export declare function generateSelectors<TElement, TSelector>({ context, elementReferences, }: {
+    context: Context<unknown, unknown, TElement, TSelector>;
+    elementReferences: (TElement | Selector<TSelector>)[];
+}): Promise<{
+    selectors: {
+        generatedSelector: Selector;
+        originalSelector: Selector;
+    }[];
+    cleanupGeneratedSelectors(): Promise<void>;
+}>;