@applitools/core 1.4.6 → 1.4.8

package/types/ufg/core.d.ts

@@ -1,16 +1,16 @@
 import type { Core } from './types';
 import type { Core as BaseCore } from '@applitools/core-base';
 import { type UFGClient } from '@applitools/ufg-client';
-import { type SpecDriver } from '@applitools/driver';
+import { type SpecType, type SpecDriver } from '@applitools/driver';
 import { type Logger } from '@applitools/logger';
-type Options<TDriver, TContext, TElement, TSelector> = {
+type Options<TSpec extends SpecType> = {
     concurrency: number;
-    spec?: SpecDriver<TDriver, TContext, TElement, TSelector>;
+    spec?: SpecDriver<TSpec>;
     client?: UFGClient;
     core?: BaseCore;
     agentId?: string;
     cwd?: string;
     logger?: Logger;
 };
-export declare function makeCore<TDriver, TContext, TElement, TSelector>({ concurrency, spec, client, core, agentId, cwd, logger, }: Options<TDriver, TContext, TElement, TSelector>): Core<TDriver, TContext, TElement, TSelector>;
+export declare function makeCore<TSpec extends SpecType>({ concurrency, spec, client, core, agentId, cwd, logger, }: Options<TSpec>): Core<TSpec>;
 export {};

package/types/ufg/get-base-eyes.d.ts

@@ -3,18 +3,18 @@ import type { Core as CoreBase, Eyes as EyesBase } from '@applitools/core-base';
 import { type Logger } from '@applitools/logger';
 import { type UFGClient, type Renderer } from '@applitools/ufg-client';
 type Options = {
-    settings?: OpenSettings;
+    settings: OpenSettings;
     eyes?: EyesBase[];
-    core?: CoreBase;
-    client?: UFGClient;
-    logger?: Logger;
+    core: CoreBase;
+    client: UFGClient;
+    logger: Logger;
 };
 export declare function makeGetBaseEyes({ settings: defaultSettings, core, client, eyes, logger: defaultLogger }: Options): (({ settings, logger, }?: {
     settings?: {
         type: 'web' | 'native';
         renderer: Renderer;
-    };
-    logger?: Logger;
+    } | undefined;
+    logger?: Logger | undefined;
 }) => Promise<EyesBase[]>) & {
     getCachedValues(): Promise<EyesBase<import("@applitools/core-base").ImageTarget>[]>[];
     setCachedValue(key: any, value: Promise<EyesBase<import("@applitools/core-base").ImageTarget>[]>): void;

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

@@ -0,0 +1,16 @@
+import type { GetResultsSettings, TestResult } from './types';
+import { type Logger } from '@applitools/logger';
+import { Renderer } from '@applitools/ufg-client';
+import { Eyes as baseEyes } from '@applitools/core-base';
+type Options = {
+    storage: Map<string, Promise<{
+        renderer: Renderer;
+        eyes: baseEyes;
+    }>[]>;
+    logger: Logger;
+};
+export declare function makeGetResults({ storage, logger: defaultLogger }: Options): ({ settings, logger, }?: {
+    settings?: GetResultsSettings | undefined;
+    logger?: Logger | undefined;
+}) => Promise<TestResult[]>;
+export {};

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

@@ -1,18 +1,18 @@
 import type { DriverTarget, Eyes, OpenSettings } from './types';
 import type { Core as BaseCore, Eyes as BaseEyes } from '@applitools/core-base';
 import { type Logger } from '@applitools/logger';
-import { type SpecDriver } from '@applitools/driver';
+import { type SpecType, type SpecDriver } from '@applitools/driver';
 import { type UFGClient } from '@applitools/ufg-client';
-type Options<TDriver, TContext, TElement, TSelector> = {
+type Options<TSpec extends SpecType> = {
     core: BaseCore;
     client?: UFGClient;
-    spec?: SpecDriver<TDriver, TContext, TElement, TSelector>;
-    logger?: Logger;
+    spec?: SpecDriver<TSpec>;
+    logger: Logger;
 };
-export declare function makeOpenEyes<TDriver, TContext, TElement, TSelector>({ core, client, spec, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): ({ target, settings, eyes, logger, }: {
-    target?: DriverTarget<TDriver, TContext, TElement, TSelector>;
+export declare function makeOpenEyes<TSpec extends SpecType>({ core, client, spec, logger: defaultLogger }: Options<TSpec>): ({ target, settings, eyes, logger, }: {
+    target?: DriverTarget<TSpec> | undefined;
     settings: OpenSettings;
-    eyes?: BaseEyes[];
-    logger?: Logger;
-}) => Promise<Eyes<TDriver, TContext, TElement, TSelector>>;
+    eyes?: BaseEyes<import("@applitools/core-base").ImageTarget>[] | undefined;
+    logger?: Logger | undefined;
+}) => Promise<Eyes<TSpec>>;
 export {};

package/types/ufg/types.d.ts

@@ -1,22 +1,23 @@
 import type { MaybeArray } from '@applitools/utils';
 import type * as BaseCore from '@applitools/core-base/types';
 import type * as AutomationCore from '../automation/types';
+import { type SpecType } from '@applitools/driver';
 import { type Logger } from '@applitools/logger';
 import { type Proxy } from '@applitools/req';
 import { type Renderer, type DomSnapshot, type AndroidSnapshot, type IOSSnapshot } from '@applitools/ufg-client';
 export * from '../automation/types';
 export type SnapshotTarget = MaybeArray<DomSnapshot> | MaybeArray<AndroidSnapshot> | MaybeArray<IOSSnapshot>;
-export type UFGTarget<TDriver, TContext, TElement, TSelector> = AutomationCore.DriverTarget<TDriver, TContext, TElement, TSelector> | SnapshotTarget;
-export interface Core<TDriver, TContext, TElement, TSelector, TEyes = Eyes<TDriver, TContext, TElement, TSelector>> extends AutomationCore.Core<TDriver, TContext, TElement, TSelector, TEyes> {
+export type Target<TSpec extends SpecType> = SnapshotTarget | AutomationCore.Target<TSpec>;
+export interface Core<TSpec extends SpecType, TTarget = AutomationCore.Target<TSpec>, TEyes extends Eyes<TSpec, TTarget | SnapshotTarget> = Eyes<TSpec, TTarget | SnapshotTarget>> extends AutomationCore.Core<TSpec, TTarget, TEyes> {
     readonly type: 'ufg';
     openEyes(options: {
-        target?: AutomationCore.DriverTarget<TDriver, TContext, TElement, TSelector>;
+        target?: AutomationCore.DriverTarget<TSpec>;
         settings: OpenSettings;
         eyes?: BaseCore.Eyes[];
         logger?: Logger;
     }): Promise<TEyes>;
 }
-export interface Eyes<TDriver, TContext, TElement, TSelector, TTarget = UFGTarget<TDriver, TContext, TElement, TSelector>> extends AutomationCore.Eyes<TDriver, TContext, TElement, TSelector, TTarget> {
+export interface Eyes<TSpec extends SpecType, TTarget = Target<TSpec>> extends AutomationCore.Eyes<TSpec, TTarget> {
     readonly type: 'ufg';
     getBaseEyes(options?: {
         settings?: {
@@ -27,28 +28,23 @@ export interface Eyes<TDriver, TContext, TElement, TSelector, TTarget = UFGTarge
     }): Promise<BaseCore.Eyes[]>;
     check(options?: {
         target?: TTarget;
-        settings?: CheckSettings<TElement, TSelector>;
+        settings?: CheckSettings<TSpec>;
         logger?: Logger;
     }): Promise<CheckResult[]>;
     checkAndClose(options?: {
         target?: TTarget;
-        settings?: CheckSettings<TElement, TSelector> & AutomationCore.CloseSettings;
+        settings?: CheckSettings<TSpec> & AutomationCore.CloseSettings;
         logger?: Logger;
     }): Promise<TestResult[]>;
-    locateText?: never;
-    extractText?: never;
-    close(options?: {
-        settings?: AutomationCore.CloseSettings;
-        logger?: Logger;
-    }): Promise<TestResult[]>;
-    abort(options?: {
+    getResults(options?: {
+        settings?: AutomationCore.GetResultsSettings;
         logger?: Logger;
     }): Promise<TestResult[]>;
 }
 export type OpenSettings = AutomationCore.OpenSettings & {
     renderConcurrency?: number;
 };
-export type CheckSettings<TElement, TSelector> = AutomationCore.CheckSettings<TElement, TSelector> & {
+export type CheckSettings<TSpec extends SpecType> = AutomationCore.CheckSettings<TSpec> & {
     renderers?: Renderer[];
     hooks?: {
         beforeCaptureScreenshot: string;
@@ -63,11 +59,13 @@ export type CheckSettings<TElement, TSelector> = AutomationCore.CheckSettings<TE
     };
 };
 export type CheckResult = AutomationCore.CheckResult & {
-    readonly renderer?: Renderer;
-    readonly promise?: Promise<Omit<CheckResult, 'promise'> & {
+    readonly renderer: Renderer;
+    readonly promise: Promise<Omit<CheckResult, 'promise'> & {
         eyes: BaseCore.Eyes;
     }>;
 };
 export type TestResult = AutomationCore.TestResult & {
-    readonly renderer?: Renderer;
+    readonly renderer: Renderer;
+} & {
+    eyes: BaseCore.Eyes;
 };

package/types/ufg/utils/extract-broker-url.d.ts

@@ -0,0 +1,6 @@
+import { type SpecType, type Driver } from '@applitools/driver';
+import { type Logger } from '@applitools/logger';
+export declare function extractBrokerUrl<TSpec extends SpecType>({ driver, logger, }: {
+    driver: Driver<TSpec>;
+    logger: Logger;
+}): Promise<string | null>;

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

@@ -1,12 +1,16 @@
-import { type Context, type Selector } from '@applitools/driver';
-export declare function generateSafeSelectors<TElement, TSelector>({ context, elementReferences, }: {
-    context: Context<unknown, unknown, TElement, TSelector>;
-    elementReferences: (TElement | Selector<TSelector>)[];
+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: Selector;
-        originalSelector: Selector;
-        elementReference: TElement | Selector<TSelector>;
-    }[];
-    cleanupGeneratedSelectors(): Promise<void>;
+    selectors: ({
+        safeSelector: null;
+        originalSelector: null;
+        elementReference: ElementReference<TSpec>;
+    } | {
+        safeSelector: CommonSelector<never>;
+        originalSelector: import("@applitools/driver").Selector<never> | null;
+        elementReference: ElementReference<TSpec>;
+    })[];
+    cleanupGeneratedSelectors: () => Promise<void>;
 }>;

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

@@ -1,6 +1,26 @@
 import { type Logger } from '@applitools/logger';
-import { type Context } from '@applitools/driver';
+import { type SpecType, type Context } from '@applitools/driver';
 import { type DomSnapshot } from '@applitools/ufg-client';
+type RawDomSnapshot = {
+    url: string;
+    selector: string;
+    cdt: {
+        attributes: {
+            name: string;
+            value: string;
+        }[];
+    }[];
+    crossFrames: {
+        selector: string;
+        index: number;
+    }[];
+    frames: RawDomSnapshot[];
+    resourceUrls: string[];
+    blobs: {
+        url: string;
+        value: string;
+    }[];
+};
 export type DomSnapshotSettings = {
     disableBrowserFetching?: boolean;
     skipResources?: string[];
@@ -9,16 +29,21 @@ export type DomSnapshotSettings = {
     pollTimeout?: number;
     showLogs?: boolean;
 };
-export declare function takeDomSnapshot<TContext extends Context<unknown, unknown, unknown, unknown>>({ context, settings, logger, }: {
-    context: TContext;
+export declare function takeDomSnapshot<TSpec extends SpecType>({ context, settings, logger, }: {
+    context: Context<TSpec>;
     settings?: DomSnapshotSettings;
     logger: Logger;
 }): Promise<DomSnapshot>;
 export declare function deserializeDomSnapshot({ snapshot }: {
-    snapshot: any;
-}): any;
-export declare function extractCrossFrames({ snapshot, parent, logger }: {
-    snapshot: any;
+    snapshot: RawDomSnapshot;
+}): DomSnapshot;
+export declare function extractCrossFrames({ snapshot, parent, logger, }: {
+    snapshot: RawDomSnapshot;
     parent?: any;
-    logger: any;
-}): any[];
+    logger: Logger;
+}): {
+    cdtNode: RawDomSnapshot['cdt'][number];
+    reference: any;
+    parentSnapshot: RawDomSnapshot;
+}[];
+export {};

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

@@ -1,6 +1,6 @@
 import type { Size } from '@applitools/utils';
 import { type Logger } from '@applitools/logger';
-import { type Driver } from '@applitools/driver';
+import { type SpecType, type Driver } from '@applitools/driver';
 import { type DomSnapshot, type Renderer, type ChromeEmulationDevice, type IOSDevice, type ScreenOrientation } from '@applitools/ufg-client';
 import { type DomSnapshotSettings } from './take-dom-snapshot';
 export * from './take-dom-snapshot';
@@ -9,8 +9,8 @@ export type DomSnapshotsSettings = DomSnapshotSettings & {
     waitBeforeCapture?: number | (() => void);
     layoutBreakpoints?: number[] | boolean;
 };
-export declare function takeDomSnapshots<TDriver extends Driver<unknown, unknown, unknown, unknown>>({ driver, settings, hooks, provides, logger, }: {
-    driver: TDriver;
+export declare function takeDomSnapshots<TSpec extends SpecType>({ driver, settings, hooks, provides, logger, }: {
+    driver: Driver<TSpec>;
     settings: DomSnapshotsSettings;
     hooks?: {
         beforeSnapshots?(): void | Promise<void>;

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

@@ -1,13 +1,13 @@
 import type { Size } from '@applitools/utils';
 import { type Logger } from '@applitools/logger';
-import { type Driver } from '@applitools/driver';
+import { type SpecType, type Driver } from '@applitools/driver';
 import { type DomSnapshot, type AndroidSnapshot, type IOSSnapshot, type ChromeEmulationDevice, type IOSDevice, type ScreenOrientation } from '@applitools/ufg-client';
 import { type DomSnapshotsSettings } from './take-dom-snapshots';
 import { type VHSesSettings } from './take-vhses';
 export * from './take-dom-snapshots';
 export * from './take-vhses';
-export declare function takeSnapshots<TDriver extends Driver<unknown, unknown, unknown, unknown>>({ driver, settings, hooks, provides, logger, }: {
-    driver: TDriver;
+export declare function takeSnapshots<TSpec extends SpecType>({ driver, settings, hooks, provides, logger, }: {
+    driver: Driver<TSpec>;
     settings: DomSnapshotsSettings & VHSesSettings;
     hooks: {
         beforeSnapshots?(): void | Promise<void>;
@@ -17,5 +17,5 @@ export declare function takeSnapshots<TDriver extends Driver<unknown, unknown, u
         getChromeEmulationDevices(): Promise<Record<ChromeEmulationDevice, Record<ScreenOrientation, Size>>>;
         getIOSDevices(): Promise<Record<IOSDevice, Record<ScreenOrientation, Size>>>;
     };
-    logger?: Logger;
+    logger: Logger;
 }): Promise<DomSnapshot[] | AndroidSnapshot[] | IOSSnapshot[]>;

package/types/ufg/utils/take-vhses.d.ts

@@ -1,14 +1,14 @@
 import type { ServerSettings } from '../types';
 import { type Logger } from '@applitools/logger';
-import { type Driver } from '@applitools/driver';
+import { type SpecType, type Driver } from '@applitools/driver';
 import { type Renderer, type AndroidSnapshot, type IOSSnapshot } from '@applitools/ufg-client';
 export type VHSesSettings = ServerSettings & {
     renderers: Renderer[];
     waitBeforeCapture?: number;
 };
-export declare function takeVHSes<TDriver extends Driver<unknown, unknown, unknown, unknown>>({ driver, settings, hooks, logger, }: {
-    driver: TDriver;
-    settings?: VHSesSettings;
+export declare function takeVHSes<TSpec extends SpecType>({ driver, settings, hooks, logger, }: {
+    driver: Driver<TSpec>;
+    settings: VHSesSettings;
     hooks?: {
         beforeSnapshots?(): void | Promise<void>;
         beforeEachSnapshot?(): void | Promise<void>;

package/types/utils/format-results.d.ts

@@ -13,4 +13,4 @@ export declare function toFlattenedTAPString(results: TestResult[], { markNewAsP
 export declare function toXmlOutput(results: TestResult[], { totalTime }?: {
     totalTime?: number;
 }): string;
-export declare function toJsonOutput(results: any, space: any): string;
+export declare function toJsonOutput(results: TestResult[], space?: number | string): string;

package/dist/utils/extract-broker-url.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractBrokerUrl = void 0;
-async function extractBrokerUrl(driver) {
-    try {
-        const selector = driver.isIOS
-            ? '//XCUIElementTypeOther[@name="Applitools_View"]'
-            : driver.isAndroid
-                ? '//android.widget.TextView[@content-desc="Applitools_View"]'
-                : null;
-        if (!selector)
-            return null;
-        const element = await driver.element({
-            type: 'xpath',
-            selector,
-        });
-        const result = JSON.parse(await element.getText());
-        return result.nextPath;
-    }
-    catch (error) {
-        return null;
-    }
-}
-exports.extractBrokerUrl = extractBrokerUrl;

package/types/classic/extract-text.d.ts

@@ -1,16 +0,0 @@
-import type { MaybeArray } from '@applitools/utils';
-import type { ClassicTarget, DriverTarget, Eyes, ExtractTextSettings } from './types';
-import { type Logger } from '@applitools/logger';
-import { type SpecDriver } from '@applitools/driver';
-type Options<TDriver, TContext, TElement, TSelector> = {
-    eyes: Eyes<TDriver, TContext, TElement, TSelector>;
-    target?: DriverTarget<TDriver, TContext, TElement, TSelector>;
-    spec?: SpecDriver<TDriver, TContext, TElement, TSelector>;
-    logger?: Logger;
-};
-export declare function makeExtractText<TDriver, TContext, TElement, TSelector>({ eyes, target: defaultTarget, spec, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): ({ target, settings, logger, }: {
-    target?: ClassicTarget<TDriver, TContext, TElement, TSelector>;
-    settings: MaybeArray<ExtractTextSettings<TElement, TSelector>>;
-    logger?: Logger;
-}) => Promise<string[]>;
-export {};

package/types/classic/locate-text.d.ts

@@ -1,15 +0,0 @@
-import type { ClassicTarget, DriverTarget, Eyes, LocateTextSettings, LocateTextResult } from './types';
-import { type Logger } from '@applitools/logger';
-import { type SpecDriver } from '@applitools/driver';
-type Options<TDriver, TContext, TElement, TSelector> = {
-    eyes: Eyes<TDriver, TContext, TElement, TSelector>;
-    target?: DriverTarget<TDriver, TContext, TElement, TSelector>;
-    spec?: SpecDriver<TDriver, TContext, TElement, TSelector>;
-    logger?: Logger;
-};
-export declare function makeLocateText<TDriver, TContext, TElement, TSelector>({ eyes, target: defaultTarget, spec, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): <TPattern extends string>({ target, settings, logger, }: {
-    target?: ClassicTarget<TDriver, TContext, TElement, TSelector>;
-    settings: LocateTextSettings<TPattern, TElement, TSelector>;
-    logger?: Logger;
-}) => Promise<LocateTextResult<TPattern>>;
-export {};

package/types/close-manager.d.ts

@@ -1,18 +0,0 @@
-import type { Eyes, TestResult, TestResultSummary } from './types';
-import type { Core as BaseCore } from '@applitools/core-base';
-import { type Logger } from '@applitools/logger';
-type Options<TDriver, TContext, TElement, TSelector, TType extends 'classic' | 'ufg'> = {
-    core: BaseCore<unknown>;
-    storage: {
-        eyes: Eyes<TDriver, TContext, TElement, TSelector, TType>;
-        promise?: Promise<TestResult<TType>[]>;
-    }[];
-    logger?: Logger;
-};
-export declare function makeCloseManager<TDriver, TContext, TElement, TSelector, TType extends 'classic' | 'ufg' = 'classic'>({ core, storage, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector, TType>): ({ settings, logger, }?: {
-    settings?: {
-        throwErr?: boolean;
-    };
-    logger?: Logger;
-}) => Promise<TestResultSummary<TType>>;
-export {};

package/types/utils/extract-broker-url.d.ts

@@ -1,2 +0,0 @@
-import { type Driver } from '@applitools/driver';
-export declare function extractBrokerUrl(driver: Driver<unknown, unknown, unknown, unknown>): Promise<string>;

package/types/utils/to-base-check-settings.d.ts

@@ -1,18 +0,0 @@
-import type { Region } from '@applitools/utils';
-import type { CheckSettings as BaseCheckSettings } from '@applitools/core-base';
-import type { CheckSettings as UFGCheckSettings } from '../ufg/types';
-import type { CheckSettings as ClassicCheckSettings } from '../ufg/types';
-import { type Selector } from '@applitools/driver';
-export declare function toBaseCheckSettings<TElement, TSelector>({ settings, }: {
-    settings: ClassicCheckSettings<TElement, TSelector> | UFGCheckSettings<TElement, TSelector>;
-}): {
-    elementReferencesToCalculate: (TElement | Selector<TSelector>)[];
-    elementReferenceToTarget: TElement | Selector<TSelector>;
-    getBaseCheckSettings: ({ calculatedRegions, preserveTransformation, }: {
-        calculatedRegions: {
-            selector: Selector;
-            regions: Region[];
-        }[];
-        preserveTransformation?: boolean;
-    }) => BaseCheckSettings;
-};