@applitools/core 4.59.0 → 4.59.1-debug.1

package/dist/universal/refer.js

@@ -0,0 +1,67 @@
+"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.makeRefer = void 0;
+const utils = __importStar(require("@applitools/utils"));
+const REF_ID = 'applitools-ref-id';
+function makeRefer() {
+    const store = new Map();
+    const relation = new Map();
+    return { isRef, ref, deref, destroy };
+    function isRef(ref) {
+        return Boolean(ref[REF_ID]);
+    }
+    function ref(value, parentRef) {
+        const ref = utils.general.guid();
+        store.set(ref, value);
+        if (parentRef) {
+            let childRefs = relation.get(parentRef[REF_ID]);
+            if (!childRefs) {
+                childRefs = new Set();
+                relation.set(parentRef[REF_ID], childRefs);
+            }
+            childRefs.add({ [REF_ID]: ref });
+        }
+        return { [REF_ID]: ref };
+    }
+    function deref(ref) {
+        if (isRef(ref)) {
+            return store.get(ref[REF_ID]);
+        }
+        else {
+            return ref;
+        }
+    }
+    function destroy(ref) {
+        if (!isRef(ref))
+            return;
+        const childRefs = relation.get(ref[REF_ID]);
+        if (childRefs) {
+            childRefs.forEach(childRef => destroy(childRef));
+        }
+        store.delete(ref[REF_ID]);
+    }
+}
+exports.makeRefer = makeRefer;

package/dist/universal/spec-driver.js

