@applitools/core 4.18.2 → 4.20.0

package/dist/ufg/utils/generate-safe-selectors.js

@@ -27,37 +27,37 @@ exports.generateSafeSelectors = void 0;
 const utils = __importStar(require("@applitools/utils"));
 const { addElementIds, cleanupElementIds } = require('@applitools/snippets');
 async function generateSafeSelectors({ context, elementReferences, }) {
-    const mapping = {
-        elements: [],
-        ids: [],
-    };
-    for (const elementReference of elementReferences) {
-        const elements = await context.elements(elementReference);
-        mapping.elements.push(elements);
-        mapping.ids.push(Array(elements.length).fill(utils.general.guid()));
-    }
-    const generatedSelectors = await context.execute(addElementIds, [
-        mapping.elements.flat(),
-        mapping.ids.flat(),
-    ]);
+    if (!(elementReferences === null || elementReferences === void 0 ? void 0 : elementReferences.length))
+        return;
+    const mapping = await Promise.all(elementReferences.map(async (ref) => {
+        const elements = await context.elements(ref);
+        return {
+            ref,
+            elements,
+            id: utils.general.guid(), // same id for all elements that match the same ref
+        };
+    }));
+    // we can't structure elementsWithIds as object because it's not supported in safari webdriver (https://stackoverflow.com/questions/78953951/ios-safari-webdriver-executescript-fails-to-serialize-objects-with-elements)
+    const elementsWithIds = mapping.map(({ elements, id }) => [elements, id]);
+    const generatedSelectors = (await context.execute(addElementIds, elementsWithIds)).flat();
     let offset = 0;
-    const selectors = mapping.elements.map((elements, index) => {
+    const selectors = mapping.map(({ elements, ref }) => {
         if (elements.length === 0)
-            return { safeSelector: null, originalSelector: null, elementReference: elementReferences[index] };
+            return { safeSelector: null, originalSelector: null, elementReference: ref };
         const safeSelector = generatedSelectors[offset].reduceRight((selector, value) => {
             return selector ? { type: 'css', selector: value, shadow: selector } : { type: 'css', selector: value };
         }, undefined);
         offset += elements.length;
-        return { safeSelector, originalSelector: elements[0].commonSelector, elementReference: elementReferences[index] };
+        return { safeSelector, originalSelector: elements[0].commonSelector, elementReference: ref };
     });
     return {
         selectors,
         cleanupGeneratedSelectors,
     };
     async function cleanupGeneratedSelectors() {
-        if (!mapping.elements.length)
+        if (!mapping.length)
             return;
-        await context.execute(cleanupElementIds, [mapping.elements.flat()]);
+        await context.execute(cleanupElementIds, [mapping.map(({ elements }) => elements).flat()]);
     }
 }
 exports.generateSafeSelectors = generateSafeSelectors;

package/dist/ufg/utils/take-dom-snapshots.js

@@ -51,13 +51,10 @@ async function takeDomSnapshots({ driver, settings, hooks, provides, logger, })
         logger.log(`taking single dom snapshot`);
         await beforeEachSnapshot();
         // it's important that we calculate safe selectors as close as possible to taking the dom snapshot
-        let safeSelectorResult;
-        if (settings.elementReferences) {
-            safeSelectorResult = await (0, generate_safe_selectors_1.generateSafeSelectors)({
-                context: currentContext,
-                elementReferences: settings.elementReferences,
-            });
-        }
+        const safeSelectorResult = await (0, generate_safe_selectors_1.generateSafeSelectors)({
+            context: currentContext,
+            elementReferences: settings.elementReferences,
+        });
         const snapshot = await (0, take_dom_snapshot_1.takeDomSnapshot)({ context: currentContext, settings, logger });
         await ((_b = safeSelectorResult === null || safeSelectorResult === void 0 ? void 0 : safeSelectorResult.cleanupGeneratedSelectors) === null || _b === void 0 ? void 0 : _b.call(safeSelectorResult));
         return Array(settings.environments.length).fill({ ...snapshot, generatedSelectors: safeSelectorResult === null || safeSelectorResult === void 0 ? void 0 : safeSelectorResult.selectors });
@@ -94,7 +91,11 @@ async function takeDomSnapshots({ driver, settings, hooks, provides, logger, })
     }
     requiredWidths.forEach((browsers, requiredWidth) => entries.push({ viewportSize: { width: requiredWidth, height: initialViewportSize.height }, browsers }));
     logger.log(`All entries to take dom snapshots for`, entries);
-    let safeSelectorResult;
+    // making safe selectors before any resize in order to make sure fallback selectors are created
+    let safeSelectorResult = await (0, generate_safe_selectors_1.generateSafeSelectors)({
+        context: currentContext,
+        elementReferences: settings.elementReferences,
+    });
     const snapshots = Array(settings.environments.length);
     for (const [index, { viewportSize, browsers }] of entries.entries()) {
         logger.log(`Taking dom snapshot for viewport size ${viewportSize}`);
@@ -132,12 +133,10 @@ async function takeDomSnapshots({ driver, settings, hooks, provides, logger, })
         }
         await beforeEachSnapshot();
         // it's important that we calculate safe selectors as close as possible to taking the dom snapshot
-        if (settings.elementReferences) {
-            safeSelectorResult = await (0, generate_safe_selectors_1.generateSafeSelectors)({
-                context: currentContext,
-                elementReferences: settings.elementReferences,
-            });
-        }
+        safeSelectorResult = await (0, generate_safe_selectors_1.generateSafeSelectors)({
+            context: currentContext,
+            elementReferences: settings.elementReferences,
+        });
         const snapshot = await (0, take_dom_snapshot_1.takeDomSnapshot)({ context: currentContext, settings, logger });
         browsers.forEach(({ index }) => (snapshots[index] = { ...snapshot, generatedSelectors: safeSelectorResult === null || safeSelectorResult === void 0 ? void 0 : safeSelectorResult.selectors }));
     }

