@applitools/core 4.74.1 → 4.75.0

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

@@ -1,15 +1,16 @@
-import type { DriverTarget, Core, Eyes, EyesStorage, OpenSettings } from './types';
+import type { DriverTarget, Core, Eyes, OpenSettings } from './types';
 import { type Logger } from '@applitools/logger';
 import { type SpecType, type SpecDriver } from '@applitools/driver';
+import { type Session } from '../tasks';
 type Options<TSpec extends SpecType> = {
     core: Core<TSpec>;
     spec?: SpecDriver<TSpec>;
     logger: Logger;
 };
-export declare function makeOpenEyes<TSpec extends SpecType>({ core, spec, logger: mainLogger }: Options<TSpec>): ({ target, settings, storage, logger, }: {
+export declare function makeOpenEyes<TSpec extends SpecType>({ core, spec, logger: mainLogger }: Options<TSpec>): ({ target, settings, session, logger, }: {
     target?: DriverTarget<TSpec> | undefined;
     settings: OpenSettings;
-    storage?: EyesStorage | undefined;
+    session?: object | undefined;
     logger?: Logger | undefined;
 }) => Promise<Eyes<TSpec>>;
 export {};

package/types/classic/types.d.ts

@@ -7,7 +7,7 @@ export interface Core<TSpec extends SpecType> extends AutomationCore.Core<TSpec>
     openEyes(options: {
         target?: AutomationCore.DriverTarget<TSpec>;
         settings: OpenSettings;
-        storage?: AutomationCore.EyesStorage;
+        session?: AutomationCore.Session;
         logger?: Logger;
     }): Promise<Eyes<TSpec>>;
 }

package/types/classic/utils/capture.d.ts

@@ -0,0 +1,21 @@
+import type { CheckSettings, Eyes, Environment, ExactEnvironment } from '../types';
+import type { Target as BaseTarget, CheckSettings as BaseCheckSettings } from '@applitools/core-base';
+import { type Logger } from '@applitools/logger';
+import type { SpecType, Driver } from '@applitools/driver';
+export type Captured = {
+    baseTarget: BaseTarget;
+    baseSetting: BaseCheckSettings;
+    exactEnvironment: ExactEnvironment;
+};
+type DriverEnvironment = Awaited<ReturnType<Driver<SpecType>['getEnvironment']>>;
+/** Whether the capture keeps `environment` as its exact environment, at the same index. */
+export declare function isCapturedAsRequested(settings: CheckSettings<SpecType>, driverEnvironment: DriverEnvironment, environment: Environment): boolean;
+/**
+ * create base targets (array of screenshots) and base settings (array of check settings) for each environment
+ */
+export declare function generateBaseScreenshotsAndSettings<TSpec extends SpecType>(settings: CheckSettings<TSpec>, uniqueEnvironments: Environment[], eyes: Eyes<TSpec>, logger: Logger, driver: Driver<TSpec>): Promise<{
+    baseTarget: BaseTarget;
+    baseSetting: BaseCheckSettings;
+    exactEnvironment: ExactEnvironment;
+}[]>;
+export {};

package/types/tasks/abort.d.ts

@@ -0,0 +1,11 @@
+import type { AbortInputs, Labels, Graph } from './types';
+/**
+ * Aborts the environment's session as soon as it is open, without waiting for its steps (they read the
+ * abort signal), unless an abort is already queued. A pending close or matchAndEnd still gets it; core-base ends a
+ * session only once. Kind `dismiss`: if the open is still lazy (nothing needed it), it's discarded and no session
+ * opens.
+ */
+export declare function add(graph: Graph, { inputs, labels }: {
+    inputs: AbortInputs;
+    labels: Labels;
+}): import("@applitools/task-manager").Task<void, AbortInputs, Labels>;

package/types/tasks/aborted-check.d.ts

@@ -0,0 +1,9 @@
+import type { Labels, Graph, AbortedCheckInputs } from './types';
+/**
+ * A check the test was aborted during, before it added its steps: it fails with the abort and is kept by its
+ * session, so the environment's getResults rejects with it.
+ */
+export declare function add(graph: Graph, { inputs, labels }: {
+    inputs: AbortedCheckInputs;
+    labels: Labels;
+}): import("@applitools/task-manager").Task<never, AbortedCheckInputs, Labels>;

package/types/tasks/classic/capture.d.ts

@@ -0,0 +1,10 @@
+import { type Captured } from '../../classic/utils/capture';
+import type { Labels, Graph, CaptureInputs } from '../types';
+/**
+ * A classic check's capture of every environment in one pass — they share the driver, whose viewport
+ * it resizes per environment. The check awaits it, so the page stays untouched until it's done.
+ */
+export declare function add(graph: Graph, { inputs, labels }: {
+    inputs: CaptureInputs;
+    labels: Labels;
+}): import("@applitools/task-manager").Task<Captured[], CaptureInputs, Labels>;

package/types/tasks/classic/steps.d.ts

@@ -0,0 +1,17 @@
+import type { Captured } from '../../classic/utils/capture';
+import type { Session, OpenInputs, CaptureInputs, UploadInputs, MatchInputs, CloseInputs, GraphTask } from '../types';
+/** A classic step uploads its target, read by index from the check's capture. */
+export type Step = {
+    open: OpenInputs;
+    upload: UploadInputs;
+    capture?: GraphTask<Captured[]>;
+    inputs: MatchInputs;
+};
+/** A check step: its upload, then its match after the environment's previous one. */
+export declare function addCheck(session: Session, env: string, step: Step): import("@applitools/task-manager").Task<import("../types").MatchResult, MatchInputs, import("../types").Labels>;
+/** A check step and the close it fuses into: one `matchAndEnd`. */
+export declare function addCheckAndClose(session: Session, env: string, { settings, ...step }: Step & {
+    settings?: CloseInputs['settings'];
+}): void;
+/** A classic check's capture; its steps read their targets from it by index. */
+export declare function addCapture(session: Session, inputs: CaptureInputs): import("@applitools/task-manager").Task<Captured[], CaptureInputs, import("../types").Labels>;

package/types/tasks/classic/upload.d.ts

@@ -0,0 +1,14 @@
+import type { Eyes as BaseEyes } from '@applitools/core-base';
+import type { Captured } from '../../classic/utils/capture';
+import type { MatchTarget, Labels, Graph, UploadInputs, GraphTask } from '../types';
+type UploadDeps = {
+    open: GraphTask<BaseEyes>;
+    capture?: GraphTask<Captured[]>;
+};
+/** The slow leg of a classic check step: normalize the captured target and upload its resources. */
+export declare function add(graph: Graph, { deps, inputs, labels }: {
+    deps: Omit<UploadDeps, 'open'>;
+    inputs: UploadInputs;
+    labels: Labels;
+}): import("@applitools/task-manager").Task<MatchTarget | undefined, UploadInputs, Labels>;
+export {};

package/types/tasks/close.d.ts

@@ -0,0 +1,9 @@
+import type { CloseInputs, Labels, Graph } from './types';
+/**
+ * The environment's terminal close, unless a close, abort or fused match already ends it. Kind `dismiss`: if the
+ * open is still lazy (nothing needed it), it's discarded and no session opens.
+ */
+export declare function add(graph: Graph, { inputs, labels }: {
+    inputs: CloseInputs;
+    labels: Labels;
+}): import("@applitools/task-manager").Task<void | import("./types").MatchResult, import("./types").MatchAndEndInputs | CloseInputs | import("./types").AbortInputs, Labels>;

package/types/tasks/fill.d.ts

@@ -0,0 +1,8 @@
+import type { Labels, Graph } from './types';
+/**
+ * An empty test's environment that still gets a session: as a normal dependent, it activates the lazy open, so
+ * the close or abort resting on it can't dismiss it.
+ */
+export declare function add(graph: Graph, { labels }: {
+    labels: Labels;
+}): import("@applitools/task-manager").Task<void, undefined, Labels>;

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

@@ -0,0 +1,6 @@
+import type { Labels, Graph, GetResultsInputs } from './types';
+/** The environment's result, once everything else in it has settled. */
+export declare function add(graph: Graph, { inputs, labels }: {
+    inputs: GetResultsInputs;
+    labels: Labels;
+}): import("@applitools/task-manager").Task<import("./types").EnvironmentResult, GetResultsInputs, Labels>;

package/types/tasks/graph.d.ts

@@ -0,0 +1,3 @@
+import type { Graph } from './types';
+/** Core's one task graph — every test is a disjoint tree in it. */
+export declare const graph: Graph;

package/types/tasks/index.d.ts

@@ -0,0 +1,3 @@
+export * from './lifecycle';
+export { activeEnvironmentKeys } from './queries';
+export type { Session, MatchInputs, GraphTask } from './types';

package/types/tasks/lifecycle.d.ts

@@ -0,0 +1,23 @@
+import type { Logger } from '@applitools/logger';
+import type { Session, OpenInputs, CloseInputs, AbortInputs, GetResultsInputs, EnvironmentResult } from './types';
+/**
+ * Declares the opens of the environments known at openEyes, lazy: the first check needing one opens it,
+ * and a close that finds it still unneeded dismisses it, so no empty session is created.
+ */
+export declare function declareOpens(eyes: OpenInputs['eyes'], environments: OpenInputs['environment'][], driver: OpenInputs['driver'], logger: Logger): void;
+/**
+ * Fills an empty test's environments, so it still has a session per environment: the ones its close names
+ * (declared here), or else a classic test's declared ones. An empty ufg test that names none opens nothing.
+ * Returns the filled environments' opens.
+ */
+export declare function declareFillers(eyes: OpenInputs['eyes'], environments: OpenInputs['environment'][] | undefined, logger: Logger): import("@applitools/task-manager").Task<import("@applitools/core-base").Eyes, OpenInputs, import("./types").Labels>[];
+/** Closes every environment of the session; a still-unstarted last match fuses into its close. */
+export declare function closeSession(session: Session, inputs: CloseInputs): void;
+/** Aborts every environment of the session as soon as it is open, without waiting for its steps. */
+export declare function abortSession(session: Session, inputs: AbortInputs): void;
+/** Closes the environment after its last step. */
+export declare function addClose(session: Session, env: string, inputs: CloseInputs): void;
+/** The environment's result, after every unfinished task of it — its last match, close or abort. */
+export declare function getResults(session: Session, env: string, inputs: GetResultsInputs): Promise<EnvironmentResult>;
+/** Records a check the test was aborted during, before it added its steps (see `aborted-check.ts`). */
+export declare function addAbortedCheck(eyes: OpenInputs['eyes'], environments: OpenInputs['environment'][], message: string, logger: Logger): void;

package/types/tasks/match.d.ts

@@ -0,0 +1,13 @@
+import type { Eyes as BaseEyes } from '@applitools/core-base';
+import type { MatchTarget, MatchResult, MatchInputs, Labels, Graph, GraphTask } from './types';
+type MatchDeps = {
+    open: GraphTask<BaseEyes>;
+    upload: GraphTask<MatchTarget | undefined>;
+};
+/** A check step. While still unstarted, it fuses with a `close` added after it into one `matchAndEnd`. */
+export declare function add(graph: Graph, { deps, inputs, labels }: {
+    deps: Omit<MatchDeps, 'open'>;
+    inputs: MatchInputs;
+    labels: Labels;
+}): import("@applitools/task-manager").Task<MatchResult, MatchInputs, Labels>;
+export {};

package/types/tasks/open.d.ts

@@ -0,0 +1,10 @@
+import type { Eyes as BaseEyes } from '@applitools/core-base';
+import type { OpenInputs, Labels, Graph } from './types';
+/**
+ * An environment's base-session open — the root of its chain, one per environment: the environment's existing
+ * open, or a new one. Lazy until a dependent needs it.
+ */
+export declare function add(graph: Graph, { inputs, labels }: {
+    inputs: OpenInputs;
+    labels: Labels;
+}): import("@applitools/task-manager").Task<BaseEyes, OpenInputs, Labels>;

package/types/tasks/queries.d.ts

@@ -0,0 +1,15 @@
+import type { Session, Labels, TaskType, Result, Inputs } from './types';
+export declare function queryTasks<K extends TaskType>({ session, type, env }: {
+    session: Session;
+    type: K;
+    env?: string;
+}): import("@applitools/task-manager").Task<Result<K>, Inputs<K>, Labels>[];
+/** The environment's newest open — every task of the environment rests on it. */
+export declare function environmentOpen({ session, env }: Labels): import("@applitools/task-manager").Task<import("@applitools/core-base").Eyes, import("./types").OpenInputs, Labels>;
+/** The environment's newest unfinished step — its match, or the recheck after it. */
+export declare function lastStep(session: Session, env: string): import("@applitools/task-manager").Task<import("./types").MatchResult, import("./types").MatchInputs, Labels> | import("@applitools/task-manager").Task<void, import("./types").RecheckInputs, Labels> | undefined;
+export declare function environmentKeys(session: Session): string[];
+/** The environment keys whose open was demanded, not just speculatively pre-created. */
+export declare function openedEnvironmentKeys(session: Session): string[];
+/** The environments getResults reports: the opened ones, and those of a check the test was aborted during. */
+export declare function activeEnvironmentKeys(session: Session): string[];

package/types/tasks/types.d.ts

@@ -0,0 +1,187 @@
+import type { Eyes as BaseEyes, Target, CheckSettings, CloseSettings, AbortSettings, GetResultsSettings, TestResult } from '@applitools/core-base';
+import type { Snapshot } from '../ufg/types';
+import type { Eyes, Environment } from '../automation/types';
+import type { Eyes as ClassicEyes, CheckSettings as ClassicCheckSettings } from '../classic/types';
+import type { Captured } from '../classic/utils/capture';
+import type { Driver } from '@applitools/driver';
+import type { UFGClient, RenderTarget, Environment as UFGEnvironment } from '@applitools/ufg-client';
+import type { Logger } from '@applitools/logger';
+import type { Task, TaskManager, TaskSpec, Deps } from '@applitools/task-manager';
+import type { AbortSignal } from 'abort-controller';
+import type { buildAccessibilityReportOptions } from '../ufg/build-accessibility-report-options';
+/** A test's identity in the graph: its tasks carry it in their labels, and it keeps their opens queryable. */
+export type Session = object;
+/** Where a task belongs: its test and environment. */
+export type Labels = {
+    session: Session;
+    env: string;
+};
+export type MatchTarget = {
+    target: Target;
+    settings: CheckSettings;
+};
+export type MatchResult = {
+    asExpected: boolean;
+};
+export type EnvironmentResult = TestResult & {
+    environment: BaseEyes['test']['environment'];
+};
+/** An environment's open. `eyes.type` picks the opener. */
+export type OpenInputs = {
+    eyes: Eyes<any>;
+    environment: Environment;
+    driver?: Driver<any>;
+    logger: Logger;
+};
+/** A classic check's capture of every environment. */
+export type CaptureInputs = {
+    eyes: ClassicEyes<any>;
+    driver: Driver<any>;
+    settings: ClassicCheckSettings<any>;
+    environments: Environment[];
+    /** A `matchTimeout` check's first capture: it waits for the opens (`deps`), and this long more on a new test. */
+    newTestDelay?: number;
+    logger: Logger;
+};
+/** A classic step's target: captured already, or its `index` in the check's still-running capture. */
+export type UploadInputs = (MatchTarget | {
+    index: number;
+}) & {
+    signal?: AbortSignal;
+    logger: Logger;
+};
+export type CreateRenderTargetInputs = {
+    ufgClient: UFGClient;
+    snapshot: Snapshot;
+    logger: Logger;
+};
+export type RenderInputs = {
+    ufgClient: UFGClient;
+    snapshot: Snapshot;
+    environment: UFGEnvironment;
+    /** Set only when the check configures an accessibility standard; each render then mints its own report URL. */
+    accessibility?: Parameters<typeof buildAccessibilityReportOptions>[0];
+    signal?: AbortSignal;
+    logger: Logger;
+};
+export type MatchInputs = {
+    canFuse: boolean;
+    /** Set when the check's target assumes mutability: the step logs that. */
+    mutability?: {
+        eyes: Eyes<any>;
+        checkName?: string;
+    };
+    signal?: AbortSignal;
+    onError?: (error: any, baseEyes: BaseEyes) => void;
+    logger: Logger;
+};
+export type RecheckInputs = {
+    /** The step's render, retargeted at the previous browser version. */
+    render: RenderInputs;
+    /** Sessions whose backend stopped expecting old-infra retries. */
+    disabled: WeakSet<BaseEyes>;
+    logger: Logger;
+};
+export type MatchAndEndInputs = {
+    match: MatchInputs;
+    settings?: CloseSettings;
+};
+export type CloseInputs = {
+    settings?: CloseSettings;
+    logger: Logger;
+};
+export type AbortInputs = {
+    settings?: AbortSettings;
+    logger: Logger;
+};
+export type GetResultsInputs = {
+    settings?: GetResultsSettings;
+    logger: Logger;
+};
+export type AbortedCheckInputs = {
+    error: Error;
+};
+/** Each core task type's result and inputs. */
+interface TaskContracts {
+    open: {
+        result: BaseEyes;
+        inputs: OpenInputs;
+    };
+    capture: {
+        result: Captured[];
+        inputs: CaptureInputs;
+    };
+    upload: {
+        result: MatchTarget | undefined;
+        inputs: UploadInputs;
+    };
+    createRenderTarget: {
+        result: RenderTarget;
+        inputs: CreateRenderTargetInputs;
+    };
+    render: {
+        result: MatchTarget;
+        inputs: RenderInputs;
+    };
+    match: {
+        result: MatchResult;
+        inputs: MatchInputs;
+    };
+    matchAndEnd: {
+        result: MatchResult;
+        inputs: MatchAndEndInputs;
+    };
+    recheck: {
+        result: void;
+        inputs: RecheckInputs;
+    };
+    fill: {
+        result: void;
+        inputs: undefined;
+    };
+    close: {
+        result: void;
+        inputs: CloseInputs;
+    };
+    abort: {
+        result: void;
+        inputs: AbortInputs;
+    };
+    getResults: {
+        result: EnvironmentResult;
+        inputs: GetResultsInputs;
+    };
+    abortedCheck: {
+        result: never;
+        inputs: AbortedCheckInputs;
+    };
+}
+export type TaskType = keyof TaskContracts;
+export type Result<K extends TaskType> = TaskContracts[K]['result'];
+export type Inputs<K extends TaskType> = TaskContracts[K]['inputs'];
+/** A task of core's graph, by its result. */
+export type GraphTask<TResult = unknown> = Task<TResult, unknown, Labels>;
+/** Any core task, discriminated by `type`. */
+type CoreTask = {
+    [K in TaskType]: Task<Result<K>, Inputs<K>, Labels> & {
+        readonly type: K;
+    };
+}[TaskType];
+/** A collapse replacement for a `K` task: a task of a type whose result the fused originals settle with. */
+type Replacement<K extends TaskType, TDeps extends Deps<Labels>> = {
+    [R in TaskType]: Result<R> extends Result<K> ? Omit<TaskSpec<Result<R>, Inputs<R>, Labels, TDeps>, 'deps' | 'after'> & {
+        type: R;
+    } : never;
+}[TaskType];
+/**
+ * Core's graph. `add` holds every task, and every collapse replacement, to its type's contract, so a query by type
+ * can rely on it, and a `collapse` can tell its successor apart by type.
+ */
+export interface Graph {
+    add<K extends TaskType, TDeps extends Deps<Labels> = Deps<Labels>>(spec: Omit<TaskSpec<Result<K>, Inputs<K>, Labels, TDeps>, 'collapse'> & {
+        type: K;
+        collapse?(successor: CoreTask): Replacement<K, TDeps> | undefined;
+    }): Task<Result<K>, Inputs<K>, Labels>;
+    filter: TaskManager<Labels>['filter'];
+}
+export {};

package/types/tasks/ufg/create-render-target.d.ts

@@ -0,0 +1,11 @@
+import type { RenderTarget } from '@applitools/ufg-client';
+import type { Labels, Graph, CreateRenderTargetInputs } from '../types';
+/**
+ * Processes a ufg snapshot's resources as soon as the check is called, before its session opens: it fills the
+ * UFG client's resource cache, which the next snapshot reads as its skip-list, so an already-fetched (e.g.
+ * ephemeral) resource is not re-requested and the renders stay identical.
+ */
+export declare function add(graph: Graph, { inputs, labels }: {
+    inputs: CreateRenderTargetInputs;
+    labels: Labels;
+}): import("@applitools/task-manager").Task<RenderTarget, CreateRenderTargetInputs, Labels>;

package/types/tasks/ufg/recheck.d.ts

@@ -0,0 +1,20 @@
+import type { Eyes as BaseEyes } from '@applitools/core-base';
+import type { RenderTarget } from '@applitools/ufg-client';
+import type { MatchResult, Labels, Graph, RecheckInputs, GraphTask } from '../types';
+type RecheckDeps = {
+    open: GraphTask<BaseEyes>;
+    match: GraphTask<MatchResult>;
+    renderTarget: GraphTask<RenderTarget>;
+};
+/**
+ * The old-infra retry of a ufg check step: when the backend asks for it, re-checks a mismatch against the
+ * previous browser version before the next step, and stops once a retry fails (the backend then stops
+ * expecting retries). Best-effort: a failed retry must not abort the environment — the primary match
+ * already recorded its step.
+ */
+export declare function add(graph: Graph, { deps, inputs, labels }: {
+    deps: Omit<RecheckDeps, 'open'>;
+    inputs: RecheckInputs;
+    labels: Labels;
+}): import("@applitools/task-manager").Task<void, RecheckInputs, Labels>;
+export {};

package/types/tasks/ufg/render.d.ts

@@ -0,0 +1,15 @@
+import type { Eyes as BaseEyes } from '@applitools/core-base';
+import type { RenderTarget } from '@applitools/ufg-client';
+import type { MatchTarget, Labels, Graph, RenderInputs, GraphTask } from '../types';
+type RenderDeps = {
+    open: GraphTask<BaseEyes>;
+    renderTarget: GraphTask<RenderTarget>;
+};
+/** The slow leg of a ufg check step: render the snapshot, then normalize and upload the result. */
+export declare function add(graph: Graph, { deps, inputs, labels }: {
+    deps: Omit<RenderDeps, 'open'>;
+    inputs: RenderInputs;
+    labels: Labels;
+}): import("@applitools/task-manager").Task<MatchTarget, RenderInputs, Labels>;
+export declare function render(baseEyes: BaseEyes, renderTarget: RenderTarget, { ufgClient, snapshot, environment, accessibility, signal, logger }: RenderInputs): Promise<MatchTarget>;
+export {};

package/types/tasks/ufg/steps.d.ts

@@ -0,0 +1,15 @@
+import type { Session, OpenInputs, CreateRenderTargetInputs, RenderInputs, RecheckInputs, MatchInputs, CloseInputs } from '../types';
+/** A ufg step renders its snapshot, and may recheck its match. */
+export type Step = {
+    open: OpenInputs;
+    renderTarget: CreateRenderTargetInputs;
+    render: RenderInputs;
+    recheck?: RecheckInputs;
+    inputs: MatchInputs;
+};
+/** A check step: its render, then its match after the environment's previous one, then its old-infra recheck. */
+export declare function addCheck(session: Session, env: string, step: Step): import("@applitools/task-manager").Task<import("../types").MatchResult, MatchInputs, import("../types").Labels>;
+/** A check step and the close it fuses into: one `matchAndEnd`. */
+export declare function addCheckAndClose(session: Session, env: string, { settings, ...step }: Step & {
+    settings?: CloseInputs['settings'];
+}): void;

package/types/tasks/upload-target.d.ts

@@ -0,0 +1,5 @@
+import { type Eyes as BaseEyes } from '@applitools/core-base';
+import type { Logger } from '@applitools/logger';
+import type { MatchTarget } from './types';
+/** Normalizes a step's target and uploads its resources — the tail shared by `upload` and `render`. */
+export declare function uploadTarget(baseEyes: BaseEyes, step: MatchTarget, logger: Logger): Promise<MatchTarget>;

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

@@ -1,15 +1,10 @@
-import type { Eyes, GetBaseEyesSettings, OpenSettings } from './types';
+import type { Eyes } from './types';
 import type { Eyes as BaseEyes } from '@applitools/core-base';
 import { type SpecType } from '@applitools/driver';
 import { type Logger } from '@applitools/logger';
-type Options<TSpec extends SpecType> = {
-    settings: OpenSettings;
+import type { OpenInputs } from '../tasks/types';
+export declare function getBaseEyes<TSpec extends SpecType>({ eyes, settings, logger, }: {
     eyes: Eyes<TSpec>;
-    base?: BaseEyes[];
+    settings: Pick<OpenInputs, 'environment' | 'driver'>;
     logger: Logger;
-};
-export declare function makeGetBaseEyes<TSpec extends SpecType>({ settings: defaultSettings, eyes, logger: mainLogger, }: Options<TSpec>): ({ settings, logger, }: {
-    settings: GetBaseEyesSettings<TSpec>;
-    logger?: Logger | undefined;
-}) => Promise<BaseEyes>;
-export {};
+}): Promise<BaseEyes>;

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

@@ -1,15 +1,16 @@
-import type { DriverTarget, Core, Eyes, EyesStorage, OpenSettings } from './types';
+import type { DriverTarget, Core, Eyes, OpenSettings } from './types';
 import { type Logger } from '@applitools/logger';
 import { type SpecType, type SpecDriver } from '@applitools/driver';
+import { type Session } from '../tasks';
 type Options<TSpec extends SpecType> = {
     core: Core<TSpec>;
     spec?: SpecDriver<TSpec>;
     logger: Logger;
 };
-export declare function makeOpenEyes<TSpec extends SpecType>({ core, spec, logger: mainLogger }: Options<TSpec>): ({ target, settings, storage, logger, }: {
+export declare function makeOpenEyes<TSpec extends SpecType>({ core, spec, logger: mainLogger }: Options<TSpec>): ({ target, settings, session, logger, }: {
     target?: DriverTarget<TSpec> | undefined;
     settings: OpenSettings;
-    storage?: EyesStorage | undefined;
+    session?: object | undefined;
     logger?: Logger | undefined;
 }) => Promise<Eyes<TSpec>>;
 export {};

package/types/ufg/types.d.ts

@@ -32,7 +32,7 @@ export interface Core<TSpec extends SpecType> extends AutomationCore.Core<TSpec>
     openEyes(options: {
         target?: AutomationCore.DriverTarget<TSpec>;
         settings: AutomationCore.OpenSettings;
-        storage?: AutomationCore.EyesStorage;
+        session?: AutomationCore.Session;
         logger?: Logger;
     }): Promise<Eyes<TSpec>>;
 }

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

@@ -16,6 +16,7 @@ type ExtractGitBranchingTimestampOptions = {
 type ExtractCurrentCommitTimestampOptions = {
     execOptions?: ExecOptions;
     logger?: Logger;
+    ignoreGitBranching?: boolean;
 };
 export declare const cacheKey = "default";
 /** Primary remote name (cached). Prefers `origin`, else the first remote. */
@@ -114,7 +115,7 @@ export declare const extractDefaultBranch: (({ execOptions, logger }: {
     clearCache(): void;
     TTL?: number | undefined;
 };
-export declare const extractLatestCommitInfo: (({ execOptions, logger, }: ExtractCurrentCommitTimestampOptions) => Promise<{
+export declare const extractLatestCommitInfo: (({ execOptions, logger, ignoreGitBranching, }: ExtractCurrentCommitTimestampOptions) => Promise<{
     timestamp: string;
     sha: string;
 } | undefined>) & {