@@ -0,0 +1,189 @@
+"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.makeSpec = void 0;
+const utils = __importStar(require("@applitools/utils"));
+function makeSpec({ socket, spec, }) {
+    const commands = {
+        isDriver(driver) {
+            return utils.types.has(driver, 'applitools-ref-id');
+        },
+        isContext(context) {
+            return utils.types.has(context, 'applitools-ref-id');
+        },
+        isElement(element) {
+            return utils.types.has(element, ['applitools-ref-id', 'type']) && element.type === 'element';
+        },
+        isSelector(selector) {
+            return ((utils.types.has(selector, ['applitools-ref-id', 'type']) && selector.type === 'selector') ||
+                utils.types.isString(selector) ||
+                (utils.types.isPlainObject(selector) &&
+                    utils.types.has(selector, 'selector') &&
+                    (utils.types.isString(selector.selector) || utils.types.has(selector, 'applitools-ref-id'))));
+        },
+        async isEqualElements(context, element1, element2) {
+            return socket.request('Driver.isEqualElements', { context, element1, element2 });
+        },
+        isStaleElementError(error) {
+            return error === null || error === void 0 ? void 0 : error.isStaleElementError;
+        },
+        extractContext(driver) {
+            return driver.context;
+        },
+        extractSelector(element) {
+            return element.selector;
+        },
+        async executeScript(context, script, arg) {
+            return socket.request('Driver.executeScript', { context, script: script.toString(), arg });
+        },
+        async findElement(context, selector, parent) {
+            return socket.request('Driver.findElement', { context, selector, parent });
+        },
+        async findElements(context, selector, parent) {
+            return socket.request('Driver.findElements', { context, selector, parent });
+        },
+        async waitForSelector(context, selector, parent, options) {
+            return socket.request('Driver.waitForSelector', { context, selector, parent, options });
+        },
+        async getElementText(context, element) {
+            return socket.request('Driver.getElementText', { context, element });
+        },
+        async setElementText(context, element, text) {
+            return socket.request('Driver.setElementText', { context, element, text });
+        },
+        async getElementRegion(context, element) {
+            return socket.request('Driver.getElementRegion', { context, element });
+        },
+        async getElementAttribute(context, element, attr) {
+            return socket.request('Driver.getElementAttribute', { context, element, attr });
+        },
+        async hover(context, element) {
+            return socket.request('Driver.hover', { context, element });
+        },
+        async click(context, element) {
+            return socket.request('Driver.click', { context, element });
+        },
+        async mainContext(context) {
+            return socket.request('Driver.mainContext', { context });
+        },
+        async parentContext(context) {
+            return socket.request('Driver.parentContext', { context });
+        },
+        async childContext(context, element) {
+            return socket.request('Driver.childContext', { context, element });
+        },
+        async getCapabilities(driver) {
+            return socket.request('Driver.getCapabilities', { driver });
+        },
+        async getDriverInfo(driver) {
+            return socket.request('Driver.getDriverInfo', { driver });
+        },
+        async getWindowSize(driver) {
+            return socket.request('Driver.getWindowSize', { driver });
+        },
+        async setWindowSize(driver, size) {
+            return socket.request('Driver.setWindowSize', { driver, size });
+        },
+        async getViewportSize(driver) {
+            return socket.request('Driver.getViewportSize', { driver });
+        },
+        async setViewportSize(driver, size) {
+            return socket.request('Driver.setViewportSize', { driver, size });
+        },
+        async getSystemBars(driver) {
+            return socket.request('Driver.getSystemBars', { driver });
+        },
+        async getOrientation(driver) {
+            return socket.request('Driver.getOrientation', { driver });
+        },
+        async setOrientation(driver, orientation) {
+            return socket.request('Driver.setOrientation', { driver, orientation });
+        },
+        async getCookies(driver, context) {
+            return socket.request('Driver.getCookies', { driver, context });
+        },
+        async getTitle(driver) {
+            return socket.request('Driver.getTitle', { driver });
+        },
+        async getUrl(driver) {
+            return socket.request('Driver.getUrl', { driver });
+        },
+        async takeScreenshot(driver) {
+            return socket.request('Driver.takeScreenshot', { driver });
+        },
+        async performAction(driver, steps) {
+            return socket.request('Driver.performAction', { driver, steps });
+        },
+        async visit(driver, url) {
+            return socket.request('Driver.visit', { driver, url });
+        },
+        async getCurrentWorld(driver) {
+            return socket.request('Driver.getCurrentWorld', { driver });
+        },
+        async getWorlds(driver) {
+            return socket.request('Driver.getWorlds', { driver });
+        },
+        async switchWorld(driver, name) {
+            return socket.request('Driver.switchWorld', { driver, name });
+        },
+        async reload(driver) {
+            return socket.request('Driver.reload', { driver });
+        },
+        async isUserFunction(ref) {
+            return utils.types.has(ref, 'applitools-ref-id');
+        },
+        async executeUserFunction(userFunction) {
+            return socket.request('Driver.executeUserFunction', userFunction);
+        },
+        async executeBrowserCommands(driver, commands) {
+            return socket.request('Driver.executeBrowserCommands', { driver, commands });
+        },
+        async bringToFront(driver) {
+            return socket.request('Driver.bringToFront', { driver });
+        },
+    };
+    // add default commands to spec (if not already there) such as `isUserFunction`
+    spec = addDefaultCommands(spec);
+    return spec.reduce((spec, name) => {
+        return Object.assign(spec, { [name]: commands[name] });
+    }, {});
+}
+exports.makeSpec = makeSpec;
+// returns a new clone of the spec commands array with additional commands universal can support even if the spec doesn't
+function addDefaultCommands(spec) {
+    const defaultCommands = [
+        {
+            command: 'isUserFunction',
+            dependsOn: ['executeUserFunction'],
+        },
+    ];
+    const commands = spec.slice();
+    defaultCommands.forEach(({ command, dependsOn }) => {
+        if (!commands.includes(command) && dependsOn.every(dep => commands.includes(dep))) {
+            commands.push(command);
+        }
+    });
+    return commands;
+}