package/dist/{log-event.js → utils/ensure-offline-folder.js}

@@ -22,17 +22,21 @@ 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.makeLogEvent = void 0;
-const populate_eyes_server_settings_1 = require("./utils/populate-eyes-server-settings");
+exports.ensureOfflineFolder = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
 const utils = __importStar(require("@applitools/utils"));
-function makeLogEvent({ core, logger: mainLogger }) {
-    return async function logEvent({ settings, logger = mainLogger, }) {
-        logger = logger.extend(mainLogger, { tags: [`log-event-${utils.general.shortid()}`] });
-        (utils.types.isArray(settings) ? settings : [settings]).forEach(settings => {
-            (0, populate_eyes_server_settings_1.populateEyesServerSettings)(settings);
-        });
-        return core.base.logEvent({ settings, logger });
-    };
+function ensureOfflineFolder() {
+    const offlineLocationPath = utils.general.getEnvValue('OFFLINE_LOCATION_PATH')
+        ? path_1.default.resolve(utils.general.getEnvValue('OFFLINE_LOCATION_PATH'), `execution-${Date.now()}`)
+        : undefined;
+    if (offlineLocationPath) {
+        fs_1.default.mkdirSync(offlineLocationPath, { recursive: true });
+    }
+    return offlineLocationPath;
 }
-exports.makeLogEvent = makeLogEvent;
+exports.ensureOfflineFolder = ensureOfflineFolder;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applitools/core",
-  "version": "4.18.2",
+  "version": "4.20.0",
   "homepage": "https://applitools.com",
   "bugs": {
     "url": "https://github.com/applitools/eyes.sdk.javascript1/issues"
@@ -74,25 +74,26 @@
     }
   },
   "dependencies": {
-    "@applitools/core-base": "1.16.1",
-    "@applitools/dom-capture": "11.4.0",
+    "@applitools/core-base": "1.17.0",
+    "@applitools/dom-capture": "11.5.0",
     "@applitools/dom-snapshot": "4.11.3",
-    "@applitools/driver": "1.19.0",
-    "@applitools/ec-client": "1.9.4",
+    "@applitools/driver": "1.19.1",
+    "@applitools/ec-client": "1.9.6",
     "@applitools/logger": "2.0.18",
-    "@applitools/nml-client": "1.8.10",
+    "@applitools/nml-client": "1.8.11",
     "@applitools/req": "1.7.2",
-    "@applitools/screenshoter": "3.8.36",
-    "@applitools/snippets": "2.4.27",
+    "@applitools/screenshoter": "3.8.37",
+    "@applitools/snippets": "2.5.0",
     "@applitools/socket": "1.1.18",
-    "@applitools/spec-driver-webdriver": "1.1.12",
-    "@applitools/ufg-client": "1.12.3",
+    "@applitools/spec-driver-webdriver": "1.1.13",
+    "@applitools/ufg-client": "1.13.0",
     "@applitools/utils": "1.7.4",
     "@types/ws": "8.5.5",
     "abort-controller": "3.0.0",
     "chalk": "4.1.2",
     "node-fetch": "2.6.7",
     "semver": "7.6.2",
+    "tar": "7.4.3",
     "webdriver": "7.31.1",
     "ws": "8.17.1",
     "yargs": "17.7.2"
@@ -100,8 +101,8 @@
   "devDependencies": {
     "@applitools/bongo": "^5.10.0",
     "@applitools/sea": "^1.0.0",
-    "@applitools/spec-driver-puppeteer": "^1.4.12",
-    "@applitools/spec-driver-selenium": "^1.5.83",
+    "@applitools/spec-driver-puppeteer": "^1.4.13",
+    "@applitools/spec-driver-selenium": "^1.5.84",
     "@applitools/test-server": "^1.2.2",
     "@applitools/test-utils": "^1.5.17",
     "@applitools/tunnel-client": "^1.5.8",

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

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

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

@@ -1,12 +1,12 @@
 import type { Core as UFGCore } from '../ufg/types';
-import type { RenderTarget, StartedRender } from './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: RenderTarget[];
+    targets: RenderTargetWithSettings[];
     logger: Logger;
 }) => Promise<StartedRender[]>;
 export {};

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

