@applitools/core 1.0.0

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

@@ -0,0 +1,18 @@
+import type { SpecDriver } from '@applitools/types';
+import type { Core as BaseCore } from '@applitools/types/base';
+import type { Eyes, Target, OpenSettings } from '@applitools/types/ufg';
+import { type Logger } from '@applitools/logger';
+import { type UFGClient } from '@applitools/ufg-client';
+declare type Options<TDriver, TContext, TElement, TSelector> = {
+    core: BaseCore;
+    client?: UFGClient;
+    spec?: SpecDriver<TDriver, TContext, TElement, TSelector>;
+    logger?: Logger;
+};
+export declare function makeOpenEyes<TDriver, TContext, TElement, TSelector>({ spec, core, client, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): ({ target, settings, logger, }: {
+    target?: Target<TDriver>;
+    settings: OpenSettings;
+    logger?: Logger;
+    on?: any;
+}) => Promise<Eyes<TDriver, TElement, TSelector>>;
+export {};

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

@@ -0,0 +1,12 @@
+import type { Selector } from '@applitools/types';
+import { type Context } from '@applitools/driver';
+export declare function generateSafeSelectors<TElement, TSelector>({ context, elementReferences, }: {
+    context: Context<unknown, unknown, TElement, TSelector>;
+    elementReferences: (TElement | Selector<TSelector>)[];
+}): Promise<{
+    selectors: {
+        safeSelector: Selector;
+        originalSelector: Selector;
+    }[];
+    cleanupGeneratedSelectors(): Promise<void>;
+}>;

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

@@ -0,0 +1,23 @@
+import type { DomSnapshot } from '@applitools/types/ufg';
+import { type Logger } from '@applitools/logger';
+import { type Context } from '@applitools/driver';
+import { type PollScriptSettings } from '../../utils/execute-poll-script';
+export declare type DomSnapshotSettings = Partial<PollScriptSettings> & {
+    disableBrowserFetching?: boolean;
+    skipResources?: string[];
+    chunkByteLength?: number;
+    showLogs?: boolean;
+};
+export declare function takeDomSnapshot<TContext extends Context<unknown, unknown, unknown, unknown>>({ context, settings, logger, }: {
+    context: TContext;
+    settings?: DomSnapshotSettings;
+    logger: Logger;
+}): Promise<DomSnapshot>;
+export declare function deserializeDomSnapshot({ snapshot }: {
+    snapshot: any;
+}): any;
+export declare function extractCrossFrames({ snapshot, parent, logger }: {
+    snapshot: any;
+    parent?: any;
+    logger: any;
+}): any[];

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

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

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

@@ -0,0 +1,21 @@
+import type { Size, ChromeEmulationDevice, IOSDevice, ScreenOrientation } from '@applitools/types';
+import type { DomSnapshot, AndroidVHS, IOSVHS } from '@applitools/types/ufg';
+import { type Logger } from '@applitools/logger';
+import { type Driver } from '@applitools/driver';
+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;
+    settings: DomSnapshotsSettings & VHSesSettings;
+    hooks: {
+        beforeSnapshots?(): void | Promise<void>;
+        beforeEachSnapshot?(): void | Promise<void>;
+    };
+    provides: {
+        getChromeEmulationDevices(): Promise<Record<ChromeEmulationDevice, Record<ScreenOrientation, Size>>>;
+        getIOSDevices(): Promise<Record<IOSDevice, Record<ScreenOrientation, Size>>>;
+    };
+    logger?: Logger;
+}): Promise<DomSnapshot[] | AndroidVHS[] | IOSVHS[]>;

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

@@ -0,0 +1,17 @@
+import type { Renderer } from '@applitools/types';
+import type { ServerSettings, AndroidVHS, IOSVHS } from '@applitools/types/ufg';
+import { type Logger } from '@applitools/logger';
+import { type Driver } from '@applitools/driver';
+export declare 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;
+    hooks?: {
+        beforeSnapshots?(): void | Promise<void>;
+        beforeEachSnapshot?(): void | Promise<void>;
+    };
+    logger: Logger;
+}): Promise<AndroidVHS[] | IOSVHS[]>;

package/types/utils/execute-poll-script.d.ts

@@ -0,0 +1,20 @@
+import { type Context } from '@applitools/driver';
+import { type Logger } from '@applitools/logger';
+export declare type PollScriptSettings = {
+    executionTimeout: number;
+    pollTimeout: number;
+};
+declare type Script = {
+    script: string;
+    args: any[];
+};
+export declare function executePollScript<TContext extends Context<unknown, unknown, unknown, unknown>>({ context, scripts, settings, logger, }: {
+    context: TContext;
+    scripts: {
+        main: Script;
+        poll: Script;
+    };
+    settings: PollScriptSettings;
+    logger: Logger;
+}): Promise<any>;
+export {};

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

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

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

@@ -0,0 +1,16 @@
+import type { TestResult } from '@applitools/types/base';
+export declare function toFormatterString(results: TestResult[], { includeSubTests, markNewAsPassed }?: {
+    includeSubTests?: boolean;
+    markNewAsPassed?: boolean;
+}): string;
+export declare function toHierarchicTAPString(results: TestResult[], { includeSubTests, markNewAsPassed }?: {
+    includeSubTests?: boolean;
+    markNewAsPassed?: boolean;
+}): string;
+export declare function toFlattenedTAPString(results: TestResult[], { markNewAsPassed }?: {
+    markNewAsPassed?: boolean;
+}): string;
+export declare function toXmlOutput(results: TestResult[], { totalTime }?: {
+    totalTime?: number;
+}): string;
+export declare function toJsonOutput(results: any, space: any): string;

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

@@ -0,0 +1,17 @@
+import { Region, Selector } from '@applitools/types';
+import { CheckSettings as BaseCheckSettings } from '@applitools/types/base';
+import { CheckSettings as ClassicCheckSettings } from '@applitools/types/classic';
+import { CheckSettings as UFGCheckSettings } from '@applitools/types/ufg';
+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;
+};

package/types/utils/wait-for-lazy-load.d.ts

@@ -0,0 +1,13 @@
+import { type Logger } from '@applitools/logger';
+import { type Driver } from '@applitools/driver';
+import { type PollScriptSettings } from './execute-poll-script';
+export declare type LazyLoadSettings = Partial<PollScriptSettings> & {
+    scrollLength?: number;
+    waitingTime?: number;
+    maxAmountToScroll?: number;
+};
+export declare function waitForLazyLoad<TDriver extends Driver<unknown, unknown, unknown, unknown>>({ driver, settings, logger, }: {
+    driver: TDriver;
+    settings: LazyLoadSettings;
+    logger: Logger;
+}): Promise<void>;