package/dist/universal/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/universal/ws-server.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeServer = void 0;
+const http_1 = require("http");
+const https_1 = require("https");
+const ws_1 = require("ws");
+const { name, version } = require('../../package.json');
+const TOKEN_HEADER = 'x-eyes-universal-token';
+const TOKEN = `${name}@${version}`;
+async function makeServer(options = {}, logger) {
+    const { port = 21077, singleton = true, debug = false, portResolutionMode = 'next', cert, key } = options;
+    const secure = Boolean(cert && key);
+    const http = secure ? new https_1.Server({ cert, key }) : new http_1.Server();
+    http.on('request', (request, response) => {
+        if (request.url === '/handshake') {
+            const token = debug ? request.headers[TOKEN_HEADER] : TOKEN;
+            if (request.headers[TOKEN_HEADER] === token) {
+                response.writeHead(200, { [TOKEN_HEADER]: token });
+            }
+            else {
+                response.writeHead(400);
+            }
+            response.end();
+        }
+    });
+    const hostName = process.env.APPLITOOLS_UNIVERSAL_HOST_NAME || 'localhost';
+    http.listen(port, hostName);
+    return new Promise((resolve, reject) => {
+        http.on('listening', () => {
+            const ws = new ws_1.Server({ server: http, path: '/eyes', maxPayload: 256 * 1024 * 1024 });
+            ws.on('close', () => {
+                logger.log('Core universal server is closed');
+                http.close();
+            });
+            ws.on('error', err => {
+                logger.log('Core universal server error', err);
+            });
+            resolve({ server: ws, port: http.address().port });
+        });
+        http.on('error', async (err) => {
+            if (portResolutionMode !== 'lazy' && err.code === 'EADDRINUSE') {
+                if (singleton && (await isHandshakable({ port, secure }))) {
+                    return resolve({ port });
+                }
+                else {
+                    return resolve(await makeServer({ ...options, port: portResolutionMode === 'next' ? port + 1 : 0 }, logger));
+                }
+            }
+            reject(err);
+        });
+    });
+}
+exports.makeServer = makeServer;
+async function isHandshakable({ port, secure }) {
+    const request = secure ? https_1.request : http_1.request;
+    return new Promise(resolve => {
+        const handshake = request(`${secure ? 'https' : 'http'}://localhost:${port}/handshake`, {
+            headers: { [TOKEN_HEADER]: TOKEN },
+        });
+        handshake.on('response', ({ statusCode, headers }) => {
+            resolve(statusCode === 200 && headers[TOKEN_HEADER] === TOKEN);
+        });
+        handshake.on('error', () => resolve(false));
+        handshake.end();
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applitools/core",
-  "version": "4.59.0",
+  "version": "4.59.1-debug.1",
   "homepage": "https://applitools.com",
   "bugs": {
     "url": "https://github.com/applitools/eyes.sdk.javascript1/issues"
@@ -61,17 +61,17 @@
   },
   "dependencies": {
     "@applitools/core-base": "1.32.4",
-    "@applitools/dom-capture": "11.6.13",
-    "@applitools/dom-snapshot": "4.16.2",
+    "@applitools/dom-capture": "11.7.0",
+    "@applitools/dom-snapshot": "4.16.3",
     "@applitools/driver": "1.25.4",
     "@applitools/ec-client": "1.12.24",
     "@applitools/logger": "2.2.10",
-    "@applitools/nml-client": "1.11.22",
+    "@applitools/nml-client": "1.11.23",
     "@applitools/req": "1.9.2",
     "@applitools/screenshoter": "3.12.17",
     "@applitools/snippets": "2.8.1",
     "@applitools/socket": "1.3.11",
-    "@applitools/ufg-client": "1.20.1",
+    "@applitools/ufg-client": "1.20.2",
     "@applitools/utils": "1.14.3",
     "abort-controller": "3.0.0",
     "chalk": "4.1.2",
@@ -113,5 +113,6 @@
       "selenium-webdriver>ws>bufferutil": false,
       "selenium-webdriver>ws>utf-8-validate": false
     }
-  }
+  },
+  "stableVersion": "4.59.1-debug.0"
 }

package/types/automation/types.d.ts

@@ -158,6 +158,8 @@ export interface ScreenshotSettings<TSpec extends SpecType> extends BaseCore.Ima
     sendDom?: boolean;
     captureStatusBar?: boolean;
     mobileOptions?: MobileOptions;
+    /** @internal */
+    skipRootHtmlResource?: boolean;
 }
 export type LocateSettings<TLocator extends string, TSpec extends SpecType> = BaseCore.LocateSettings<TLocator, Region | ElementReference<TSpec>> & ScreenshotSettings<TSpec>;
 export type LocateTextSettings<TPattern extends string, TSpec extends SpecType> = BaseCore.LocateTextSettings<TPattern, Region | ElementReference<TSpec>> & ScreenshotSettings<TSpec>;

package/types/cli/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

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

@@ -32,6 +32,7 @@ export declare function makeCheckAndClose<TSpec extends SpecType>({ eyes, target
             domains?: string[] | undefined;
         }) | undefined;
         headers?: Record<string, string> | undefined;
+        skipRootHtmlResource?: boolean | undefined;
     } & import("@applitools/core-base").CloseSettings & {
         environments?: Environment[] | undefined;
     }) | undefined;

package/types/ufg/types.d.ts

@@ -67,6 +67,8 @@ export type SnapshotSettings<TSpec extends SpecType> = AutomationCore.CheckSetti
         domains?: string[];
     };
     headers?: Record<string, string>;