@@ -1,12 +1,13 @@
 import type { Core as UFGCore } from '../ufg/types';
 import type { DriverTarget, SnapshotSettings, Snapshot } from './types';
 import { type Logger } from '@applitools/logger';
-import { type SpecType } from '@applitools/driver';
+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, logger: defaultLogger }: Options<TSpec>): ({ target, settings, 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;

package/types/autonomous/types.d.ts

@@ -2,7 +2,7 @@ import type { Eyes as BaseEyes, ImageTarget as BaseImageTarget, OpenSettings as
 import type * as UFGCore from '../ufg/types';
 import { type Logger } from '@applitools/logger';
 import { type SpecType } from '@applitools/driver';
-import { type RenderTarget as UFGRenderTarget, type StartedRender as UFGStartedRender } from '@applitools/ufg-client';
+import { type RenderTarget, type StartedRender as UFGStartedRender } from '@applitools/ufg-client';
 export * from '../ufg/types';
 export interface AutonomousCore<TSpec extends SpecType> {
     readonly type: 'autonomous';
@@ -14,9 +14,9 @@ export interface AutonomousCore<TSpec extends SpecType> {
     createRenderTarget(options: {
         snapshot: UFGCore.Snapshot;
         logger?: Logger;
-    }): Promise<RenderTarget>;
+    }): Promise<RenderTargetWithSettings>;
     startRenders(options: {
-        targets: RenderTarget[];
+        targets: RenderTargetWithSettings[];
         logger?: Logger;
     }): Promise<StartedRender[]>;
     getRenderResults(options: {
@@ -34,8 +34,8 @@ export interface AutonomousCore<TSpec extends SpecType> {
     }): Promise<BaseEyes>;
 }
 export type SnapshotSettings<TSpec extends SpecType> = UFGCore.SnapshotSettings<TSpec> & UFGCore.EyesServerSettings;
-export type RenderTarget = {
-    target: UFGRenderTarget;
+export type RenderTargetWithSettings = {
+    target: RenderTarget;
     settings: UFGCore.SafeCheckSettings;
     environment: UFGCore.RenderEnvironment;
     account: UFGCore.Account;

package/types/classic/core.d.ts

@@ -13,6 +13,7 @@ type Options<TSpec extends SpecType> = {
     agentId?: string;
     cwd?: string;
     logger?: Logger;
+    offlineLocationPath?: string;
 };
-export declare function makeCore<TSpec extends SpecType>({ spec, clients, base: defaultBase, concurrency, agentId, cwd, logger: defaultLogger, }: Options<TSpec>): Core<TSpec>;
+export declare function makeCore<TSpec extends SpecType>({ spec, clients, base: defaultBase, concurrency, agentId, cwd, logger: defaultLogger, offlineLocationPath, }: Options<TSpec>): Core<TSpec>;
 export {};

package/types/classic/utils/take-dom-capture.d.ts

@@ -8,6 +8,14 @@ export type DomCaptureSettings = {
     chunkByteLength?: number;
     proxy?: Proxy;
     fetch?: Fetch;
+    domCaptureArgs?: {
+        styleProps?: string[] | boolean;
+        rectProps?: string[];
+        elementProps?: string[];
+        capturePseudo?: boolean;
+        addStats?: boolean;
+        fetchTimeLimit?: number;
+    };
 };
 export declare function takeDomCapture<TSpec extends SpecType>({ driver, settings, logger, }: {
     driver: Driver<TSpec>;

package/types/make-manager.d.ts

@@ -17,8 +17,9 @@ type Options<TSpec extends SpecType> = {
     cwd?: string;
     logger: Logger;
     asyncCache?: AsyncCache;
+    offlineLocationPath?: string;
 };
-export declare function makeMakeManager<TSpec extends SpecType>({ spec, clients, core, base: defaultBase, agentId: defaultAgentId, environment, cwd, logger: mainLogger, asyncCache, }: Options<TSpec>): <TType extends "classic" | "ufg" = "classic">({ type, settings, logger, }?: {
+export declare function makeMakeManager<TSpec extends SpecType>({ spec, clients, core, base: defaultBase, agentId: defaultAgentId, environment, cwd, logger: mainLogger, asyncCache, offlineLocationPath, }: Options<TSpec>): <TType extends "classic" | "ufg" = "classic">({ type, settings, logger, }?: {
     type?: TType | undefined;
     settings?: ManagerSettings | undefined;
     logger?: Logger | undefined;

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

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

package/types/ufg/core.d.ts

@@ -17,6 +17,7 @@ type Options<TSpec extends SpecType> = {
     agentId?: string;
     cwd?: string;
     logger?: Logger;
+    offlineLocationPath?: string;
 };
-export declare function makeCore<TSpec extends SpecType>({ spec, clients, base: defaultBase, asyncCache, concurrency, fetchConcurrency, agentId, cwd, logger: defaultLogger, }: Options<TSpec>): Core<TSpec>;
+export declare function makeCore<TSpec extends SpecType>({ spec, clients, base: defaultBase, asyncCache, concurrency, offlineLocationPath, 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

@@ -5,8 +5,9 @@ type Options = {
     fetchConcurrency?: number;
     logger: Logger;
     asyncCache?: AsyncCache;
+    offlineLocationPath?: string;
 };
-export declare function makeGetUFGClient({ client, fetchConcurrency, logger: mainLogger, asyncCache }: Options): (({ settings, logger }: {
+export declare function makeGetUFGClient({ client, fetchConcurrency, offlineLocationPath, logger: mainLogger, asyncCache, }: Options): (({ settings, logger }: {
     settings: UFGClientSettings;
     logger?: Logger | undefined;
 }) => Promise<UFGClient>) & {

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

@@ -1,18 +1,16 @@
-import type { DriverTarget, Core, SnapshotSettings, Account, Snapshot } from './types';
-import { type Environment as UFGEnvironment } from '@applitools/ufg-client';
+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 } from '@applitools/driver';
+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>): ({ target, settings, environments: defaultEnvironments, account, logger, }: {
-    target: DriverTarget<TSpec>;
+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;
-    environments?: UFGEnvironment[] | undefined;
     account: Account;
     logger?: Logger | undefined;
 }) => Promise<Snapshot[]>;

package/types/ufg/types.d.ts

@@ -1,6 +1,6 @@
 import type { MaybeArray } from '@applitools/utils';
 import type * as AutomationCore from '../automation/types';
-import { type SpecType, type CommonSelector } from '@applitools/driver';
+import { type SpecType, type CommonSelector, type Driver } from '@applitools/driver';
 import { type Logger } from '@applitools/logger';
 import { type Proxy } from '@applitools/req';
 import { type UFGClient, type UFGClientSettings, type Selector as UFGSelector, type Environment as UFGEnvironment, type DomSnapshot as UFGDomSnapshot, type AndroidSnapshot as UFGAndroidSnapshot, type IOSSnapshot as UFGIOSSnapshot } from '@applitools/ufg-client';
@@ -13,7 +13,7 @@ export type DomSnapshot = UFGDomSnapshot & {
 };
 export type AndroidSnapshot = UFGAndroidSnapshot;
 export type IOSSnapshot = UFGIOSSnapshot;
-export type SnapshotTarget = MaybeArray<DomSnapshot> | MaybeArray<AndroidSnapshot> | MaybeArray<IOSSnapshot>;
+export type SnapshotTarget = MaybeArray<Snapshot>;
 export type Target<TSpec extends SpecType> = SnapshotTarget | AutomationCore.Target<TSpec>;
 export interface Core<TSpec extends SpecType> extends AutomationCore.Core<TSpec> {
     readonly type: 'ufg';
@@ -22,7 +22,7 @@ export interface Core<TSpec extends SpecType> extends AutomationCore.Core<TSpec>
         logger?: Logger;
     }): Promise<UFGClient>;
     takeSnapshots?(options: {
-        target: AutomationCore.DriverTarget<TSpec>;
+        driver: Driver<TSpec>;
         settings?: SnapshotSettings<TSpec>;
         account: AutomationCore.Account;
         logger?: Logger;

package/types/ufg/utils/generate-safe-selectors.d.ts

@@ -1,16 +1,22 @@
 import { type SpecType, type Context, type ElementReference, type CommonSelector } from '@applitools/driver';
-export declare function generateSafeSelectors<TSpec extends SpecType>({ context, elementReferences, }: {
-    context: Context<TSpec>;
-    elementReferences: ElementReference<TSpec>[];
-}): Promise<{
-    selectors: ({
-        safeSelector: null;
-        originalSelector: null;
-        elementReference: ElementReference<TSpec>;
-    } | {
-        safeSelector: CommonSelector;
+type GeneratedSafeSelector<TSpec extends SpecType> = {
+    selectors: {
+        safeSelector: CommonSelector | null;
         originalSelector: CommonSelector | null;
         elementReference: ElementReference<TSpec>;
-    })[];
+    }[];
     cleanupGeneratedSelectors: () => Promise<void>;
-}>;
+};
+export declare function generateSafeSelectors<TSpec extends SpecType>({ context, elementReferences, }: {
+    context: Context<TSpec>;
+    elementReferences: ElementReference<TSpec>[];
+}): Promise<GeneratedSafeSelector<TSpec>>;
+export declare function generateSafeSelectors<TSpec extends SpecType>({ context, elementReferences, }: {
+    context: Context<TSpec>;
+    elementReferences: undefined | [];
+}): Promise<undefined>;
+export declare function generateSafeSelectors<TSpec extends SpecType>({ context, elementReferences, }: {
+    context: Context<TSpec>;
+    elementReferences?: ElementReference<TSpec>[];
+}): Promise<GeneratedSafeSelector<TSpec> | undefined>;
+export {};

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

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

package/types/log-event.d.ts

@@ -1,12 +0,0 @@
-import type { MaybeArray } from '@applitools/utils';
-import type { Core, LogEventSettings } from './types';
-import { type Logger } from '@applitools/logger';
-type Options = {
-    core: Core<any>;
-    logger: Logger;
-};
-export declare function makeLogEvent({ core, logger: mainLogger }: Options): ({ settings, logger, }: {
-    settings: MaybeArray<LogEventSettings>;
-    logger?: Logger | undefined;
-}) => Promise<void>;
-export {};