@applitools/core 2.5.2 → 2.5.3-legacy.1

package/dist/make-manager.js

@@ -40,7 +40,10 @@ function makeMakeManager({ spec, concurrency: defaultConcurrency = utils.general
         (_c = (_f = settings.batch).id) !== null && _c !== void 0 ? _c : (_f.id = (_d = utils.general.getEnvValue('BATCH_ID')) !== null && _d !== void 0 ? _d : `generated-${utils.general.guid()}`);
         (_e = settings.agentId) !== null && _e !== void 0 ? _e : (settings.agentId = type === 'ufg' ? defaultAgentId === null || defaultAgentId === void 0 ? void 0 : defaultAgentId.replace(/(\/\d)/, '.visualgrid$1') : defaultAgentId);
         base !== null && base !== void 0 ? base : (base = (0, core_base_1.makeCore)({ agentId: settings.agentId, concurrency: settings.concurrency, cwd, logger }));
-        const cores = { ufg: (0, core_2.makeCore)({ spec, base, logger }), classic: (0, core_1.makeCore)({ spec, base, logger }) };
+        const cores = {
+            ufg: (0, core_2.makeCore)({ spec, base, fetchConcurrency: settings.fetchConcurrency, logger }),
+            classic: (0, core_1.makeCore)({ spec, base, logger }),
+        };
         const storage = [];
         return {
             openEyes: utils.general.wrap((0, open_eyes_1.makeOpenEyes)({ type, batch: settings.batch, spec, core, cores, logger }), async (openEyes, options) => {

package/dist/open-eyes.js

@@ -61,7 +61,7 @@ function makeOpenEyes({ type: defaultType = 'classic', concurrency, batch, core,
         if (account.ecEnabled) {
             const environment = await (driver === null || driver === void 0 ? void 0 : driver.getEnvironment());
             (_r = settings.properties) !== null && _r !== void 0 ? _r : (settings.properties = []);
-            settings.properties.push({ name: 'Execution cloud', value: (environment === null || environment === void 0 ? void 0 : environment.isEC) ? 'Yes' : 'No' });
+            settings.properties.push({ name: 'Execution Cloud', value: (environment === null || environment === void 0 ? void 0 : environment.isEC) ? 'Yes' : 'No' });
         }
         core.logEvent({
             settings: {

package/dist/ufg/core.js

@@ -35,7 +35,7 @@ const get_ufg_client_1 = require("./get-ufg-client");
 const get_nml_client_1 = require("./get-nml-client");
 const open_eyes_1 = require("./open-eyes");
 const utils = __importStar(require("@applitools/utils"));
-function makeCore({ concurrency, spec, clients, base, agentId = 'core-ufg', cwd = process.cwd(), logger: defaultLogger, }) {
+function makeCore({ concurrency, spec, clients, base, fetchConcurrency, agentId = 'core-ufg', cwd = process.cwd(), logger: defaultLogger, }) {
     var _a;
     const logger = (_a = defaultLogger === null || defaultLogger === void 0 ? void 0 : defaultLogger.extend({ label: 'core-ufg' })) !== null && _a !== void 0 ? _a : (0, logger_1.makeLogger)({ label: 'core-ufg' });
     logger.log(`Core ufg is initialized ${base ? 'with' : 'without'} custom base core`);
@@ -49,7 +49,7 @@ function makeCore({ concurrency, spec, clients, base, agentId = 'core-ufg', cwd
             locate: (0, locate_1.makeLocate)({ spec, core, logger }),
             locateText: (0, locate_text_1.makeLocateText)({ spec, core, logger }),
             extractText: (0, extract_text_1.makeExtractText)({ spec, core, logger }),
-            getUFGClient: (0, get_ufg_client_1.makeGetUFGClient)({ client: clients === null || clients === void 0 ? void 0 : clients.ufg, logger }),
+            getUFGClient: (0, get_ufg_client_1.makeGetUFGClient)({ client: clients === null || clients === void 0 ? void 0 : clients.ufg, fetchConcurrency, logger }),
             getNMLClient: (0, get_nml_client_1.makeGetNMLClient)({ client: clients === null || clients === void 0 ? void 0 : clients.nml, logger }),
             openEyes: (0, open_eyes_1.makeOpenEyes)({ spec, core, logger }),
         };

package/dist/ufg/get-ufg-client.js

@@ -26,13 +26,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeGetUFGClient = void 0;
 const ufg_client_1 = require("@applitools/ufg-client");
 const utils = __importStar(require("@applitools/utils"));
-function makeGetUFGClient({ client, logger: defaultLogger }) {
-    const getUFGClientWithCache = utils.general.cachify(getUFGClient, ([options]) => client ? 'default' : [options.config]);
+function makeGetUFGClient({ client, fetchConcurrency, logger: defaultLogger }) {
+    // we are caching by the server config, therefor if the user creates another Runner / manager with the same server config but different
+    // fetchConcurrency, it will not take any affect.
+    const getUFGClientWithCache = utils.general.cachify(getUFGClient, ([options]) => client ? 'default' : [{ ...options.config, fetchConcurrency: undefined }]);
     if (client)
         getUFGClientWithCache.setCachedValue('default', Promise.resolve(client));
     return getUFGClientWithCache;
     async function getUFGClient({ config, logger = defaultLogger }) {
-        return (0, ufg_client_1.makeUFGClient)({ config, logger });
+        return (0, ufg_client_1.makeUFGClient)({ config: { ...config, fetchConcurrency }, logger });
     }
 }
 exports.makeGetUFGClient = makeGetUFGClient;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applitools/core",
-  "version": "2.5.2",
+  "version": "2.5.3-legacy.1",
   "homepage": "https://applitools.com",
   "bugs": {
     "url": "https://github.com/applitools/eyes.sdk.javascript1/issues"
@@ -87,14 +87,14 @@
     "@applitools/snippets": "2.4.19",
     "@applitools/socket": "1.0.10",
     "@applitools/spec-driver-webdriver": "1.0.24",
-    "@applitools/ufg-client": "1.2.9",
+    "@applitools/ufg-client": "1.2.10",
     "@applitools/utils": "1.3.32",
     "@types/ws": "8.5.4",
     "abort-controller": "3.0.0",
     "chalk": "4.1.2",
     "node-fetch": "2.6.7",
     "webdriver": "7.30.0",
-    "ws": "8.12.0",
+    "ws": "8.17.1",
     "yargs": "17.6.2"
   },
   "devDependencies": {

package/types/abort.d.ts

@@ -0,0 +1,13 @@
+import type { Eyes, AbortSettings, Environment } from './types';
+import { type SpecType } from '@applitools/driver';
+import { type Logger } from '@applitools/logger';
+type Options<TSpec extends SpecType, TType extends 'classic' | 'ufg'> = {
+    eyes: Eyes<TSpec, TType>;
+    environments?: Environment[];
+    logger: Logger;
+};
+export declare function makeAbort<TSpec extends SpecType, TType extends 'classic' | 'ufg'>({ eyes, environments: defaultEnvironments, logger: mainLogger, }: Options<TSpec, TType>): ({ settings, logger, }?: {
+    settings?: AbortSettings<TType> | undefined;
+    logger?: Logger | undefined;
+}) => Promise<void>;
+export {};

package/types/automation/abort.d.ts

@@ -0,0 +1,16 @@
+import type { Eyes, AbortSettings, Environment } from './types';
+import { type Logger } from '@applitools/logger';
+import { type AbortController } from 'abort-controller';
+import { type Driver, type SpecType } from '@applitools/driver';
+type Options<TSpec extends SpecType> = {
+    eyes: Eyes<TSpec>;
+    driver?: Driver<TSpec>;
+    controller: AbortController;
+    environments?: Environment[];
+    logger: Logger;
+};
+export declare function makeAbort<TSpec extends SpecType>({ eyes, driver, controller, environments: defaultEnvironments, logger: mainLogger, }: Options<TSpec>): ({ settings, logger, }?: {
+    settings?: AbortSettings | undefined;
+    logger?: Logger | undefined;
+}) => Promise<void>;
+export {};

package/types/automation/close.d.ts

@@ -0,0 +1,14 @@
+import type { Eyes, CloseSettings, Environment } from '../ufg/types';
+import { type Logger } from '@applitools/logger';
+import { type Driver, type SpecType } from '@applitools/driver';
+type Options<TSpec extends SpecType> = {
+    eyes: Eyes<TSpec>;
+    driver?: Driver<TSpec>;
+    environments?: Environment[];
+    logger: Logger;
+};
+export declare function makeClose<TSpec extends SpecType>({ eyes, driver, environments: defaultEnvironments, logger: mainLogger, }: Options<TSpec>): ({ settings, logger, }?: {
+    settings?: CloseSettings | undefined;
+    logger?: Logger | undefined;
+}) => Promise<void>;
+export {};

package/types/automation/get-nml-client.d.ts

@@ -0,0 +1,16 @@
+import { type SpecType, type Driver } from '@applitools/driver';
+import { type Logger } from '@applitools/logger';
+import { type NMLClient, type NMLClientSettings } from '@applitools/nml-client';
+type Options = {
+    client?: NMLClient;
+    logger: Logger;
+};
+export declare function makeGetNMLClient({ client, logger: mainLogger }: Options): {
+    getNMLClient: ({ driver, settings, logger, }: {
+        driver: Driver<SpecType>;
+        settings: Omit<NMLClientSettings, 'brokerUrl'>;
+        logger: Logger;
+    }) => Promise<NMLClient>;
+    clearNMLClientCache: (driver: Driver<SpecType>) => Promise<void>;
+};
+export {};

package/types/automation/get-results.d.ts

@@ -0,0 +1,11 @@
+import type { Eyes, GetResultsSettings, TestResult } from '../ufg/types';
+import { type Logger } from '@applitools/logger';
+type Options = {
+    eyes: Eyes<any>;
+    logger: Logger;
+};
+export declare function makeGetResults({ eyes, logger: mainLogger }: Options): ({ settings, logger, }?: {
+    settings?: GetResultsSettings | undefined;
+    logger?: Logger | undefined;
+}) => Promise<TestResult[]>;
+export {};

package/types/automation/utils/report-kobiton.d.ts

@@ -0,0 +1,12 @@
+import type { Driver, SpecType } from '@applitools/driver';
+import type { Logger } from '@applitools/logger';
+type Options<TSpec extends SpecType> = {
+    driver?: Driver<TSpec>;
+    settings: {
+        batchId: string;
+        resultsUrl: string;
+    };
+    logger: Logger;
+};
+export declare function reportKobiton<TSpec extends SpecType>({ driver, settings, logger }: Options<TSpec>): Promise<void>;
+export {};

package/types/automation/utils/to-environment-key.d.ts

@@ -0,0 +1,2 @@
+import type { Environment } from '../types';
+export declare function toEnvironmentKey(environment: Environment): string;

package/types/automation/utils/uniquify-environments.d.ts

@@ -0,0 +1,2 @@
+import type { Environment } from '../types';
+export declare function uniquifyEnvironments<TEnvironment extends Environment>(environments: TEnvironment[]): TEnvironment[];

package/types/autonomous/core.d.ts

@@ -0,0 +1,19 @@
+import type { AutonomousCore } from './types';
+import { type AsyncCache, type UFGClient } from '@applitools/ufg-client';
+import { type NMLClient } from '@applitools/nml-client';
+import { type SpecType, type SpecDriver } from '@applitools/driver';
+import { type Logger } from '@applitools/logger';
+import { type Core as BaseCore } from '@applitools/core-base';
+type Options<TSpec extends SpecType> = {
+    spec?: SpecDriver<TSpec>;
+    clients?: {
+        ufg?: UFGClient;
+        nml?: NMLClient;
+    };
+    base?: BaseCore;
+    asyncCache?: AsyncCache;
+    agentId?: string;
+    logger?: Logger;
+};
+export declare function makeAutonomousCore<TSpec extends SpecType>({ spec, clients, base: defaultBase, asyncCache, agentId, logger: defaultLogger, }?: Options<TSpec>): AutonomousCore<TSpec>;
+export {};

package/types/autonomous/create-render-results.d.ts

@@ -0,0 +1,10 @@
+import type { StartedRender, RenderResult } from './types';
+import { type Logger } from '@applitools/logger';
+type Options = {
+    logger: Logger;
+};
+export declare function makeCreateRenderResults({ logger }: Options): ({ renders, rawResults, }: {
+    renders: StartedRender[];
+    rawResults: any[];
+}) => Promise<RenderResult[]>;
+export {};

package/types/autonomous/create-render-target.d.ts

@@ -0,0 +1,12 @@
+import type { Core as UFGCore } from '../ufg/types';
+import type { Snapshot, RenderTargetWithSettings } from './types';
+import { type Logger } from '@applitools/logger';
+type Options = {
+    core: UFGCore<any>;
+    logger: Logger;
+};
+export declare function makeCreateRenderTarget({ core, logger: defaultLogger }: Options): ({ snapshot, logger, }: {
+    snapshot: Snapshot;
+    logger: Logger;
+}) => Promise<RenderTargetWithSettings>;
+export {};

package/types/autonomous/get-render-results.d.ts

@@ -0,0 +1,12 @@
+import type { Core as UFGCore } from '../ufg/types';
+import type { StartedRender, RenderResult } from './types';
+import { type Logger } from '@applitools/logger';
+type Options = {
+    core: UFGCore<any>;
+    logger: Logger;
+};
+export declare function makeGetRenderResults({ core, logger: defaultLogger }: Options): ({ renders, logger, }: {
+    renders: StartedRender[];
+    logger: Logger;
+}) => Promise<RenderResult[]>;
+export {};

package/types/autonomous/open-check-and-close.d.ts

@@ -0,0 +1,16 @@
+import type { Core as UFGCore } from '../ufg/types';
+import type { OpenSettings } from './types';
+import type { CheckSettings, CloseSettings, Target } from '@applitools/core-base/types';
+import { type Logger } from '@applitools/logger';
+type Options = {
+    core: UFGCore<any>;
+    logger: Logger;
+};
+export declare function makeOpenCheckAndClose({ core, logger: defaultLogger }: Options): ({ target, openSettings, checkSettings, closeSettings, logger, }: {
+    target: Target;
+    openSettings: OpenSettings;
+    checkSettings?: CheckSettings<import("@applitools/utils").Region> | undefined;
+    closeSettings?: CloseSettings | undefined;
+    logger: Logger;
+}) => Promise<void>;
+export {};

package/types/autonomous/open-eyes.d.ts

@@ -0,0 +1,13 @@
+import type { Core as UFGCore } from '../ufg/types';
+import type { OpenSettings } from './types';
+import type { Eyes as BaseEyes } from '@applitools/core-base/types';
+import { type Logger } from '@applitools/logger';
+type Options = {
+    core: UFGCore<any>;
+    logger: Logger;
+};
+export declare function makeOpenEyes({ core, logger: defaultLogger }: Options): ({ settings, logger, }: {
+    settings: OpenSettings;
+    logger: Logger;
+}) => Promise<BaseEyes>;
+export {};

package/types/autonomous/start-renders.d.ts

@@ -0,0 +1,12 @@
+import type { Core as UFGCore } from '../ufg/types';
+import type { RenderTargetWithSettings, StartedRender } from './types';
+import { type Logger } from '@applitools/logger';
+type Options = {
+    core: UFGCore<any>;
+    logger: Logger;
+};
+export declare function makeStartRenders({ core, logger: defaultLogger }: Options): ({ targets, logger, }: {
+    targets: RenderTargetWithSettings[];
+    logger: Logger;
+}) => Promise<StartedRender[]>;
+export {};

package/types/autonomous/take-snapshots.d.ts

@@ -0,0 +1,15 @@
+import type { Core as UFGCore } from '../ufg/types';
+import type { DriverTarget, SnapshotSettings, Snapshot } from './types';
+import { type Logger } from '@applitools/logger';
+import { type SpecDriver, type SpecType } from '@applitools/driver';
+type Options<TSpec extends SpecType> = {
+    core: UFGCore<TSpec>;
+    spec: SpecDriver<TSpec>;
+    logger: Logger;
+};
+export declare function makeTakeSnapshots<TSpec extends SpecType>({ core, spec, logger: defaultLogger }: Options<TSpec>): ({ target, settings, logger, }: {
+    target: DriverTarget<TSpec>;
+    settings: SnapshotSettings<TSpec>;
+    logger?: Logger | undefined;
+}) => Promise<Snapshot[]>;
+export {};

package/types/autonomous/types.d.ts

@@ -0,0 +1,65 @@
+import type { Eyes as BaseEyes, ImageTarget as BaseImageTarget, OpenSettings as BaseOpenSettings, CheckSettings as BaseCheckSettings, CloseSettings as BaseCloseSettings } from '@applitools/core-base/types';
+import type * as UFGCore from '../ufg/types';
+import { type Logger } from '@applitools/logger';
+import { type SpecType } from '@applitools/driver';
+import { type RenderTarget, type StartedRender as UFGStartedRender } from '@applitools/ufg-client';
+export * from '../ufg/types';
+export interface AutonomousCore<TSpec extends SpecType> {
+    readonly type: 'autonomous';
+    takeSnapshots?(options: {
+        target: UFGCore.DriverTarget<TSpec>;
+        settings?: Partial<SnapshotSettings<TSpec>>;
+        logger?: Logger;
+    }): Promise<UFGCore.Snapshot[]>;
+    createRenderTarget(options: {
+        snapshot: UFGCore.Snapshot;
+        logger?: Logger;
+    }): Promise<RenderTargetWithSettings>;
+    startRenders(options: {
+        targets: RenderTargetWithSettings[];
+        logger?: Logger;
+    }): Promise<StartedRender[]>;
+    getRenderResults(options: {
+        renders: StartedRender[];
+        logger?: Logger;
+    }): Promise<RenderResult[]>;
+    createRenderResults(options: {
+        renders: StartedRender[];
+        rawResults: any[];
+        logger?: Logger;
+    }): Promise<RenderResult[]>;
+    /** @deprecated */
+    openEyes(options: {
+        settings: Partial<OpenSettings>;
+        logger?: Logger;
+    }): Promise<BaseEyes>;
+    openCheckAndClose(options: {
+        target: BaseImageTarget;
+        openSettings: Partial<OpenSettings>;
+        checkSettings?: BaseCheckSettings;
+        closeSettings?: BaseCloseSettings;
+        logger?: Logger;
+    }): Promise<void>;
+}
+export type SnapshotSettings<TSpec extends SpecType> = UFGCore.SnapshotSettings<TSpec> & UFGCore.EyesServerSettings;
+export type RenderTargetWithSettings = {
+    target: RenderTarget;
+    settings: UFGCore.SafeCheckSettings;
+    environment: UFGCore.RenderEnvironment;
+    account: UFGCore.Account;
+};
+export type StartedRender = {
+    render: UFGStartedRender;
+    settings: UFGCore.SafeCheckSettings;
+    environment: UFGCore.ExactEnvironment;
+    account: UFGCore.Account;
+};
+export type RenderResult = {
+    status: 'rendering' | 'rendered' | 'error';
+    error: string;
+    target: BaseImageTarget;
+    settings: BaseCheckSettings;
+    environment: UFGCore.ExactEnvironment;
+    account: UFGCore.Account;
+};
+export type OpenSettings = BaseOpenSettings;

package/types/classic/utils/extract-default-environments.d.ts

@@ -0,0 +1,9 @@
+import type { ExactEnvironment, Environment } from '../types';
+import { type SpecType, type Driver } from '@applitools/driver';
+export declare function extractDefaultEnvironments<TSpec extends SpecType>({ driver, settings, }: {
+    driver?: Driver<TSpec>;
+    settings?: {
+        keepPlatformNameAsIs?: boolean;
+        environment?: ExactEnvironment;
+    };
+}): Promise<Environment[]>;

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

@@ -0,0 +1,18 @@
+import type { ScreenshotSettings, Environment } from '../types';
+import type { Target as BaseTarget } from '@applitools/core-base';
+import { type Logger } from '@applitools/logger';
+import { type SpecType, type Driver, type ElementReference } from '@applitools/driver';
+import { type DomCaptureSettings } from './take-dom-capture';
+export type ScreenshotsSettings<TSpec extends SpecType> = ScreenshotSettings<TSpec> & {
+    environments: Environment[];
+    regionsToCalculate?: ElementReference<TSpec>[];
+    calculateView?: boolean;
+    domSettings?: DomCaptureSettings;
+};
+export declare function takeScreenshots<TSpec extends SpecType>({ driver, settings, logger, }: {
+    driver: Driver<TSpec>;
+    settings: ScreenshotsSettings<TSpec>;
+    logger: Logger;
+}): Promise<(BaseTarget & {
+    calculatedRegions: any;
+})[]>;

package/types/get-account-info.d.ts

@@ -0,0 +1,11 @@
+import type { Core, Account, EyesServerSettings } from './types';
+import { type Logger } from '@applitools/logger';
+type Options = {
+    core: Core<any>;
+    logger: Logger;
+};
+export declare function makeGetAccountInfo({ core, logger: mainLogger }: Options): ({ settings, logger, }: {
+    settings: EyesServerSettings;
+    logger?: Logger | undefined;
+}) => Promise<Account>;
+export {};

package/types/lang.d.ts

@@ -0,0 +1,32 @@
+export declare const matchLevelContentDeprecatedWarning = "The \"Content\" match level value has been deprecated, use \"IgnoreColors\" instead.";
+export declare const edgeUfgEnvironmentDeprecatedWarning = "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.";
+export declare const outdatedSdkVersionWarning: (options: {
+    name: string;
+    currentVersion: string;
+    latestVersion: string;
+}) => string;
+export declare const requestedEnvironmentSmallerThenBreakpointWarning: (options: {
+    breakpoint: number;
+    browsers: {
+        name: string;
+        width: number;
+    }[];
+}) => string;
+export declare const breakpointOutOfDriverBoundsWarning: (options: {
+    requiredWidth: number;
+    actualWidth: number;
+    browsers: {
+        name: string;
+        width: number;
+    }[];
+}) => string;
+export declare const requestedEnvironmentOutOfDriverBoundsWarning: (options: {
+    requiredWidth: number;
+    actualWidth: number;
+    browsers: {
+        name: string;
+    }[];
+}) => string;
+export declare const applitoolsLibConflictingCapabilitiesWarning: (options: {
+    conflictingCapabilities: Record<string, any>;
+}) => string;

package/types/offline/merge-configs.d.ts

@@ -0,0 +1 @@
+export declare function mergeConfigs<TBase extends Record<string, any>>(base: TBase, other: Record<string, any>): TBase;

package/types/offline/run-offline-snapshots.d.ts

@@ -0,0 +1,11 @@
+import { Config, type EyesServerSettings } from '../types';
+import { type Logger } from '@applitools/logger';
+import type { TestResult } from '@applitools/core-base';
+import type { SpecType } from '@applitools/driver';
+export type OfflineSnapshotsSettings = EyesServerSettings & {
+    offlineLocationPath: string;
+    failOnDiff: boolean;
+    config: Config<SpecType, 'ufg'>;
+    logger?: Logger;
+};
+export declare function runOfflineSnapshots(options: OfflineSnapshotsSettings): Promise<TestResult[]>;

package/types/run-offline-snapshots.d.ts

@@ -0,0 +1,6 @@
+import { type EyesServerSettings } from './types';
+export type OfflineSnapshotsSettings = EyesServerSettings & {
+    offlineLocationPath: string;
+    failOnDiff: boolean;
+};
+export declare function runOfflineSnapshots(options: OfflineSnapshotsSettings): Promise<void>;

package/types/troubleshoot/logs.d.ts

@@ -0,0 +1,25 @@
+interface Log {
+    label?: string;
+    tags?: string[][];
+    timestamp?: string;
+    level?: string;
+    message: string;
+}
+interface GroupedLog<TGroupedLog extends GroupedLog<TGroupedLog>> {
+    [key: string]: TGroupedLog;
+}
+type StructuredLog = GroupedLog<StructuredLog> & {
+    logs?: Log[];
+};
+type AnalyzedLog = GroupedLog<AnalyzedLog> & {
+    logs?: string[];
+    startedAt: number;
+    finishedAt: number;
+    time: number;
+    conclusion: string;
+};
+export declare function parseLogs(logs: string): Log[];
+export declare function stringifyLog(log: Log): string;
+export declare function structureLogs(logs: Log[]): StructuredLog;
+export declare function analyzeLogs({ logs, ...groups }: StructuredLog): AnalyzedLog;
+export {};

package/types/types.d.ts

@@ -99,6 +99,7 @@ export interface Eyes<TSpec extends SpecType, TDefaultType extends 'classic' | '
 }
 export interface ManagerSettings {
     concurrency?: number;
+    fetchConcurrency?: number;
     /** @deprecated */
     legacyConcurrency?: number;
     agentId?: string;

package/types/ufg/core.d.ts

@@ -13,8 +13,9 @@ type Options<TSpec extends SpecType> = {
     base?: BaseCore;
     agentId?: string;
     concurrency?: number;
+    fetchConcurrency?: number;
     cwd?: string;
     logger?: Logger;
 };
-export declare function makeCore<TSpec extends SpecType>({ concurrency, spec, clients, base, agentId, cwd, logger: defaultLogger, }: Options<TSpec>): Core<TSpec>;
+export declare function makeCore<TSpec extends SpecType>({ concurrency, spec, clients, base, fetchConcurrency, agentId, cwd, logger: defaultLogger, }: Options<TSpec>): Core<TSpec>;
 export {};

package/types/ufg/create-render-target-from-snapshot.d.ts

@@ -0,0 +1,8 @@
+import { UFGClient, RenderTarget } from '@applitools/ufg-client';
+import { Snapshot } from './types';
+import { Logger } from '@applitools/logger';
+export declare function createRenderTargetFromSnapshot({ ufgClient, snapshot, logger, }: {
+    ufgClient: UFGClient;
+    snapshot: Snapshot;
+    logger: Logger;
+}): Promise<RenderTarget>;

package/types/ufg/get-ufg-client.d.ts

@@ -1,11 +1,12 @@
 import { type Logger } from '@applitools/logger';
-import { type UFGClient, type UFGRequestsConfig } from '@applitools/ufg-client';
+import { type UFGClient, type UFGClientConfig } from '@applitools/ufg-client';
 type Options = {
     client?: UFGClient;
     logger: Logger;
+    fetchConcurrency?: number;
 };
-export declare function makeGetUFGClient({ client, logger: defaultLogger }: Options): (({ config, logger }: {
-    config: UFGRequestsConfig;
+export declare function makeGetUFGClient({ client, fetchConcurrency, logger: defaultLogger }: Options): (({ config, logger }: {
+    config: UFGClientConfig;
     logger?: Logger | undefined;
 }) => Promise<UFGClient>) & {
     getCachedValues(): Promise<UFGClient>[];

package/types/ufg/take-snapshots.d.ts

@@ -0,0 +1,17 @@
+import type { Core, SnapshotSettings, Account, Snapshot } from './types';
+import { type AbortSignal } from 'abort-controller';
+import { type Logger } from '@applitools/logger';
+import { type SpecType, type SpecDriver, type Driver } from '@applitools/driver';
+type Options<TSpec extends SpecType> = {
+    core: Core<TSpec>;
+    spec: SpecDriver<TSpec>;
+    signal?: AbortSignal;
+    logger: Logger;
+};
+export declare function makeTakeSnapshots<TSpec extends SpecType>({ core, spec, signal, logger: mainLogger }: Options<TSpec>): ({ driver, settings, account, logger, }: {
+    driver: Driver<TSpec>;
+    settings?: SnapshotSettings<TSpec> | undefined;
+    account: Account;
+    logger?: Logger | undefined;
+}) => Promise<Snapshot[]>;
+export {};

package/types/ufg/utils/extract-default-environment.d.ts

@@ -0,0 +1,5 @@
+import type { Environment } from '../types';
+import { type SpecType, type Driver } from '@applitools/driver';
+export declare function extractDefaultEnvironments<TSpec extends SpecType>({ driver, }: {
+    driver?: Driver<TSpec>;
+}): Promise<Environment[]>;

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

@@ -0,0 +1,34 @@
+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, transformElementReference, }: {
+    elementReferences: {
+        target?: ElementReference<TSpec>;
+        scrolling?: ElementReference<TSpec>;
+        calculate?: ElementReference<TSpec>[];
+    };
+    transformElementReference: (elementReference: ElementReference<TSpec>) => UFGSelector | undefined;
+    logger: Logger;
+}): {
+    elementReferencesToMark: (string | TSpec["element"] | TSpec["secondary"]["element"] | TSpec["selector"] | TSpec["secondary"]["selector"] | {
+        selector: string | TSpec["selector"] | TSpec["secondary"]["selector"];
+        type?: string | undefined;
+        child?: TSpec["selector"] | TSpec["secondary"]["selector"] | import("@applitools/driver").CommonSelector<TSpec["selector"] | TSpec["secondary"]["selector"]> | undefined;
+        shadow?: TSpec["selector"] | TSpec["secondary"]["selector"] | import("@applitools/driver").CommonSelector<TSpec["selector"] | TSpec["secondary"]["selector"]> | undefined;
+        frame?: TSpec["selector"] | TSpec["secondary"]["selector"] | import("@applitools/driver").CommonSelector<TSpec["selector"] | TSpec["secondary"]["selector"]> | undefined;
+        fallback?: TSpec["selector"] | TSpec["secondary"]["selector"] | import("@applitools/driver").CommonSelector<TSpec["selector"] | TSpec["secondary"]["selector"]> | undefined;
+    } | (NonNullable<TSpec["element"]> extends infer T ? T extends NonNullable<TSpec["element"]> ? T extends readonly (infer InnerArr)[] ? InnerArr : T : never : never) | (NonNullable<TSpec["secondary"]["element"]> extends infer T_1 ? T_1 extends NonNullable<TSpec["secondary"]["element"]> ? T_1 extends readonly (infer InnerArr)[] ? InnerArr : T_1 : never : never) | (NonNullable<TSpec["selector"]> extends infer T_2 ? T_2 extends NonNullable<TSpec["selector"]> ? T_2 extends readonly (infer InnerArr)[] ? InnerArr : T_2 : never : never) | (NonNullable<TSpec["secondary"]["selector"]> extends infer T_3 ? T_3 extends NonNullable<TSpec["secondary"]["selector"]> ? T_3 extends readonly (infer InnerArr)[] ? InnerArr : T_3 : never : never))[];
+    getGeneratedSelectors: (generatedSelectors?: {
+        originalSelector: UFGSelector | null;
+        safeSelector: UFGSelector | {
+            error: string;
+        } | null;
+    }[]) => {
+        target: UFGSelector | undefined;
+        scrolling: UFGSelector | undefined;
+        calculate: {
+            originalSelector: UFGSelector | null;
+            safeSelector: UFGSelector | null;
+        }[];
+    };
+};

package/types/ufg/utils/to-safe-check-settings.d.ts

@@ -0,0 +1,22 @@
+import type { CheckSettings, SafeCheckSettings } from '../types';
+import { type SpecType, type ElementReference, type CommonSelector } from '@applitools/driver';
+import { type Selector as UFGSelector } from '@applitools/ufg-client';
+export declare function toSafeCheckSettings<TSpec extends SpecType>({ settings }: {
+    settings: CheckSettings<TSpec>;
+}): {
+    elementReferences: {
+        target: ElementReference<TSpec> | undefined;
+        scrolling: ElementReference<TSpec> | undefined;
+        calculate: ElementReference<TSpec>[];
+    };
+    getSafeCheckSettings: ({ selectors, }: {
+        selectors: {
+            target: UFGSelector | undefined;
+            scrolling: UFGSelector | undefined;
+            calculate: {
+                originalSelector: CommonSelector | null;
+                safeSelector: UFGSelector | null;
+            }[];
+        };
+    }) => SafeCheckSettings;
+};

package/types/utils/ensure-offline-folder.d.ts

@@ -0,0 +1 @@
+export declare function ensureOfflineFolder(): string | undefined;

package/types/utils/extract-branching-timestamp.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import type { ExecOptions } from 'child_process';
+import { type Logger } from '@applitools/logger';
+export declare const extractBranchingTimestamp: typeof extractGitBranchingTimestamp & {
+    getCachedValues(): Promise<string>[];
+    setCachedValue(key: any, value: Promise<string>): void;
+    clearCache(): void;
+};
+type ExtractGitBranchingTimestampOptions = {
+    branchName: string;
+    execOptions?: ExecOptions;
+    logger?: Logger;
+    parentBranchName: string;
+};
+declare function extractGitBranchingTimestamp({ branchName, parentBranchName, execOptions, logger, }: ExtractGitBranchingTimestampOptions): Promise<string>;
+export {};

package/types/utils/extract-current-commit.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+import type { ExecOptions } from 'child_process';
+import { type Logger } from '@applitools/logger';
+export declare const cacheKey = "extract-current-commit";
+export declare const extractLatestCommitInfo: typeof extractCommitInfo & {
+    getCachedValues(): Promise<{
+        timestamp: string;
+        sha: string;
+    } | undefined>[];
+    setCachedValue(key: any, value: Promise<{
+        timestamp: string;
+        sha: string;
+    } | undefined>): void;
+    clearCache(): void;
+};
+type ExtractCurrentCommitTimestampOptions = {
+    execOptions?: ExecOptions;
+    logger?: Logger;
+};
+declare function extractCommitInfo({ execOptions, logger, }: ExtractCurrentCommitTimestampOptions): Promise<{
+    timestamp: string;
+    sha: string;
+} | undefined>;
+export {};

package/types/utils/extract-git-info.d.ts

@@ -0,0 +1,59 @@
+/// <reference types="node" />
+import type { ExecOptions } from 'child_process';
+import { type Logger } from '@applitools/logger';
+type Options = {
+    execOptions?: ExecOptions;
+    logger: Logger;
+};
+type ExtractGitBranchingTimestampOptions = {
+    branchName: string;
+    execOptions?: ExecOptions;
+    logger?: Logger;
+    parentBranchName: string;
+};
+type ExtractCurrentCommitTimestampOptions = {
+    execOptions?: ExecOptions;
+    logger?: Logger;
+};
+export declare const cacheKey = "default";
+export declare const extractLatestCommitInfo: (({ execOptions, logger, }: ExtractCurrentCommitTimestampOptions) => Promise<{
+    timestamp: string;
+    sha: string;
+} | undefined>) & {
+    getCachedValues(): Promise<{
+        timestamp: string;
+        sha: string;
+    } | undefined>[];
+    setCachedValue(key: any, value: Promise<{
+        timestamp: string;
+        sha: string;
+    } | undefined>): void;
+    clearCache(): void;
+};
+export declare const extractGitBranch: (({ execOptions, logger }: Options) => Promise<string | undefined>) & {
+    getCachedValues(): Promise<string | undefined>[];
+    setCachedValue(key: any, value: Promise<string | undefined>): void;
+    clearCache(): void;
+};
+export declare const extractGitRepo: (({ execOptions, logger }: Options) => Promise<{
+    name?: string;
+    owner?: string;
+}>) & {
+    getCachedValues(): Promise<{
+        name?: string | undefined;
+        owner?: string | undefined;
+    }>[];
+    setCachedValue(key: any, value: Promise<{
+        name?: string | undefined;
+        owner?: string | undefined;
+    }>): void;
+    clearCache(): void;
+};
+export declare function extractBuildIdFromCI(): Promise<string | undefined>;
+export declare const extractBranchingTimestamp: (({ branchName, parentBranchName, execOptions, logger, }: ExtractGitBranchingTimestampOptions) => Promise<string | undefined>) & {
+    getCachedValues(): Promise<string | undefined>[];
+    setCachedValue(key: any, value: Promise<string | undefined>): void;
+    clearCache(): void;
+};
+export declare function isISODate(str: string): boolean;
+export {};

package/types/utils/extract-start-info.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+import type { ExecOptions } from 'child_process';
+import { type Logger } from '@applitools/logger';
+type Options = {
+    execOptions?: ExecOptions;
+    logger: Logger;
+};
+export declare const cacheKey = "default";
+export declare const extractGitBranch: (({ execOptions, logger }: Options) => Promise<string | undefined>) & {
+    getCachedValues(): Promise<string | undefined>[];
+    setCachedValue(key: any, value: Promise<string | undefined>): void;
+    clearCache(): void;
+};
+export declare const extractGitRepo: (({ execOptions, logger }: Options) => Promise<{
+    name?: string;
+    owner?: string;
+}>) & {
+    getCachedValues(): Promise<{
+        name?: string | undefined;
+        owner?: string | undefined;
+    }>[];
+    setCachedValue(key: any, value: Promise<{
+        name?: string | undefined;
+        owner?: string | undefined;
+    }>): void;
+    clearCache(): void;
+};
+export declare function extractBuildIdFromCI(): Promise<string | undefined>;
+export {};

package/types/utils/extract-test-environment.d.ts

@@ -0,0 +1,2 @@
+export declare function extractTestEnvironment(baseEnvironment?: Record<string, any>): Record<string, any>;
+export declare function extractCIProvider(): string | null;

package/types/utils/memory-usage-logging.d.ts

@@ -0,0 +1,7 @@
+import { type Logger } from '@applitools/logger';
+export declare function startMemoryUsageLogging({ timeout, logger }: {
+    timeout?: number;
+    logger: Logger;
+}): {
+    stop(): void;
+};

package/types/utils/populate-eyes-server-settings.d.ts

@@ -0,0 +1,2 @@
+import type { EyesServerSettings } from '../types';
+export declare function populateEyesServerSettings(settings: Partial<EyesServerSettings>): EyesServerSettings;

package/types/utils/validate-sdk-version.d.ts

@@ -0,0 +1,42 @@
+import { type Logger } from '@applitools/logger';
+declare const extractors: {
+    js: typeof extractLatestJsPackageVersion & {
+        getCachedValues(): Promise<string>[];
+        setCachedValue(key: any, value: Promise<string>): void;
+        clearCache(): void;
+    };
+    java: typeof extractLatestJavaPackageVersion & {
+        getCachedValues(): Promise<string>[];
+        setCachedValue(key: any, value: Promise<string>): void;
+        clearCache(): void;
+    };
+    dotnet: typeof extractLatestDotNetPackageVersion & {
+        getCachedValues(): Promise<string>[];
+        setCachedValue(key: any, value: Promise<string>): void;
+        clearCache(): void;
+    };
+    python: typeof extractLatestPythonPackageVersion & {
+        getCachedValues(): Promise<string>[];
+        setCachedValue(key: any, value: Promise<string>): void;
+        clearCache(): void;
+    };
+    ruby: typeof extractLatestRubyPackageVersion & {
+        getCachedValues(): Promise<string>[];
+        setCachedValue(key: any, value: Promise<string>): void;
+        clearCache(): void;
+    };
+};
+export declare function validateSdkVersion(sdk: {
+    lang: keyof typeof extractors;
+    name: string;
+    currentVersion: string;
+    latestVersion?: string;
+}, { logger }: {
+    logger: Logger;
+}): Promise<void>;
+export declare function extractLatestJsPackageVersion(name: string): Promise<string>;
+export declare function extractLatestJavaPackageVersion(name: string): Promise<string>;
+export declare function extractLatestDotNetPackageVersion(name: string): Promise<string>;
+export declare function extractLatestPythonPackageVersion(name: string): Promise<string>;
+export declare function extractLatestRubyPackageVersion(name: string): Promise<string>;
+export {};

package/CHANGELOG.md

@@ -1,222 +0,0 @@
-# Change Log
-
-## Unreleased
-
-## 2.5.2 - 2023/4/19
-
-### Features
-### Bug fixes
-- Fixed functional test feature issues in ec client
-
-## 2.5.1 - 2023/4/18
-
-### Features
-### Bug fixes
-- Fixed the issue with session metadata extraction
-
-## 2.5.0 - 2023/4/18
-
-### Features
-- Added functional session feature
-### Bug fixes
-- Fixed issue with when webview were wasn't recognized as web compatible world
-
-## 2.4.13 - 2023/4/16
-
-### Features
-### Bug fixes
-- format result `hostDisplaySize`
-
-## 2.4.12 - 2023/4/12
-
-### Features
-### Bug fixes
-- Expose types for eyes-cypress
-
-## 2.4.11 - 2023/4/11
-
-### Features
-- Make `locate` to return coordinates that could be directly used with the driver
-### Bug fixes
-- Fix issue when `locate` return wrong type of the region, with `left` and `top` properties instead of `x` and `y`
-
-## 2.4.10 - 2023/4/10
-
-### Features
-### Bug fixes
-- Improved appium prefixed capabilities parsing
-
-## 2.4.9 - 2023/4/7
-
-### Features
-### Bug fixes
-- Fixed issue in dom snapshot that prevented urls that start with a whitespace to be mapped
-
-## 2.4.8 - 2023/4/5
-
-### Features
-### Bug fixes
-- Fixed screenshot framing
-- Fixed issue with css fetching for dom capture
-
-## 2.4.7 - 2023/4/4
-
-### Features
-### Bug fixes
-- Fixed issue with emulation driver detection
-
-## 2.4.6 - 2023/4/4
-
-### Features
-### Bug fixes
-- Fixed relative url resolution in css files
-- Added timeout to css fetching during preparing dom capture
-
-## 2.4.5 - 2023/3/31
-
-### Features
-- Added `removeDuplicateTests` property to the `GetManagerResultsSettings`
-### Bug fixes
-
-## 2.4.4 - 2023/3/30
-
-### Features
-### Bug fixes
-- Improve performance in DOM snapshot
-
-## 2.4.3 - 2023/3/22
-
-### Features
-- Changed `makeManager` api to accept `settings`
-### Bug fixes
-- Fixed retry interval during poll requests to eyes back-end
-
-## 2.4.2 - 2023/3/17
-
-### Features
-### Bug fixes
-- Fixed issue with concurrency of the renders in ufg mode
-
-## 2.4.1 - 2023/3/17
-
-### Features
-- Improved extraction of nml element
-### Bug fixes
-- Fixed issue with concurrency of the renders in ufg mode
-
-## 2.4.0 - 2023/3/12
-
-### Features
-### Bug fixes
-- Fixed ufg concurrency regression
-
-## 2.3.14 - 2023/3/7
-
-### Features
-### Bug fixes
-- Upgrade tunnel version
-
-## 2.3.13 - 2023/3/7
-
-### Features
-### Bug fixes
-- Fixed selector transformation for scroll root elements for ufg
-
-## 2.3.12 - 2023/3/7
-
-### Features
-- Update broker url using last response instead of using driver
-### Bug fixes
-- Replaced broker url cache with nml element cache
-
-## 2.3.11 - 2023/3/6
-
-### Features
-### Bug fixes
-- setting the universal cli for javascript right
-
-## 2.3.10 - 2023/3/3
-
-### Features
-- Added `Resize` stitch mode value
-### Bug fixes
-- Fixed issue when `.visualgrid` was not added to agent id
-- Fixed issue with aborting ufg tests
-
-## 2.3.9 - 2023/3/2
-
-### Features
-### Bug fixes
-- Update `@applitools/execution-grid-tunnel` dependency
-
-## 2.3.8 - 2023/3/2
-
-### Features
-### Bug fixes
-- upgrade dom-snapshot with a fix to CSP
-
-## 2.3.7 - 2023/2/23
-
-### Features
-- Added caching for broker url to avoid looking for the nml element multiple times
-- Passing density metric for PPI support in the sdk
-### Bug fixes
-- Fixed issue with universal protocol when manager ref was deleted once `EyesManager.getResults` was called
-- Fixed vulnerabilities of EC client
-
-## 2.3.6 - 2023/2/17
-
-### Features
-### Bug fixes
-- Update some type declarations
-
-## 2.3.5 - 2023/2/17
-
-### Features
-- Improve logging in core server
-### Bug fixes
-- Fixed issue when core server was hanging if any command was called immediately after `Core.makeCore` command
-- Fixed issue when `StaticDriver` and `StaticElement` were not recognized as a valid driver or element objects
-
-## 2.3.4 - 2023/2/16
-
-### Features
-### Bug fixes
-- Fixed ws types
-
-## 2.3.3 - 2023/2/16
-
-### Features
-### Bug fixes
-- Fixed debug mode
-- Fixed logs
-
-## 2.3.2 - 2023/2/16
-
-### Features
-- Added arm64 binary
-### Bug fixes
-
-## 2.3.1 - 2023/2/15
-
-### Features
-- Avoid helper initialization on native devices before it required
-### Bug fixes
-
-## 2.3.0 - 2023/2/15
-
-### Features
-- Integrate universal protocol to run core via transport
-### Bug fixes
-
-## 2.2.0 - 2023/2/15
-
-### Features
-- Integrate universal protocol to run core via transport
-### Bug fixes
-
-## 2.0.2 - 2022/12/27
-
-### Features
-- Created
-### Bug fixes