+    /** @internal */
+    skipRootHtmlResource?: boolean;
 };
 export type CheckSettings<TSpec extends SpecType> = SnapshotSettings<TSpec>;
 export type SafeCheckSettings = CheckSettings<SpecType<never, never, UFGSelector, never, never>>;

package/types/ufg/utils/take-dom-snapshot.d.ts

@@ -31,6 +31,8 @@ export type RawDomSnapshot = {
 export type DomSnapshotSettings<TSpec extends SpecType> = {
     disableBrowserFetching?: boolean;
     skipResources?: string[];
+    /** @internal */
+    skipRootHtmlResource?: boolean;
     fetchConcurrency?: number;
     chunkByteLength?: number;
     executionTimeout?: number;

package/types/ufg/utils/to-generated-selectors.d.ts

@@ -1,13 +1,14 @@
 import { type SpecType, type ElementReference } from '@applitools/driver';
 import type { Logger } from '@applitools/logger';
 import { type Selector as UFGSelector } from '@applitools/ufg-client';
-export declare function toGeneratedSelectors<TSpec extends SpecType>({ elementReferences, logger, }: {
+export declare function toGeneratedSelectors<TSpec extends SpecType>({ elementReferences, logger, logDeprecations, }: {
     elementReferences: {
         target?: ElementReference<TSpec>;
         scrolling?: ElementReference<TSpec>;
         calculate?: ElementReference<TSpec>[];
     };
     logger: Logger;
+    logDeprecations: (...args: string[]) => void;
 }): {
     elementReferencesToMark: (string | TSpec["element"] | TSpec["secondary"]["element"] | TSpec["selector"] | TSpec["secondary"]["selector"] | {
         selector: string | TSpec["selector"] | TSpec["secondary"]["selector"];

package/types/universal/core-server-process.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import { type Options } from './core-server';
+import { type ForkOptions } from 'child_process';
+export declare function makeCoreServerProcess(options: Options & {
+    forkOptions?: ForkOptions;
+}): Promise<{
+    port: number;
+    close: () => void;
+}>;

package/types/universal/core-server.d.ts

@@ -0,0 +1,18 @@
+import { type ServerOptions } from './ws-server';
+import { type Logger } from '@applitools/logger';
+export type Options = ServerOptions & {
+    environment?: Record<string, any>;
+    agentIdPrefix?: string;
+    debug?: boolean;
+    shutdownMode?: 'lazy' | 'stdin';
+    idleTimeout?: number;
+    printStdout?: boolean;
+    isProcess?: boolean;
+    maskLog?: boolean;
+    logger?: Logger;
+};
+export declare function makeCoreServer({ environment: defaultEnvironment, agentIdPrefix, debug, shutdownMode, idleTimeout, // 15min
+printStdout, isProcess, maskLog, logger, ...handlerOptions }?: Options): Promise<{
+    port: number;
+    close?: () => void;
+}>;

package/types/universal/history.d.ts

@@ -0,0 +1,2 @@
+import { type Socket } from '@applitools/socket';
+export declare function withHistory<TSocket extends Socket>(socket: TSocket): () => Record<string, any>;

package/types/universal/refer.d.ts

@@ -0,0 +1,8 @@
+import type { Ref } from './types';
+export interface Refer {
+    isRef<TValue = any>(ref: any): ref is Ref<TValue>;
+    ref<TValue>(value: TValue, parentRef?: Ref<unknown>): Ref<TValue>;
+    deref<TValue>(ref: Ref<TValue>): TValue;
+    destroy(ref: Ref<any>): void;
+}
+export declare function makeRefer(): Refer;

package/types/universal/spec-driver.d.ts

@@ -0,0 +1,15 @@
+import type { Ref, ServerSocket, UniversalSpecDriver } from './types';
+import type { SpecType, SpecDriver as BaseSpecDriver, CommonSelector } from '@applitools/driver';
+export type Driver = Ref;
+export type Context = Ref;
+export type Element = Ref;
+export type Selector = string | CommonSelector | Ref;
+export type UserFunction = Ref;
+export type PrimarySpecType = SpecType<Driver, Context, Element, Selector, never, UserFunction>;
+export type SpecDriver = BaseSpecDriver<PrimarySpecType>;
+type CommandName = keyof UniversalSpecDriver<PrimarySpecType>;
+export declare function makeSpec({ socket, spec, }: {
+    socket: ServerSocket<PrimarySpecType, any>;
+    spec: CommandName[];
+}): SpecDriver;
+export {};