@applitools/core 1.1.0 → 1.1.1

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

@@ -51,7 +51,6 @@ async function takeScreenshot({ driver, settings, logger, }) {
         },
         debug: settings.debugImages,
         logger,
-        webview: settings.webview,
     });
 }
 exports.takeScreenshot = takeScreenshot;

package/dist/check.js

@@ -22,13 +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 utils = __importStar(require("@applitools/utils"));
-const chalk_1 = __importDefault(require("chalk"));
 function makeCheck({ eyes, logger: defaultLogger, }) {
     return async function check({ target, settings = {}, config, logger = defaultLogger, } = {}) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
@@ -52,9 +48,6 @@ function makeCheck({ eyes, logger: defaultLogger, }) {
             (_p = (_u = settings.lazyLoad).maxAmountToScroll) !== null && _p !== void 0 ? _p : (_u.maxAmountToScroll = 15000);
         }
         (_q = settings.waitBetweenStitches) !== null && _q !== void 0 ? _q : (settings.waitBetweenStitches = utils.types.isObject(settings.lazyLoad) ? settings.lazyLoad.waitingTime : 100);
-        if (settings.matchLevel === 'Content') {
-            logger.console.log(chalk_1.default.yellow(`The "Content" match level value has been deprecated, use "IgnoreColors" instead.`));
-        }
         const results = await eyes.check({ target: target, settings, logger });
         return results;
     };

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/dist/ufg/utils/take-dom-snapshots.js

@@ -31,8 +31,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.takeDomSnapshots = void 0;
 const take_dom_snapshot_1 = require("./take-dom-snapshot");
-const utils = __importStar(require("@applitools/utils"));
 const chalk_1 = __importDefault(require("chalk"));
+const utils = __importStar(require("@applitools/utils"));
 __exportStar(require("./take-dom-snapshot"), exports);
 async function takeDomSnapshots({ driver, settings, hooks, provides, logger, }) {
     var _a, _b, _c, _d;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applitools/core",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "homepage": "https://applitools.com",
   "bugs": {
     "url": "https://github.com/applitools/eyes.sdk.javascript1/issues"
@@ -57,17 +57,17 @@
     }
   },
   "dependencies": {
-    "@applitools/core-base": "1.0.6",
+    "@applitools/core-base": "1.0.7",
     "@applitools/dom-capture": "11.1.2",
-    "@applitools/dom-snapshot": "4.6.2",
-    "@applitools/driver": "1.10.3",
-    "@applitools/logger": "1.1.24",
-    "@applitools/nml-client": "1.3.0",
-    "@applitools/req": "1.1.8",
-    "@applitools/screenshoter": "3.6.0",
+    "@applitools/dom-snapshot": "4.6.3",
+    "@applitools/driver": "1.10.4",
+    "@applitools/logger": "1.1.25",
+    "@applitools/nml-client": "1.3.1",
+    "@applitools/req": "1.1.9",
+    "@applitools/screenshoter": "3.6.2",
     "@applitools/snippets": "2.4.5",
-    "@applitools/types": "1.5.17",
-    "@applitools/ufg-client": "1.0.6",
+    "@applitools/types": "1.5.18",
+    "@applitools/ufg-client": "1.0.7",
     "@applitools/utils": "1.3.12",
     "abort-controller": "3.0.0",
     "throat": "6.0.1"
@@ -75,9 +75,9 @@
   "devDependencies": {
     "@applitools/bongo": "^2.2.0",
     "@applitools/sdk-fake-eyes-server": "^2.1.3",
-    "@applitools/spec-driver-puppeteer": "^1.1.13",
-    "@applitools/spec-driver-selenium": "^1.4.0",
-    "@applitools/spec-driver-webdriverio": "^1.3.0",
+    "@applitools/spec-driver-puppeteer": "^1.1.14",
+    "@applitools/spec-driver-selenium": "^1.4.1",
+    "@applitools/spec-driver-webdriverio": "^1.3.1",
     "@applitools/test-server": "^1.1.5",
     "@applitools/test-utils": "^1.5.1",
     "@types/mocha": "^9.1.1",

package/types/eyes.d.ts

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

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>;
+}>;

package/dist/ufg/utils/take-native-app-snapshot.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.takeNativeAppSnapshot = exports.getBrokerURL = void 0;
-const nml_client_1 = require("@applitools/nml-client");
-async function getBrokerURL(driver) {
-    if (!driver.isIOS)
-        return false;
-    try {
-        const element = await driver.element({
-            type: 'xpath',
-            selector: '//XCUIElementTypeOther[@name="Applitools_View"]',
-        });
-        const result = JSON.parse(await element.getText());
-        return result.nextPath;
-    }
-    catch (error) {
-        return false;
-    }
-}
-exports.getBrokerURL = getBrokerURL;
-async function takeNativeAppSnapshot(options) {
-    const nmlSnapshot = await (0, nml_client_1.takeSnapshot)(options.driver);
-    const snapshot = {
-        platformName: nmlSnapshot.resourceMap.metadata.platformName,
-        vhsHash: nmlSnapshot.resourceMap.vhs,
-        vhsCompatibilityParams: undefined,
-    };
-    if (options.driver.isIOS) {
-        snapshot.vhsCompatibilityParams = {
-            UIKitLinkTimeVersionNumber: nmlSnapshot.metadata.UIKitLinkTimeVersionNumber,
-            UIKitRunTimeVersionNumber: nmlSnapshot.metadata.UIKitRunTimeVersionNumber,
-        };
-    }
-    return { snapshots: snapshot };
-}
-exports.takeNativeAppSnapshot = takeNativeAppSnapshot;

package/types/ufg/utils/take-native-app-snapshot.d.ts

@@ -1,5 +0,0 @@
-export declare function getBrokerURL(driver: any): Promise<any>;
-export declare function takeNativeAppSnapshot(options: {
-    driver: any;
-    logger: any;
-}): Promise<any>;