@applitools/driver 1.11.27 → 1.11.29

package/dist/context.js

@@ -30,8 +30,7 @@ const specUtils = __importStar(require("./spec-utils"));
 const snippets = require('@applitools/snippets');
 class Context {
     _isReference(reference) {
-        return (reference instanceof Context ||
-            utils.types.isInteger(reference) ||
+        return (utils.types.isInteger(reference) ||
             utils.types.isString(reference) ||
             reference instanceof element_1.Element ||
             this._spec.isElement(reference) ||
@@ -47,14 +46,12 @@ class Context {
                 this._target = options.context;
             }
             else {
-                throw new TypeError('Context constructor called with argument of unknown type of context!');
+                throw new TypeError('Context constructor called with target context of unknown type');
             }
         }
         if (this._isReference(options.reference)) {
-            if (options.reference instanceof Context)
-                return options.reference;
             if (!options.parent) {
-                throw new TypeError('Cannot construct child context without reference to the parent');
+                throw new TypeError('Cannot construct child context without parent context');
             }
             this._reference = options.reference;
             this._parent = options.parent;
@@ -66,7 +63,7 @@ class Context {
             this._driver = options.driver;
         }
         else {
-            throw new TypeError('Context constructor called with argument of unknown type!');
+            throw new TypeError('Context constructor called with context reference of unknown type!');
         }
     }
     get target() {
@@ -250,6 +247,8 @@ class Context {
             return new Context({ spec: this._spec, parent: this, driver: this.driver, reference, logger: this._logger });
         }
         else if (utils.types.has(reference, 'reference')) {
+            if (reference.reference instanceof Context)
+                return this;
             const parent = reference.parent ? await this.context(reference.parent) : this;
             return new Context({
                 spec: this._spec,

package/dist/driver.js

@@ -797,9 +797,7 @@ function isDriver(driver, spec) {
 }
 exports.isDriver = isDriver;
 async function makeDriver(options) {
-    const driver = options.driver instanceof Driver
-        ? options.driver
-        : new Driver(options);
+    const driver = options.driver instanceof Driver ? options.driver : new Driver(options);
     await driver.init();
     await driver.refreshContexts();
     return driver;

package/dist/element.js

@@ -649,9 +649,9 @@ class Element {
             this._originalOverflow = null;
         });
     }
-    async refresh(freshElement) {
-        if (this._spec.isElement(freshElement)) {
-            this._target = freshElement;
+    async refresh(freshTarget) {
+        if (this._spec.isElement(freshTarget)) {
+            this._target = freshTarget;
             return true;
         }
         if (!this._selector)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applitools/driver",
-  "version": "1.11.27",
+  "version": "1.11.29",
   "description": "Applitools universal framework wrapper",
   "keywords": [
     "applitools",
@@ -71,8 +71,8 @@
     "types"
   ],
   "scripts": {
-    "lint": "npx eslint '**/*.ts'",
-    "build": "npx tsc --project ./tsconfig.build.json",
+    "lint": "node ../../node_modules/.bin/eslint '**/*.ts'",
+    "build": "node ../../node_modules/.bin/tsc --project ./tsconfig.build.json",
     "test": "yarn test:unit",
     "test:sanity": "yarn test:unit",
     "test:unit": "mocha --no-timeouts -r ts-node/register ./test/unit/*.spec.ts",
@@ -82,9 +82,9 @@
     "postversion": "bongo postversion --skip-release-notification"
   },
   "dependencies": {
-    "@applitools/logger": "1.1.44",
+    "@applitools/logger": "1.1.45",
     "@applitools/snippets": "2.4.15",
-    "@applitools/utils": "1.3.29",
+    "@applitools/utils": "1.3.30",
     "semver": "7.3.7"
   },
   "devDependencies": {

package/types/context.d.ts

@@ -1,27 +1,27 @@
 import type { Location, Size, Region } from '@applitools/utils';
 import type { Cookie } from './types';
-import { type SpecDriver, type WaitOptions } from './spec-driver';
+import { type SpecType, type SpecDriver, type WaitOptions } from './spec-driver';
 import { type Driver } from './driver';
 import { type Selector } from './selector';
 import { type Logger } from '@applitools/logger';
-import { Element } from './element';
-export type ContextReference<TDriver, TContext, TElement, TSelector> = Context<TDriver, TContext, TElement, TSelector> | Element<TDriver, TContext, TElement, TSelector> | TElement | Selector<TSelector> | string | number;
-export type ContextPlain<TDriver, TContext, TElement, TSelector> = ContextReference<TDriver, TContext, TElement, TSelector> | {
-    reference: ContextReference<TDriver, TContext, TElement, TSelector>;
-    scrollingElement?: Element<TDriver, TContext, TElement, TSelector>;
-    parent?: ContextPlain<TDriver, TContext, TElement, TSelector>;
+import { Element, type ElementReference } from './element';
+export type ContextReference<T extends SpecType> = Element<T> | ElementReference<T> | string | number;
+export type NestedContextReference<T extends SpecType> = {
+    reference: ContextReference<T>;
+    scrollingElement?: Element<T>;
+    parent?: Context<T> | ContextReference<T> | NestedContextReference<T>;
 };
-type ContextOptions<TDriver, TContext, TElement, TSelector> = {
-    spec: SpecDriver<TDriver, TContext, TElement, TSelector>;
-    context?: TContext;
-    driver?: Driver<TDriver, TContext, TElement, TSelector>;
-    parent?: Context<TDriver, TContext, TElement, TSelector>;
-    reference?: ContextReference<TDriver, TContext, TElement, TSelector>;
-    element?: Element<TDriver, TContext, TElement, TSelector>;
-    scrollingElement?: Element<TDriver, TContext, TElement, TSelector>;
+type ContextOptions<T extends SpecType> = {
+    spec: SpecDriver<T>;
+    context?: T['context'];
+    driver?: Driver<T>;
+    parent?: Context<T>;
+    reference?: ContextReference<T>;
+    element?: Element<T>;
+    scrollingElement?: Element<T>;
     logger: Logger;
 };
-export declare class Context<TDriver, TContext, TElement, TSelector> {
+export declare class Context<T extends SpecType> {
     private _target?;
     private _driver?;
     private _parent?;
@@ -31,13 +31,13 @@ export declare class Context<TDriver, TContext, TElement, TSelector> {
     private _state;
     private _logger;
     private _isReference;
-    protected readonly _spec: SpecDriver<TDriver, TContext, TElement, TSelector>;
-    constructor(options: ContextOptions<TDriver, TContext, TElement, TSelector>);
-    get target(): TContext;
-    get driver(): Driver<TDriver, TContext, TElement, TSelector>;
-    get parent(): Context<TDriver, TContext, TElement, TSelector> | null;
-    get main(): Context<TDriver, TContext, TElement, TSelector>;
-    get path(): Context<TDriver, TContext, TElement, TSelector>[];
+    protected readonly _spec: SpecDriver<T>;
+    constructor(options: ContextOptions<T>);
+    get target(): T['driver'];
+    get driver(): Driver<T>;
+    get parent(): Context<T> | null;
+    get main(): Context<T>;
+    get path(): Context<T>[];
     get isMain(): boolean;
     get isCurrent(): boolean;
     get isInitialized(): boolean;
@@ -45,11 +45,11 @@ export declare class Context<TDriver, TContext, TElement, TSelector> {
     private _findElements;
     init(): Promise<this>;
     focus(): Promise<this>;
-    equals(context: Context<TDriver, TContext, TElement, TSelector> | Element<TDriver, TContext, TElement, TSelector>): Promise<boolean>;
-    context(reference: ContextPlain<TDriver, TContext, TElement, TSelector>): Promise<Context<TDriver, TContext, TElement, TSelector>>;
-    element(elementOrSelector: TElement | Selector<TSelector>): Promise<Element<TDriver, TContext, TElement, TSelector> | null>;
-    elements(selectorOrElement: Selector<TSelector> | TElement): Promise<Element<TDriver, TContext, TElement, TSelector>[]>;
-    waitFor(selector: Selector<TSelector>, options?: WaitOptions): Promise<Element<TDriver, TContext, TElement, TSelector> | null>;
+    equals(context: Context<T> | Element<T>): Promise<boolean>;
+    context(reference: ContextReference<T> | NestedContextReference<T>): Promise<Context<T>>;
+    element(elementOrSelector: ElementReference<T>): Promise<Element<T> | null>;
+    elements(selectorOrElement: ElementReference<T>): Promise<Element<T>[]>;
+    waitFor(selector: Selector<T>, options?: WaitOptions): Promise<Element<T> | null>;
     execute(script: ((args: any) => any) | string, arg?: any): Promise<any>;
     executePoll(script: ((arg: any) => any) | string | {
         main: ((arg: any) => any) | string;
@@ -60,11 +60,11 @@ export declare class Context<TDriver, TContext, TElement, TSelector> {
         executionTimeout?: number;
         pollTimeout?: number;
     }): Promise<any>;
-    getContextElement(): Promise<Element<TDriver, TContext, TElement, TSelector> | null>;
-    getScrollingElement(): Promise<Element<TDriver, TContext, TElement, TSelector> | null>;
-    setScrollingElement(scrollingElement: Element<TDriver, TContext, TElement, TSelector> | TElement | Selector<TSelector> | undefined | null): Promise<void>;
-    blurElement(element?: Element<TDriver, TContext, TElement, TSelector>): Promise<TElement | null>;
-    focusElement(element: Element<TDriver, TContext, TElement, TSelector>): Promise<any>;
+    getContextElement(): Promise<Element<T> | null>;
+    getScrollingElement(): Promise<Element<T> | null>;
+    setScrollingElement(scrollingElement: Element<T> | ElementReference<T> | undefined | null): Promise<void>;
+    blurElement(element?: Element<T>): Promise<T['element'] | null>;
+    focusElement(element: Element<T>): Promise<any>;
     getRegion(): Promise<Region>;
     getClientRegion(): Promise<Region>;
     getScrollingRegion(): Promise<Region>;

package/types/debug/check-spec-driver.d.ts

@@ -1,7 +1,7 @@
-import { type SpecDriver } from '../spec-driver';
-export declare function checkSpecDriver<TDriver, TContext, TElement, TSelector>(options: {
-    spec: SpecDriver<TDriver, TContext, TElement, TSelector>;
-    driver: TDriver;
+import { SpecType, type SpecDriver } from '../spec-driver';
+export declare function checkSpecDriver<T extends SpecType>(options: {
+    spec: SpecDriver<T>;
+    driver: T['driver'];
 }): Promise<({
     skipped: boolean;
     test: string;

package/types/driver.d.ts

@@ -2,22 +2,22 @@
 import type { Size, Region } from '@applitools/utils';
 import type { ScreenOrientation, Cookie } from './types';
 import { type Selector } from './selector';
-import { type SpecDriver, type WaitOptions } from './spec-driver';
+import { type SpecType, type SpecDriver, type WaitOptions } from './spec-driver';
 import { type Element } from './element';
 import { Context, type ContextReference } from './context';
 import { type Logger } from '@applitools/logger';
 import { HelperIOS } from './helper-ios';
 import { HelperAndroid } from './helper-android';
-type DriverOptions<TDriver, TContext, TElement, TSelector> = {
-    spec: SpecDriver<TDriver, TContext, TElement, TSelector>;
-    driver: TDriver;
+type DriverOptions<T extends SpecType> = {
+    spec: SpecDriver<T>;
+    driver: T['driver'];
     logger?: Logger;
     customConfig?: {
         useCeilForViewportSize?: boolean;
         disableHelper?: boolean;
     };
 };
-export declare class Driver<TDriver, TContext, TElement, TSelector> {
+export declare class Driver<T extends SpecType> {
     private _target;
     private _mainContext;
     private _currentContext;
@@ -26,12 +26,12 @@ export declare class Driver<TDriver, TContext, TElement, TSelector> {
     private _customConfig;
     private _helper?;
     private _previousWorld?;
-    protected readonly _spec: SpecDriver<TDriver, TContext, TElement, TSelector>;
-    constructor(options: DriverOptions<TDriver, TContext, TElement, TSelector>);
-    get target(): TDriver;
-    get currentContext(): Context<TDriver, TContext, TElement, TSelector>;
-    get mainContext(): Context<TDriver, TContext, TElement, TSelector>;
-    get helper(): HelperAndroid<TDriver, TContext, TElement, TSelector> | HelperIOS<TDriver, TContext, TElement, TSelector> | null | undefined;
+    protected readonly _spec: SpecDriver<T>;
+    constructor(options: DriverOptions<T>);
+    get target(): T['driver'];
+    get currentContext(): Context<T>;
+    get mainContext(): Context<T>;
+    get helper(): HelperAndroid<T> | HelperIOS<T> | null | undefined;
     get features(): {
         shadowSelector?: boolean | undefined;
         allCookies?: boolean | undefined;
@@ -64,7 +64,7 @@ export declare class Driver<TDriver, TContext, TElement, TSelector> {
     get isEC(): boolean;
     get sessionId(): string | undefined;
     get remoteHostname(): string | undefined;
-    updateCurrentContext(context: Context<TDriver, TContext, TElement, TSelector>): void;
+    updateCurrentContext(context: Context<T>): void;
     init(): Promise<this>;
     switchWorld(options?: {
         id?: string;
@@ -80,16 +80,16 @@ export declare class Driver<TDriver, TContext, TElement, TSelector> {
         isWebView: boolean;
     }>;
     getSessionMetadata(): Promise<any>;
-    refreshContexts(): Promise<Context<TDriver, TContext, TElement, TSelector>>;
-    switchTo(context: Context<TDriver, TContext, TElement, TSelector>): Promise<Context<TDriver, TContext, TElement, TSelector>>;
-    switchToMainContext(): Promise<Context<TDriver, TContext, TElement, TSelector>>;
-    switchToParentContext(elevation?: number): Promise<Context<TDriver, TContext, TElement, TSelector>>;
-    switchToChildContext(...references: ContextReference<TDriver, TContext, TElement, TSelector>[]): Promise<Context<TDriver, TContext, TElement, TSelector>>;
+    refreshContexts(): Promise<Context<T>>;
+    switchTo(context: Context<T>): Promise<Context<T>>;
+    switchToMainContext(): Promise<Context<T>>;
+    switchToParentContext(elevation?: number): Promise<Context<T>>;
+    switchToChildContext(...references: ContextReference<T>[]): Promise<Context<T>>;
     normalizeRegion(region: Region): Promise<Region>;
-    getRegionInViewport(context: Context<TDriver, TContext, TElement, TSelector>, region: Region): Promise<Region>;
-    element(selector: Selector<TSelector>): Promise<Element<TDriver, TContext, TElement, TSelector> | null>;
-    elements(selector: Selector<TSelector>): Promise<Element<TDriver, TContext, TElement, TSelector>[]>;
-    waitFor(selector: Selector<TSelector>, options?: WaitOptions): Promise<Element<TDriver, TContext, TElement, TSelector> | null>;
+    getRegionInViewport(context: Context<T>, region: Region): Promise<Region>;
+    element(selector: Selector<T>): Promise<Element<T> | null>;
+    elements(selector: Selector<T>): Promise<Element<T>[]>;
+    waitFor(selector: Selector<T>, options?: WaitOptions): Promise<Element<T> | null>;
     execute(script: ((arg: any) => any) | string, arg?: any): Promise<any>;
     takeScreenshot(): Promise<Buffer>;
     getViewportRegion(): Promise<Region>;
@@ -103,14 +103,14 @@ export declare class Driver<TDriver, TContext, TElement, TSelector> {
     getUrl(): Promise<string>;
     visit(url: string): Promise<void>;
 }
-export declare function isDriver<TDriver>(driver: any, spec?: SpecDriver<TDriver, any, any, any>): driver is Driver<TDriver, any, any, any> | TDriver;
-export declare function makeDriver<TDriver, TContext, TElement, TSelector>(options: {
-    driver: TDriver | Driver<TDriver, TContext, TElement, TSelector>;
-    spec?: SpecDriver<TDriver, TContext, TElement, TSelector>;
+export declare function isDriver<T extends SpecType>(driver: any, spec?: SpecDriver<T>): driver is Driver<T> | T['driver'];
+export declare function makeDriver<T extends SpecType>(options: {
+    driver: Driver<T> | T['driver'];
+    spec?: SpecDriver<T>;
     logger?: Logger;
     customConfig?: {
         useCeilForViewportSize?: boolean;
         disableHelper?: boolean;
     };
-}): Promise<Driver<TDriver, TContext, TElement, TSelector>>;
+}): Promise<Driver<T>>;
 export {};

package/types/element.d.ts

@@ -1,30 +1,30 @@
 import type { Location, Size, Region } from '@applitools/utils';
-import { type SpecDriver } from './spec-driver';
+import { type SpecType, type SpecDriver } from './spec-driver';
 import { type Context } from './context';
 import { type Selector } from './selector';
 import { type Logger } from '@applitools/logger';
-export type ElementReference<TElement, TSelector> = TElement | Selector<TSelector>;
-type ElementState<TElement> = {
+export type ElementReference<T extends SpecType> = T['element'] | Selector<T>;
+type ElementState = {
     contentSize?: Size;
     scrollOffset?: Location;
     transforms?: any;
     attributes?: Record<string, string | Error>;
     touchPadding?: number;
-    containedElements?: Map<TElement, boolean>;
+    containedElements?: Map<any, boolean>;
 };
-type ElementOptions<TDriver, TContext, TElement, TSelector> = {
-    spec: SpecDriver<TDriver, TContext, TElement, TSelector>;
-    context?: Context<TDriver, TContext, TElement, TSelector>;
+type ElementOptions<T extends SpecType> = {
+    spec: SpecDriver<T>;
+    context?: Context<T>;
     logger: Logger;
 } & ({
-    element: TElement;
-    selector?: Selector<TSelector>;
+    element: T['element'];
+    selector?: Selector<T>;
     index?: number;
 } | {
-    selector: Selector<TSelector>;
+    selector: Selector<T>;
     index?: number;
 });
-export declare class Element<TDriver, TContext, TElement, TSelector> {
+export declare class Element<T extends SpecType> {
     private _target?;
     private _context?;
     private _selector?;
@@ -33,18 +33,18 @@ export declare class Element<TDriver, TContext, TElement, TSelector> {
     private _state;
     private _originalOverflow;
     private _logger;
-    protected readonly _spec: SpecDriver<TDriver, TContext, TElement, TSelector>;
-    constructor(options: ElementOptions<TDriver, TContext, TElement, TSelector>);
-    get target(): NonNullable<TElement>;
-    get selector(): Selector<TSelector> | undefined;
+    protected readonly _spec: SpecDriver<T>;
+    constructor(options: ElementOptions<T>);
+    get target(): NonNullable<T["element"]>;
+    get selector(): Selector<T> | undefined;
     get commonSelector(): Selector<never> | null;
     get index(): number | undefined;
-    get context(): Context<TDriver, TContext, TElement, TSelector>;
-    get driver(): import("./driver").Driver<TDriver, TContext, TElement, TSelector>;
+    get context(): Context<T>;
+    get driver(): import("./driver").Driver<T>;
     get isRef(): boolean;
-    equals(element: Element<TDriver, TContext, TElement, TSelector> | TElement): Promise<boolean>;
-    contains(innerElement: Element<TDriver, TContext, TElement, TSelector> | TElement): Promise<boolean>;
-    init(context: Context<TDriver, TContext, TElement, TSelector>): Promise<this>;
+    equals(element: Element<T> | T['element']): Promise<boolean>;
+    contains(innerElement: Element<T> | T['element']): Promise<boolean>;
+    init(context: Context<T>): Promise<this>;
     getRegion(): Promise<Region>;
     getClientRegion(): Promise<Region>;
     getContentRegion(options?: {
@@ -64,7 +64,7 @@ export declare class Element<TDriver, TContext, TElement, TSelector> {
     isPager(): Promise<boolean>;
     isScrollable(): Promise<boolean>;
     isRoot(): Promise<boolean>;
-    getShadowRoot(): Promise<TElement | null>;
+    getShadowRoot(): Promise<T['element'] | null>;
     getTouchPadding(): Promise<number>;
     getText(): Promise<string>;
     getAttribute(name: string): Promise<string>;
@@ -78,13 +78,13 @@ export declare class Element<TDriver, TContext, TElement, TSelector> {
     getInnerOffset(): Promise<Location>;
     click(): Promise<void>;
     type(value: string): Promise<void>;
-    preserveState(): Promise<ElementState<TElement>>;
-    restoreState(state?: ElementState<TElement>): Promise<void>;
+    preserveState(): Promise<ElementState>;
+    restoreState(state?: ElementState): Promise<void>;
     hideScrollbars(): Promise<void>;
     restoreScrollbars(): Promise<void>;
-    refresh(freshElement?: TElement): Promise<boolean>;
+    refresh(freshTarget?: T['element']): Promise<boolean>;
     withRefresh<TResult>(operation: (...args: any[]) => TResult): Promise<TResult>;
-    toJSON(): TElement;
+    toJSON(): T['element'];
 }
-export declare function isElementReference<TElement, TSelector>(reference: any, spec?: SpecDriver<unknown, unknown, TElement, TSelector>): reference is ElementReference<TElement, TSelector>;
+export declare function isElementReference<T extends SpecType>(reference: any, spec?: SpecDriver<T>): reference is ElementReference<T>;
 export {};

package/types/helper-android.d.ts

@@ -1,14 +1,14 @@
 import type { Location, Region } from '@applitools/utils';
-import { type SpecDriver } from './spec-driver';
+import { type Logger } from '@applitools/logger';
+import { type SpecType, type SpecDriver } from './spec-driver';
 import { type Driver } from './driver';
 import { type Element } from './element';
-import { type Logger } from '@applitools/logger';
-export declare class HelperAndroid<TDriver, TContext, TElement, TSelector> {
-    static make<TDriver, TContext, TElement, TSelector>(options: {
-        spec: SpecDriver<TDriver, TContext, TElement, TSelector>;
-        driver: Driver<TDriver, TContext, TElement, TSelector>;
+export declare class HelperAndroid<T extends SpecType> {
+    static make<T extends SpecType>(options: {
+        spec: SpecDriver<T>;
+        driver: Driver<T>;
         logger: Logger;
-    }): Promise<HelperAndroid<TDriver, TContext, TElement, TSelector> | null>;
+    }): Promise<HelperAndroid<T> | null>;
     private readonly _spec;
     private readonly _input;
     private readonly _action;
@@ -17,16 +17,16 @@ export declare class HelperAndroid<TDriver, TContext, TElement, TSelector> {
     private _logger;
     readonly name: 'android' | 'android-legacy';
     constructor(options: {
-        spec: SpecDriver<TDriver, TContext, TElement, TSelector>;
-        input: Element<TDriver, TContext, TElement, TSelector>;
-        action: Element<TDriver, TContext, TElement, TSelector> | null;
+        spec: SpecDriver<T>;
+        input: Element<T>;
+        action: Element<T> | null;
         legacy: boolean;
         supportAsync: boolean;
         logger: Logger;
     });
     private _getElementId;
     private _command;
-    getContentRegion(element: Element<TDriver, TContext, TElement, TSelector>, options?: {
+    getContentRegion(element: Element<T>, options?: {
         lazyLoad?: {
             scrollLength?: number;
             waitingTime?: number;
@@ -34,7 +34,7 @@ export declare class HelperAndroid<TDriver, TContext, TElement, TSelector> {
         };
     }): Promise<Region | null>;
     getTouchPadding(): Promise<number | undefined>;
-    getRegion(element: Element<TDriver, TContext, TElement, TSelector>): Promise<Region | null>;
-    scrollToTop(element: Element<TDriver, TContext, TElement, TSelector>): Promise<void>;
-    scrollBy(element: Element<TDriver, TContext, TElement, TSelector>, offset: Location): Promise<void>;
+    getRegion(element: Element<T>): Promise<Region | null>;
+    scrollToTop(element: Element<T>): Promise<void>;
+    scrollBy(element: Element<T>, offset: Location): Promise<void>;
 }

package/types/helper-ios.d.ts

@@ -1,24 +1,24 @@
 import type { Region } from '@applitools/utils';
-import { type SpecDriver } from './spec-driver';
+import { type Logger } from '@applitools/logger';
+import { type SpecType, type SpecDriver } from './spec-driver';
 import { type Driver } from './driver';
 import { type Element } from './element';
-import { type Logger } from '@applitools/logger';
-export declare class HelperIOS<TDriver, TContext, TElement, TSelector> {
-    static make<TDriver, TContext, TElement, TSelector>(options: {
-        spec: SpecDriver<TDriver, TContext, TElement, TSelector>;
-        driver: Driver<TDriver, TContext, TElement, TSelector>;
+export declare class HelperIOS<T extends SpecType> {
+    static make<T extends SpecType>(options: {
+        spec: SpecDriver<T>;
+        driver: Driver<T>;
         logger: Logger;
-    }): Promise<HelperIOS<TDriver, TContext, TElement, TSelector> | null>;
+    }): Promise<HelperIOS<T> | null>;
     private readonly _driver;
     private readonly _element;
     private readonly _spec;
     private _logger;
     readonly name: 'ios';
     constructor(options: {
-        driver: Driver<TDriver, TContext, TElement, TSelector>;
-        element: Element<TDriver, TContext, TElement, TSelector>;
-        spec: SpecDriver<TDriver, TContext, TElement, TSelector>;
+        driver: Driver<T>;
+        element: Element<T>;
+        spec: SpecDriver<T>;
         logger: Logger;
     });
-    getContentRegion(element: Element<TDriver, TContext, TElement, TSelector>): Promise<Region | null>;
+    getContentRegion(element: Element<T>): Promise<Region | null>;
 }

package/types/selector.d.ts

@@ -1,9 +1,10 @@
-export type Selector<TSelector = never> = TSelector | string | {
-    selector: TSelector | string;
+import { type SpecType } from './spec-driver';
+export type Selector<T extends SpecType = never> = T['selector'] | string | CommonSelector<T>;
+export type CommonSelector<T extends SpecType = never> = {
+    selector: T['selector'] | string;
     type?: string;
-    child?: Selector<TSelector>;
-    shadow?: Selector<TSelector>;
-    frame?: Selector<TSelector>;
-    fallback?: Selector<TSelector>;
+    child?: T['selector'] | string | CommonSelector<T>;
+    shadow?: T['selector'] | string | CommonSelector<T>;
+    frame?: T['selector'] | string | CommonSelector<T>;
+    fallback?: T['selector'] | string | CommonSelector<T>;
 };
-export type CommonSelector = Selector;

package/types/spec-driver.d.ts

@@ -2,6 +2,73 @@
 import type { Location, Size, Region } from '@applitools/utils';
 import type { ScreenOrientation, Cookie } from './types';
 import { type Selector } from './selector';
+export type SpecType<TDriver = unknown, TContext = unknown, TElement = unknown, TSelector = unknown> = {
+    driver: TDriver;
+    context: TContext;
+    element: TElement;
+    selector: TSelector;
+};
+export interface SpecDriver<T extends SpecType> {
+    isDriver(driver: any): driver is T['driver'];
+    isContext?(context: any): context is T['context'];
+    isElement(element: any): element is T['element'];
+    isSelector(selector: any): selector is T['selector'];
+    transformDriver?(driver: any): T['driver'];
+    transformElement?(element: any): T['element'];
+    transformSelector?(selector: Selector<T>): T['selector'];
+    untransformSelector?(selector: T['selector'] | Selector<T>): Selector | null;
+    extractContext?(element: T['driver'] | T['context']): T['context'];
+    extractSelector?(element: T['element']): T['selector'];
+    isStaleElementError(error: any, selector?: T['selector']): boolean;
+    isEqualElements?(context: T['context'], element1: T['element'], element2: T['element']): Promise<boolean>;
+    extractHostName?(driver: T['driver']): string | null;
+    mainContext(context: T['context']): Promise<T['context']>;
+    parentContext?(context: T['context']): Promise<T['context']>;
+    childContext(context: T['context'], element: T['element']): Promise<T['context']>;
+    executeScript(context: T['context'], script: ((arg?: any) => any) | string, arg?: any): Promise<any>;
+    findElement(context: T['context'], selector: T['selector'], parent?: T['element']): Promise<T['element'] | null>;
+    findElements(context: T['context'], selector: T['selector'], parent?: T['element']): Promise<T['element'][]>;
+    waitForSelector?(context: T['context'], selector: T['selector'], parent?: T['element'], options?: WaitOptions): Promise<T['element'] | null>;
+    setElementText?(context: T['context'], element: T['element'], text: string): Promise<void>;
+    getElementText?(context: T['context'], element: T['element']): Promise<string>;
+    setWindowSize?(driver: T['driver'], size: Size): Promise<void>;
+    getWindowSize?(driver: T['driver']): Promise<Size>;
+    setViewportSize?(driver: T['driver'], size: Size): Promise<void>;
+    getViewportSize?(driver: T['driver']): Promise<Size>;
+    getCookies?(driver: T['driver'] | T['context'], context?: boolean): Promise<Cookie[]>;
+    getDriverInfo?(driver: T['driver']): Promise<DriverInfo>;
+    getCapabilities?(driver: T['driver']): Promise<Record<string, any>>;
+    getTitle(driver: T['driver']): Promise<string>;
+    getUrl(driver: T['driver']): Promise<string>;
+    takeScreenshot(driver: T['driver']): Promise<Buffer | string>;
+    click?(context: T['context'], element: T['element'] | T['selector']): Promise<void>;
+    visit?(driver: T['driver'], url: string): Promise<void>;
+    getOrientation?(driver: T['driver']): Promise<ScreenOrientation>;
+    setOrientation?(driver: T['driver'], orientation: ScreenOrientation): Promise<void>;
+    getSystemBars?(driver: T['driver']): Promise<{
+        statusBar: {
+            visible: boolean;
+            x: number;
+            y: number;
+            height: number;
+            width: number;
+        };
+        navigationBar: {
+            visible: boolean;
+            x: number;
+            y: number;
+            height: number;
+            width: number;
+        };
+    }>;
+    getElementRegion?(driver: T['driver'], element: T['element']): Promise<Region>;
+    getElementAttribute?(driver: T['driver'], element: T['element'], attr: string): Promise<string>;
+    performAction?(driver: T['driver'], steps: any[]): Promise<void>;
+    getCurrentWorld?(driver: T['driver']): Promise<string>;
+    getWorlds?(driver: T['driver']): Promise<string[]>;
+    switchWorld?(driver: T['driver'], id: string): Promise<void>;
+    getSessionMetadata?(driver: T['driver']): Promise<any>;
+}
 export type DriverInfo = {
     sessionId?: string;
     remoteHostname?: string;
@@ -43,64 +110,3 @@ export type WaitOptions = {
     interval?: number;
     timeout?: number;
 };
-export interface SpecDriver<TDriver, TContext, TElement, TSelector> {
-    isDriver(driver: any): driver is TDriver;
-    isContext?(context: any): context is TContext;
-    isElement(element: any): element is TElement;
-    isSelector(selector: any): selector is TSelector;
-    transformDriver?(driver: any): TDriver;
-    transformElement?(element: any): TElement;
-    transformSelector?(selector: Selector<TSelector>): TSelector;
-    untransformSelector?(selector: TSelector | Selector<TSelector>): Selector | null;
-    extractContext?(element: TDriver | TContext): TContext;
-    extractSelector?(element: TElement): TSelector;
-    isStaleElementError(error: any, selector?: TSelector): boolean;
-    isEqualElements?(context: TContext, element1: TElement, element2: TElement): Promise<boolean>;
-    extractHostName?(driver: TDriver): string | null;
-    mainContext(context: TContext): Promise<TContext>;
-    parentContext?(context: TContext): Promise<TContext>;
-    childContext(context: TContext, element: TElement): Promise<TContext>;
-    executeScript(context: TContext, script: ((arg?: any) => any) | string, arg?: any): Promise<any>;
-    findElement(context: TContext, selector: TSelector, parent?: TElement): Promise<TElement | null>;
-    findElements(context: TContext, selector: TSelector, parent?: TElement): Promise<TElement[]>;
-    waitForSelector?(context: TContext, selector: TSelector, parent?: TElement, options?: WaitOptions): Promise<TElement | null>;
-    setElementText?(context: TContext, element: TElement, text: string): Promise<void>;
-    getElementText?(context: TContext, element: TElement): Promise<string>;
-    setWindowSize?(driver: TDriver, size: Size): Promise<void>;
-    getWindowSize?(driver: TDriver): Promise<Size>;
-    setViewportSize?(driver: TDriver, size: Size): Promise<void>;
-    getViewportSize?(driver: TDriver): Promise<Size>;
-    getCookies?(driver: TDriver | TContext, context?: boolean): Promise<Cookie[]>;
-    getDriverInfo?(driver: TDriver): Promise<DriverInfo>;
-    getCapabilities?(driver: TDriver): Promise<Record<string, any>>;
-    getTitle(driver: TDriver): Promise<string>;
-    getUrl(driver: TDriver): Promise<string>;
-    takeScreenshot(driver: TDriver): Promise<Buffer | string>;
-    click?(context: TContext, element: TElement | TSelector): Promise<void>;
-    visit?(driver: TDriver, url: string): Promise<void>;
-    getOrientation?(driver: TDriver): Promise<ScreenOrientation>;
-    setOrientation?(driver: TDriver, orientation: ScreenOrientation): Promise<void>;
-    getSystemBars?(driver: TDriver): Promise<{
-        statusBar: {
-            visible: boolean;
-            x: number;
-            y: number;
-            height: number;
-            width: number;
-        };
-        navigationBar: {
-            visible: boolean;
-            x: number;
-            y: number;
-            height: number;
-            width: number;
-        };
-    }>;
-    getElementRegion?(driver: TDriver, element: TElement): Promise<Region>;
-    getElementAttribute?(driver: TDriver, element: TElement, attr: string): Promise<string>;
-    performAction?(driver: TDriver, steps: any[]): Promise<void>;
-    getCurrentWorld?(driver: TDriver): Promise<string>;
-    getWorlds?(driver: TDriver): Promise<string[]>;
-    switchWorld?(driver: TDriver, id: string): Promise<void>;
-    getSessionMetadata?(driver: TDriver): Promise<any>;
-}

package/types/spec-utils.d.ts

@@ -1,18 +1,16 @@
-import { type SpecDriver } from './spec-driver';
-import { type Selector } from './selector';
-type CommonSelector<TSelector = never> = Exclude<Selector<TSelector>, TSelector | string>;
+import { type SpecType, type SpecDriver } from './spec-driver';
+import { type Selector, type CommonSelector } from './selector';
 export declare function isSimpleCommonSelector(selector: any): selector is CommonSelector;
-export declare function isCommonSelector<TSelector>(spec: Pick<SpecDriver<unknown, unknown, unknown, TSelector>, 'isSelector'>, selector: any): selector is CommonSelector<TSelector>;
-export declare function isSelector<TSelector>(spec: Pick<SpecDriver<unknown, unknown, unknown, TSelector>, 'isSelector'>, selector: any): selector is Selector<TSelector>;
-export declare function transformSelector<TSelector>(spec: Pick<SpecDriver<unknown, unknown, unknown, TSelector>, 'isSelector' | 'transformSelector'>, selector: Selector<TSelector>, environment?: {
+export declare function isCommonSelector<T extends SpecType>(spec: Pick<SpecDriver<T>, 'isSelector'>, selector: any): selector is CommonSelector<T>;
+export declare function isSelector<T extends SpecType>(spec: Pick<SpecDriver<T>, 'isSelector'>, selector: any): selector is Selector<T>;
+export declare function transformSelector<T extends SpecType>(spec: Pick<SpecDriver<T>, 'isSelector' | 'transformSelector'>, selector: Selector<T>, environment?: {
     isWeb?: boolean;
     isNative?: boolean;
     isIOS?: boolean;
     isAndroid?: boolean;
-}): TSelector;
-export declare function splitSelector<TSelector>(spec: Pick<SpecDriver<unknown, unknown, unknown, TSelector>, 'isSelector'>, selector: Selector<TSelector>): {
-    contextSelectors: Selector<TSelector>[];
-    elementSelector: Selector<TSelector>;
+}): T['selector'];
+export declare function splitSelector<T extends SpecType>(spec: Pick<SpecDriver<T>, 'isSelector'>, selector: Selector<T>): {
+    contextSelectors: Selector<T>[];
+    elementSelector: Selector<T>;
 };
-export declare function withFastCache<TSpecDriver extends SpecDriver<unknown, unknown, unknown, unknown>>(spec: TSpecDriver): TSpecDriver;
-export {};
+export declare function withFastCache<TSpecDriver extends SpecDriver<SpecType>>(spec: TSpecDriver): TSpecDriver;