@applitools/core 4.56.2 → 4.57.0

package/dist/universal/spec-driver.js

@@ -1,189 +0,0 @@
-"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

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

package/dist/universal/ws-server.js

@@ -1,66 +0,0 @@
-"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/types/cli/cli.d.ts

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

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

@@ -1,9 +0,0 @@
-/// <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

@@ -1,18 +0,0 @@
-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

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

package/types/universal/refer.d.ts

@@ -1,8 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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 {};

package/types/universal/types.d.ts

@@ -1,205 +0,0 @@
-import type { Size, Region } from '@applitools/utils';
-import type { Emitter, Listener, Client, Server } from '@applitools/socket';
-import type { SpecType, DriverInfo, Cookie, WaitOptions } from '@applitools/driver';
-import type * as MainCore from '../types';
-/**
- * Wraps the type with a ref if it vas to be refed
- */
-type Refify<TValue> = TValue extends string | number | boolean | null | undefined ? TValue : TValue extends Array<infer TItem> ? Refify<TItem>[] : Extract<TValue[keyof TValue], (...args: any) => any> extends never ? TValue : Ref<TValue>;
-/**
- * Creates universalized object out of an ordinary interface:
- * - Filters out properties that are not of async function type
- * - Adds domain to the method names (`Domain.methodName`)
- * - Keep only first (`options`) argument of the methods
- * - Introduces additional option to the methods with a ref of the current instance
- * - Refifies return values of the methods
- */
-type Universalize<TTarget extends Record<string, any>, TDomain extends string, TRefKey extends string = never> = {
-    [TKey in keyof TTarget as NonNullable<TTarget[TKey]> extends (...args: any[]) => Promise<any> ? `${TDomain}.${TKey & string}` : never]: NonNullable<TTarget[TKey]> extends (options: infer TOptions) => Promise<infer TResult> ? (options: TOptions & {
-        [TKey in TRefKey]: Ref<TTarget>;
-    }) => Promise<Refify<TResult>> : never;
-};
-export type Ref<TValue = never> = {
-    'applitools-ref-id': string;
-    type?: string;
-};
-export type ClientSocket<TSpec extends SpecType, TType extends 'classic' | 'ufg'> = unknown & Emitter<Universalize<UniversalCore<TSpec, TType>, 'Core'>> & Client<Universalize<MainCore.Core<TSpec, TType>, 'Core'>> & Client<Universalize<MainCore.EyesManager<TSpec, TType>, 'EyesManager', 'manager'>> & Client<Universalize<MainCore.Eyes<TSpec, TType>, 'Eyes', 'eyes'>> & Client<Universalize<UniversalDebug<TSpec>, 'Debug'>> & Server<Universalize<UniversalSpecDriver<TSpec>, 'Driver'>>;
-export type ServerSocket<TSpec extends SpecType, TType extends 'classic' | 'ufg'> = unknown & Listener<Universalize<UniversalCore<TSpec, TType>, 'Core'>> & Emitter<Universalize<UniversalLogger, 'Logger'>> & Server<Universalize<MainCore.Core<TSpec, TType>, 'Core'>> & Server<Universalize<MainCore.EyesManager<TSpec, TType>, 'EyesManager', 'manager'>> & Server<Universalize<MainCore.Eyes<TSpec, TType>, 'Eyes', 'eyes'>> & Server<Universalize<UniversalDebug<TSpec>, 'Debug'>> & Client<Universalize<UniversalSpecDriver<TSpec>, 'Driver'>>;
-export interface UniversalCore<TSpec extends SpecType, TType extends 'classic' | 'ufg'> {
-    makeCore(options: {
-        spec: 'webdriver' | (keyof UniversalSpecDriver<TSpec>)[];
-        agentId: string;
-        environment?: Record<string, any>;
-        cwd: string;
-    }): Promise<MainCore.Core<TSpec, TType>>;
-}
-export interface UniversalLogger {
-    log(options: {
-        level: string;
-        message: string;
-    }): Promise<void>;
-}
-export interface UniversalDebug<TSpec extends SpecType> {
-    getHistory(): Promise<any>;
-    checkSpecDriver(options: {
-        driver: TSpec['driver'];
-        commands: (keyof UniversalSpecDriver<TSpec>)[];
-    }): Promise<any>;
-}
-/**
- * Ideally would be transform SpecDriver type to the type with single object argument
- * but typescript doesn't have a possibility to convert named tuples to object types at the moment
- */
-export interface UniversalSpecDriver<T extends SpecType> {
-    isEqualElements(options: {
-        context: T['context'];
-        element1: T['element'];
-        element2: T['element'];
-    }): Promise<boolean>;
-    executeScript(options: {
-        context: T['context'];
-        script: string;
-        arg?: any;
-    }): Promise<any>;
-    findElement(options: {
-        context: T['context'];
-        selector: T['selector'];
-        parent?: T['element'];
-    }): Promise<T['element'] | null>;
-    findElements(options: {
-        context: T['context'];
-        selector: T['selector'];
-        parent?: T['element'];
-    }): Promise<T['element'][]>;
-    waitForSelector(options: {
-        context: T['context'];
-        selector: T['selector'];
-        parent?: T['element'];
-        options?: WaitOptions;
-    }): Promise<T['element'] | null>;
-    getElementRegion(options: {
-        context: T['context'];
-        element: T['element'];
-    }): Promise<Region>;
-    getElementAttribute(options: {
-        context: T['context'];
-        element: T['element'];
-        attr: string;
-    }): Promise<string>;
-    setElementText(options: {
-        context: T['context'];
-        element: T['element'];
-        text: string;
-    }): Promise<void>;
-    getElementText(options: {
-        context: T['context'];
-        element: T['element'];
-    }): Promise<string>;
-    hover(options: {
-        context: T['context'];
-        element: T['element'];
-    }): Promise<void>;
-    click(options: {
-        context: T['context'];
-        element: T['element'];
-    }): Promise<void>;
-    mainContext(options: {
-        context: T['context'];
-    }): Promise<T['context']>;
-    parentContext(options: {
-        context: T['context'];
-    }): Promise<T['context']>;
-    childContext(options: {
-        context: T['context'];
-        element: T['element'];
-    }): Promise<T['context']>;
-    getDriverInfo(options: {
-        driver: T['driver'];
-    }): Promise<DriverInfo>;
-    getCapabilities(options: {
-        driver: T['driver'];
-    }): Promise<Record<string, any>>;
-    setWindowSize(options: {
-        driver: T['driver'];
-        size: Size;
-    }): Promise<void>;
-    getWindowSize(options: {
-        driver: T['driver'];
-    }): Promise<Size>;
-    setViewportSize(options: {
-        driver: T['driver'];
-        size: Size;
-    }): Promise<void>;
-    getViewportSize(options: {
-        driver: T['driver'];
-    }): Promise<Size>;
-    getSystemBars(options: {
-        driver: T['driver'];
-    }): Promise<{
-        statusBar: {
-            visible: boolean;
-            x: number;
-            y: number;
-            height: number;
-            width: number;
-        };
-        navigationBar: {
-            visible: boolean;
-            x: number;
-            y: number;
-            height: number;
-            width: number;
-        };
-    }>;
-    getOrientation(options: {
-        driver: T['driver'];
-    }): Promise<'portrait' | 'landscape' | 'portrait-secondary' | 'landscape-secondary'>;
-    setOrientation(options: {
-        driver: T['driver'];
-        orientation: 'portrait' | 'landscape' | 'portrait-secondary' | 'landscape-secondary';
-    }): Promise<void>;
-    getCookies(options: {
-        driver: T['driver'] | T['context'];
-        context?: boolean;
-    }): Promise<Cookie[]>;
-    getTitle(options: {
-        driver: T['driver'];
-    }): Promise<string>;
-    getUrl(options: {
-        driver: T['driver'];
-    }): Promise<string>;
-    takeScreenshot(options: {
-        driver: T['driver'];
-    }): Promise<string>;
-    performAction(options: {
-        driver: T['driver'];
-        steps: any[];
-    }): Promise<void>;
-    visit(options: {
-        driver: T['driver'];
-        url: string;
-    }): Promise<void>;
-    getCurrentWorld(options: {
-        driver: T['driver'];
-    }): Promise<string>;
-    getWorlds(options: {
-        driver: T['driver'];
-    }): Promise<string[]>;
-    switchWorld(options: {
-        driver: T['driver'];
-        name: string;
-    }): Promise<void>;
-    reload(options: {
-        driver: T['driver'];
-    }): Promise<void>;
-    isUserFunction(ref: any): Promise<boolean>;
-    executeUserFunction(userFunction: Ref): Promise<any>;
-    executeBrowserCommands(options: {
-        driver?: T['driver'];
-        commands: any[];
-    }): Promise<any>;
-    bringToFront(options: {
-        driver: T['driver'];
-    }): Promise<void>;
-}
-export {};

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

@@ -1,15 +0,0 @@
-/// <reference types="node" />
-import { Server as WsServer } from 'ws';
-import { Logger } from '@applitools/logger';
-export type ServerOptions = {
-    port?: number;
-    singleton?: boolean;
-    portResolutionMode?: 'next' | 'random' | 'lazy';
-    debug?: boolean;
-    key?: string | Buffer;
-    cert?: string | Buffer;
-};
-export declare function makeServer(options: ServerOptions | undefined, logger: Logger): Promise<{
-    server?: WsServer;
-    port: number;
-}>;