@applitools/nml-client 1.5.8 → 1.5.9

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## [1.5.9](https://github.com/applitools/eyes.sdk.javascript1/compare/js/nml-client@1.5.8...js/nml-client@1.5.9) (2023-08-30)
+
+
+### Bug Fixes
+
+* update broker url when server respond with error ([#1882](https://github.com/applitools/eyes.sdk.javascript1/issues/1882)) ([ab5a6ae](https://github.com/applitools/eyes.sdk.javascript1/commit/ab5a6ae8976b061bda8b56a9cc11c149e47d6dea))
+
+
+### Dependencies
+
+* @applitools/utils bumped to 1.5.2
+  #### Bug Fixes
+
+  * fixed some types ([498b1d7](https://github.com/applitools/eyes.sdk.javascript1/commit/498b1d7c547df04773b64b66ee39cccb402c093e))
+* @applitools/logger bumped to 2.0.9
+
+* @applitools/req bumped to 1.5.4
+
+* @applitools/spec-driver-webdriver bumped to 1.0.43
+
+* @applitools/driver bumped to 1.13.6
+
+
 ## [1.5.8](https://github.com/applitools/eyes.sdk.javascript1/compare/js/nml-client@1.5.7...js/nml-client@1.5.8) (2023-08-18)
 
 

package/dist/client.js

@@ -4,13 +4,14 @@ exports.makeNMLClient = void 0;
 const logger_1 = require("@applitools/logger");
 const requests_1 = require("./server/requests");
 const take_snapshots_1 = require("./take-snapshots");
-const take_screenshot_1 = require("./take-screenshot");
-function makeNMLClient({ config, logger: defaultLogger, }) {
+const take_screenshots_1 = require("./take-screenshots");
+function makeNMLClient({ settings, logger: defaultLogger, }) {
     const logger = (0, logger_1.makeLogger)({ logger: defaultLogger, format: { label: 'nml-client' } });
-    const requests = (0, requests_1.makeNMLRequests)({ config, logger });
+    const requests = (0, requests_1.makeNMLRequests)({ settings, logger });
     return {
-        takeScreenshot: (0, take_screenshot_1.makeTakeScreenshot)({ requests, logger }),
+        takeScreenshots: (0, take_screenshots_1.makeTakeScreenshots)({ requests, logger }),
         takeSnapshots: (0, take_snapshots_1.makeTakeSnapshots)({ requests, logger }),
+        getSupportedRenderEnvironments: requests.getSupportedRenderEnvironments,
     };
 }
 exports.makeNMLClient = makeNMLClient;

package/dist/server/req-broker.js

@@ -25,14 +25,14 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeReqBroker = void 0;
 const req_1 = __importStar(require("@applitools/req"));
-function makeReqBroker({ config, logger }) {
+function makeReqBroker({ settings, logger }) {
     return (0, req_1.makeReq)({
         method: 'POST',
         headers: {
             'Content-Type': 'application/json',
-            'User-Agent': config.agentId,
+            'User-Agent': settings.agentId,
         },
-        proxy: config.proxy,
+        proxy: settings.proxy,
         connectionTimeout: 300000 /* 5min */,
         retry: {
             limit: 5,
@@ -90,8 +90,9 @@ function handleUnexpectedResponse() {
                 const body = await response.text();
                 const result = JSON.parse(body);
                 if ((_a = result === null || result === void 0 ? void 0 : result.payload) === null || _a === void 0 ? void 0 : _a.error) {
-                    const error = result.payload.error;
-                    throw new Error(`There was a problem when interacting with the mobile application. The provided error message was "${error.message}" and had a stack trace of "${error.stack}"`);
+                    const error = new Error(`There was a problem when interacting with the mobile application. The provided error message was "${result.payload.error.message}" and had a stack trace of "${result.payload.error.stack}"`);
+                    error.nextPath = result.nextPath;
+                    throw error;
                 }
                 return { response, body };
             }

package/dist/server/requests.js

@@ -22,60 +22,124 @@ 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.makeNMLRequests = void 0;
 const req_broker_1 = require("./req-broker");
+const req_1 = __importDefault(require("@applitools/req"));
 const utils = __importStar(require("@applitools/utils"));
-function makeNMLRequests({ config, logger: defaultLogger, }) {
-    let brokerUrl = config.brokerUrl;
-    const req = (0, req_broker_1.makeReqBroker)({ config, logger: defaultLogger });
-    return { takeScreenshot, takeSnapshots };
-    async function takeScreenshot({ settings, logger = defaultLogger, }) {
-        const response = await req(brokerUrl, {
-            name: 'TAKE_SCREENSHOT',
-            body: {
-                protocolVersion: '1.0',
-                name: 'TAKE_SCREENSHOT',
-                key: utils.general.guid(),
-                payload: settings,
-            },
-            logger,
-        });
+function makeNMLRequests({ settings, logger: defaultLogger, }) {
+    let brokerUrl = settings.brokerUrl;
+    const req = (0, req_broker_1.makeReqBroker)({ settings, logger: defaultLogger });
+    const getSupportedRenderEnvironmentsWithCache = utils.general.cachify(getSupportedRenderEnvironments);
+    return {
+        getSupportedRenderEnvironments: getSupportedRenderEnvironmentsWithCache,
+        takeScreenshots,
+        takeSnapshots,
+    };
+    async function getSupportedRenderEnvironments({ logger: _logger }) {
+        const response = await (0, req_1.default)(settings.renderEnvironmentsUrl);
         const result = await response.json();
-        brokerUrl = result.nextPath;
-        return {
-            image: result.payload.result.screenshotUrl,
-        };
+        return result;
+    }
+    async function takeScreenshots({ settings, logger = defaultLogger, }) {
+        const supportedRenderEnvironments = await getSupportedRenderEnvironmentsWithCache({ logger });
+        const { localEnvironment, renderEnvironments, rendererSettings } = settings.renderers.reduce((result, renderer) => {
+            var _a;
+            if (utils.types.has(renderer, 'environment')) {
+                result.localEnvironment = { ...renderer.environment, renderEnvironmentId: utils.general.guid(), renderer };
+            }
+            else {
+                const deviceInfo = utils.types.has(renderer, 'iosDeviceInfo')
+                    ? renderer.iosDeviceInfo
+                    : renderer.androidDeviceInfo;
+                const orientation = deviceInfo.screenOrientation === 'landscape' ? 'landscapeLeft' : (_a = deviceInfo.screenOrientation) !== null && _a !== void 0 ? _a : 'portrait';
+                const rawEnvironment = supportedRenderEnvironments[deviceInfo.deviceName][orientation].env;
+                result.renderEnvironments.push({
+                    renderEnvironmentId: utils.general.guid(),
+                    renderer,
+                    deviceName: rawEnvironment.deviceInfo,
+                    os: rawEnvironment.os + (deviceInfo.version ? ` ${deviceInfo.version}` : ''),
+                    viewportSize: rawEnvironment.displaySize,
+                });
+                result.rendererSettings.push({ ...supportedRenderEnvironments[deviceInfo.deviceName], orientation });
+            }
+            return result;
+        }, {
+            localEnvironment: undefined,
+            renderEnvironments: [],
+            rendererSettings: [],
+        });
+        try {
+            const response = await req(brokerUrl, {
+                name: 'TAKE_SCREENSHOT',
+                body: {
+                    protocolVersion: '1.0',
+                    name: 'TAKE_SCREENSHOT',
+                    key: utils.general.guid(),
+                    payload: {
+                        ...settings,
+                        renderers: undefined,
+                        deviceList: !localEnvironment ? rendererSettings : undefined,
+                    },
+                },
+                logger,
+            });
+            const result = await response.json();
+            brokerUrl = result.nextPath;
+            if (localEnvironment) {
+                return [{ image: result.payload.result.screenshotUrl, renderEnvironment: localEnvironment }];
+            }
+            else {
+                return renderEnvironments.map((renderEnvironment, index) => {
+                    return { image: result.payload[index].result.screenshotUrl, renderEnvironment };
+                });
+            }
+        }
+        catch (error) {
+            if (error.nextPath)
+                brokerUrl = error.nextPath;
+            throw error;
+        }
     }
     async function takeSnapshots({ settings, logger = defaultLogger, }) {
-        const response = await req(brokerUrl, {
-            name: 'TAKE_SNAPSHOT',
-            body: {
-                protocolVersion: '1.0',
+        try {
+            const response = await req(brokerUrl, {
                 name: 'TAKE_SNAPSHOT',
-                key: utils.general.guid(),
-                payload: {
-                    waitBeforeCapture: settings.waitBeforeCapture,
+                body: {
+                    protocolVersion: '1.0',
+                    name: 'TAKE_SNAPSHOT',
+                    key: utils.general.guid(),
+                    payload: {
+                        waitBeforeCapture: settings.waitBeforeCapture,
+                    },
                 },
-            },
-            logger,
-        });
-        const result = await response.json();
-        brokerUrl = result.nextPath;
-        const platformName = result.payload.result.resourceMap.metadata.platformName;
-        const snapshot = { platformName, vhsHash: result.payload.result.resourceMap.vhs };
-        if (platformName === 'ios') {
-            ;
-            snapshot.vhsCompatibilityParams = {
-                UIKitLinkTimeVersionNumber: result.payload.result.metadata.UIKitLinkTimeVersionNumber,
-                UIKitRunTimeVersionNumber: result.payload.result.metadata.UIKitRunTimeVersionNumber,
-            };
+                logger,
+            });
+            const result = await response.json();
+            brokerUrl = result.nextPath;
+            const platformName = result.payload.result.resourceMap.metadata.platformName;
+            const snapshot = { platformName, vhsHash: result.payload.result.resourceMap.vhs };
+            if (platformName === 'ios') {
+                ;
+                snapshot.vhsCompatibilityParams = {
+                    UIKitLinkTimeVersionNumber: result.payload.result.metadata.UIKitLinkTimeVersionNumber,
+                    UIKitRunTimeVersionNumber: result.payload.result.metadata.UIKitRunTimeVersionNumber,
+                };
+            }
+            else if (platformName === 'android') {
+                ;
+                snapshot.vhsType = 'android-x';
+            }
+            return Array(settings.renderers.length).fill(snapshot);
         }
-        else if (platformName === 'android') {
-            ;
-            snapshot.vhsType = 'android-x';
+        catch (error) {
+            if (error.nextPath)
+                brokerUrl = error.nextPath;
+            throw error;
         }
-        return Array(settings.renderers.length).fill(snapshot);
     }
 }
 exports.makeNMLRequests = makeNMLRequests;

package/dist/take-screenshots.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTakeScreenshots = void 0;
+function makeTakeScreenshots({ requests, logger: defaultLogger }) {
+    return async function takeScreenshots({ settings, logger = defaultLogger, }) {
+        return requests.takeScreenshots({ settings, logger });
+    };
+}
+exports.makeTakeScreenshots = makeTakeScreenshots;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applitools/nml-client",
-  "version": "1.5.8",
+  "version": "1.5.9",
   "description": "Client to integrate the SDKs to the Native Mobile Library (NML)",
   "homepage": "https://applitools.com",
   "bugs": {
@@ -36,12 +36,12 @@
     "test": "run --top-level mocha './test/**/*.spec.ts' --parallel --jobs ${MOCHA_JOBS:-15}"
   },
   "dependencies": {
-    "@applitools/logger": "2.0.8",
-    "@applitools/req": "1.5.3",
-    "@applitools/utils": "1.5.1"
+    "@applitools/logger": "2.0.9",
+    "@applitools/req": "1.5.4",
+    "@applitools/utils": "1.5.2"
   },
   "devDependencies": {
-    "@applitools/spec-driver-webdriver": "^1.0.42",
+    "@applitools/spec-driver-webdriver": "^1.0.43",
     "@applitools/test-server": "^1.2.2",
     "@applitools/test-utils": "^1.5.17",
     "@types/node": "^12.20.55",

package/types/client.d.ts

@@ -1,7 +1,6 @@
-import type { NMLClient } from './types';
+import type { NMLClient, NMLClientSettings } from './types';
 import { type Logger } from '@applitools/logger';
-import { type NMLRequestsConfig } from './server/requests';
-export declare function makeNMLClient({ config, logger: defaultLogger, }: {
-    config: NMLRequestsConfig;
+export declare function makeNMLClient({ settings, logger: defaultLogger, }: {
+    settings: NMLClientSettings;
     logger?: Logger;
 }): NMLClient;

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

@@ -1,9 +1,6 @@
+import type { BrokerServerSettings } from '../types';
 import { type Logger } from '@applitools/logger';
-import { type Req, type Options, type Proxy } from '@applitools/req';
-export type ReqBrokerConfig = {
-    proxy?: Proxy;
-    agentId?: string;
-};
+import { type Req, type Options } from '@applitools/req';
 export type ReqBrokerOptions = Options & {
     name: string;
     body: {
@@ -15,7 +12,7 @@ export type ReqBrokerOptions = Options & {
     logger?: Logger;
 };
 export type ReqBroker = Req<ReqBrokerOptions>;
-export declare function makeReqBroker({ config, logger }: {
-    config: ReqBrokerConfig;
+export declare function makeReqBroker({ settings, logger }: {
+    settings: Partial<BrokerServerSettings>;
     logger?: Logger;
 }): Req<ReqBrokerOptions>;

package/types/server/requests.d.ts

@@ -1,20 +1,19 @@
-import type { ScreenshotSettings, Screenshot, SnapshotSettings, IOSSnapshot, AndroidSnapshot } from '../types';
+import type { BrokerServerSettings, ScreenshotSettings, Screenshot, SnapshotSettings, IOSSnapshot, AndroidSnapshot } from '../types';
 import { type Logger } from '@applitools/logger';
-import { type ReqBrokerConfig } from './req-broker';
 export interface NMLRequests {
-    takeScreenshot(options: {
+    getSupportedRenderEnvironments(options: {
+        logger?: Logger;
+    }): Promise<Record<string, any>>;
+    takeScreenshots(options: {
         settings: ScreenshotSettings;
         logger?: Logger;
-    }): Promise<Screenshot>;
+    }): Promise<Screenshot[]>;
     takeSnapshots<TSnapshot extends IOSSnapshot | AndroidSnapshot = IOSSnapshot | AndroidSnapshot>(options: {
         settings: SnapshotSettings;
         logger?: Logger;
     }): Promise<TSnapshot[]>;
 }
-export type NMLRequestsConfig = ReqBrokerConfig & {
-    brokerUrl: string;
-};
-export declare function makeNMLRequests({ config, logger: defaultLogger, }: {
-    config: NMLRequestsConfig;
+export declare function makeNMLRequests({ settings, logger: defaultLogger, }: {
+    settings: BrokerServerSettings;
     logger: Logger;
 }): NMLRequests;

package/types/{take-screenshot.d.ts → take-screenshots.d.ts}

@@ -5,8 +5,8 @@ type Options = {
     requests: NMLRequests;
     logger: Logger;
 };
-export declare function makeTakeScreenshot({ requests, logger: defaultLogger }: Options): ({ settings, logger, }: {
+export declare function makeTakeScreenshots({ requests, logger: defaultLogger }: Options): ({ settings, logger, }: {
     settings: ScreenshotSettings;
     logger?: Logger | undefined;
-}) => Promise<Screenshot>;
+}) => Promise<Screenshot[]>;
 export {};

package/types/take-snapshots.d.ts

@@ -5,7 +5,7 @@ type Options = {
     requests: NMLRequests;
     logger: Logger;
 };
-export declare function makeTakeSnapshots({ requests, logger: defaultLogger }: Options): <TSnapshot extends AndroidSnapshot | IOSSnapshot = AndroidSnapshot | IOSSnapshot>({ settings, logger, }: {
+export declare function makeTakeSnapshots({ requests, logger: defaultLogger }: Options): <TSnapshot extends IOSSnapshot | AndroidSnapshot = IOSSnapshot | AndroidSnapshot>({ settings, logger, }: {
     settings: SnapshotSettings;
     logger?: Logger | undefined;
 }) => Promise<TSnapshot[]>;

package/types/types.d.ts

@@ -1,6 +1,53 @@
 /// <reference types="node" />
 import type { Size, Location, Region } from '@applitools/utils';
 import { type Logger } from '@applitools/logger';
+import { type Proxy } from '@applitools/req';
+export interface NMLClient {
+    takeScreenshots(options: {
+        settings: ScreenshotSettings;
+        logger?: Logger;
+    }): Promise<Screenshot[]>;
+    takeSnapshots<TSnapshot extends IOSSnapshot | AndroidSnapshot = IOSSnapshot | AndroidSnapshot>(options: {
+        settings: SnapshotSettings;
+        logger?: Logger;
+    }): Promise<TSnapshot[]>;
+    getSupportedRenderEnvironments(options: {
+        logger?: Logger;
+    }): Promise<Record<string, any>>;
+}
+export interface BrokerServerSettings {
+    brokerUrl: string;
+    renderEnvironmentsUrl: string;
+    agentId?: string;
+    proxy?: Proxy;
+    useDnsCache?: boolean;
+}
+export type NMLClientSettings = BrokerServerSettings;
+export interface IOSDeviceRenderer {
+    iosDeviceInfo: {
+        deviceName: string;
+        version?: string;
+        screenOrientation?: string;
+    };
+}
+export interface AndroidDeviceRenderer {
+    androidDeviceInfo: {
+        deviceName: string;
+        version?: string;
+        screenOrientation?: string;
+    };
+}
+export interface EnvironmentRenderer {
+    environment: any;
+}
+export type Renderer = IOSDeviceRenderer | AndroidDeviceRenderer | EnvironmentRenderer;
+export interface RenderEnvironment {
+    os: string;
+    deviceName: string;
+    viewportSize: Size;
+    renderEnvironmentId: string;
+    renderer: Renderer;
+}
 export type Selector = string | {
     selector: string;
     type?: string;
@@ -8,11 +55,9 @@ export type Selector = string | {
     frame?: Selector;
 };
 export type ScreenshotSettings = {
+    renderers: Renderer[];
+    webview?: boolean | string;
     region?: Region | Selector;
-    debugImages?: {
-        path: string;
-        prefix?: string;
-    };
     fully?: boolean;
     scrollRootElement?: Selector;
     stitchMode?: 'Scroll' | 'CSS' | 'Resize';
@@ -29,9 +74,8 @@ export type ScreenshotSettings = {
         waitingTime?: number;
         maxAmountToScroll?: number;
     };
-    webview?: boolean | string;
-    name?: string;
     selectorsToFindRegionsFor?: Selector[];
+    name?: string;
 };
 export type Screenshot = {
     image: Buffer | string;
@@ -42,12 +86,14 @@ export type Screenshot = {
     locationInViewport?: Location;
     locationInView?: Location;
     fullViewSize?: Size;
+    calculatedRegions?: Region[];
+    renderEnvironment: RenderEnvironment;
 };
 export type SnapshotSettings = {
-    name?: string;
-    renderers: any[];
+    renderers: Renderer[];
     resourceSeparation?: boolean;
     waitBeforeCapture?: number;
+    name?: string;
 };
 export type AndroidSnapshot = {
     platformName: 'android';
@@ -67,13 +113,3 @@ export type IOSSnapshot = {
         contentType: string;
     };
 };
-export interface NMLClient {
-    takeScreenshot(options: {
-        settings: ScreenshotSettings;
-        logger?: Logger;
-    }): Promise<Screenshot>;
-    takeSnapshots<TSnapshot extends IOSSnapshot | AndroidSnapshot = IOSSnapshot | AndroidSnapshot>(options: {
-        settings: SnapshotSettings;
-        logger?: Logger;
-    }): Promise<TSnapshot[]>;
-}

package/dist/take-screenshot.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeTakeScreenshot = void 0;
-function makeTakeScreenshot({ requests, logger: defaultLogger }) {
-    return async function takeScreenshot({ settings, logger = defaultLogger, }) {
-        return requests.takeScreenshot({ settings, logger });
-    };
-}
-exports.makeTakeScreenshot = makeTakeScreenshot;