@applitools/driver 1.11.1 → 1.11.3

package/dist/context.js

@@ -104,6 +104,70 @@ class Context {
     get isRef() {
         return !this._target;
     }
+    async _findElements(selector, options = {}) {
+        await this.focus();
+        const { parent, all, wait } = options;
+        const transformedSelector = specUtils.transformSelector(this._spec, selector, this.driver);
+        let elements = [];
+        if (wait) {
+            if (this._spec.waitForSelector) {
+                const element = await this._spec.waitForSelector(this.target, specUtils.transformSelector(this._spec, selector, this.driver), parent, wait);
+                if (element)
+                    elements = [element];
+            }
+            else {
+                let waiting = true;
+                const timeout = setTimeout(() => (waiting = false), wait.timeout);
+                while (waiting) {
+                    const element = await this._spec.findElement(this.target, specUtils.transformSelector(this._spec, selector, this.driver), parent);
+                    if (element) {
+                        clearTimeout(timeout);
+                        elements = [element];
+                    }
+                    await utils.general.sleep(wait.interval);
+                }
+            }
+        }
+        else if (all) {
+            elements = await this._spec.findElements(this.target, transformedSelector, parent);
+        }
+        else {
+            const element = await this._spec.findElement(this.target, transformedSelector, parent);
+            if (element)
+                elements = [element];
+        }
+        if (specUtils.isCommonSelector(this._spec, selector)) {
+            if (elements.length > 0) {
+                if (selector.child) {
+                    elements = await elements.reduce((result, element) => {
+                        return result.then(async (result) => {
+                            return result.concat(await this._findElements(selector.child, { parent: element, all, wait }));
+                        });
+                    }, Promise.resolve([]));
+                }
+                else if (selector.shadow) {
+                    elements = await elements.reduce((result, element) => {
+                        return result.then(async (result) => {
+                            const root = await this._spec.executeScript(this.target, snippets.getShadowRoot, [element]);
+                            return result.concat(root ? await this._findElements(selector.shadow, { parent: root, all, wait }) : []);
+                        });
+                    }, Promise.resolve([]));
+                }
+                else if (selector.frame) {
+                    elements = await elements.reduce((result, element) => {
+                        return result.then(async (result) => {
+                            const context = await this.context(element);
+                            return result.concat(await context._findElements(selector.frame, { all, wait }));
+                        });
+                    }, Promise.resolve([]));
+                }
+            }
+            if (elements.length === 0 && selector.fallback) {
+                elements = await this._findElements(selector.fallback, parent);
+            }
+        }
+        return elements;
+    }
     async init() {
         if (this.isInitialized)
             return this;
@@ -201,62 +265,21 @@ class Context {
             });
         }
     }
-    async root(selector) {
-        var _a;
-        await this.focus();
-        const { contextSelectors, elementSelector } = specUtils.splitSelector(this._spec, selector);
-        let context = this;
-        for (const contextSelector of contextSelectors) {
-            try {
-                context = await context.context(contextSelector);
-                await context.focus();
-            }
-            catch {
-                return null;
-            }
-        }
-        if ((_a = this.driver.features) === null || _a === void 0 ? void 0 : _a.shadowSelector)
-            return { context, selector: elementSelector };
-        let root = null;
-        let element = null;
-        let currentSelector = elementSelector;
-        while (specUtils.isCommonSelector(this._spec, currentSelector) &&
-            specUtils.isSelector(this._spec, currentSelector.shadow)) {
-            element = await this._spec.findElement(this.target, specUtils.transformSelector(this._spec, currentSelector, this.driver), root);
-            if (!element)
-                return null;
-            root = await this._spec.executeScript(this.target, snippets.getShadowRoot, [element]);
-            if (!root)
-                return null;
-            currentSelector = currentSelector.shadow;
-        }
-        return {
-            context,
-            shadow: element && new element_1.Element({ spec: this._spec, context, element, logger: this._logger }),
-            selector: currentSelector,
-        };
-    }
     async element(elementOrSelector) {
         if (this._spec.isElement(elementOrSelector)) {
             return new element_1.Element({ spec: this._spec, context: this, element: elementOrSelector, logger: this._logger });
         }
-        else if (specUtils.isSelector(this._spec, elementOrSelector)) {
-            if (this.isRef) {
-                return new element_1.Element({ spec: this._spec, context: this, selector: elementOrSelector, logger: this._logger });
-            }
-            this._logger.log('Finding element by selector: ', elementOrSelector);
-            const root = await this.root(elementOrSelector);
-            if (!root)
-                return null;
-            const element = await this._spec.findElement(root.context.target, specUtils.transformSelector(this._spec, root.selector, this.driver), root.shadow && (await root.shadow.getShadowRoot()));
-            // TODO root.selector is not a full selector from context root to an element, but selector inside a shadow
-            return element
-                ? new element_1.Element({ spec: this._spec, context: root.context, element, selector: root.selector, logger: this._logger })
-                : null;
-        }
-        else {
+        else if (!specUtils.isSelector(this._spec, elementOrSelector)) {
             throw new TypeError('Cannot find element using argument of unknown type!');
         }
+        if (this.isRef) {
+            return new element_1.Element({ spec: this._spec, context: this, selector: elementOrSelector, logger: this._logger });
+        }
+        this._logger.log('Finding element by selector: ', elementOrSelector);
+        const [element] = await this._findElements(elementOrSelector, { all: false });
+        return element
+            ? new element_1.Element({ spec: this._spec, context: this, element, selector: elementOrSelector, logger: this._logger })
+            : null;
     }
     async elements(selectorOrElement) {
         if (specUtils.isSelector(this._spec, selectorOrElement)) {
@@ -264,17 +287,13 @@ class Context {
                 return [new element_1.Element({ spec: this._spec, context: this, selector: selectorOrElement, logger: this._logger })];
             }
             this._logger.log('Finding elements by selector: ', selectorOrElement);
-            const root = await this.root(selectorOrElement);
-            if (!root)
-                return [];
-            const elements = await this._spec.findElements(root.context.target, specUtils.transformSelector(this._spec, root.selector, this.driver), root.shadow && (await root.shadow.getShadowRoot()));
+            const elements = await this._findElements(selectorOrElement, { all: true });
             return elements.map((element, index) => {
-                // TODO root.selector is not a full selector from context root to an element, but selector inside a shadow
                 return new element_1.Element({
                     spec: this._spec,
-                    context: root.context,
+                    context: this,
                     element,
-                    selector: root.selector,
+                    selector: selectorOrElement,
                     index,
                     logger: this._logger,
                 });
@@ -288,34 +307,10 @@ class Context {
         }
     }
     async waitFor(selector, options) {
-        var _a, _b;
-        const root = await this.root(selector);
-        if (!root)
-            return null;
-        options = { state: 'exist', timeout: 10000, interval: 500, ...options };
-        if (this._spec.waitForSelector) {
-            const element = await this._spec.waitForSelector(root.context.target, specUtils.transformSelector(this._spec, root.selector, this.driver), (_a = root.shadow) === null || _a === void 0 ? void 0 : _a.target, options);
-            return element
-                ? new element_1.Element({ spec: this._spec, context: root.context, element, selector: root.selector, logger: this._logger })
-                : null;
-        }
-        let waiting = true;
-        const timeout = setTimeout(() => (waiting = false), options.timeout);
-        while (waiting) {
-            const element = await this._spec.findElement(root.context.target, specUtils.transformSelector(this._spec, root.selector, this.driver), (_b = root.shadow) === null || _b === void 0 ? void 0 : _b.target);
-            if (element) {
-                clearTimeout(timeout);
-                return new element_1.Element({
-                    spec: this._spec,
-                    context: root.context,
-                    element,
-                    selector: root.selector,
-                    logger: this._logger,
-                });
-            }
-            await utils.general.sleep(options.interval);
-        }
-        return null;
+        const [element] = await this._findElements(selector, {
+            wait: { state: 'exist', timeout: 10000, interval: 500, ...options },
+        });
+        return element ? new element_1.Element({ spec: this._spec, context: this, element, selector, logger: this._logger }) : null;
     }
     async execute(script, arg) {
         await this.focus();

package/dist/spec-utils.js

@@ -34,7 +34,7 @@ exports.isSimpleCommonSelector = isSimpleCommonSelector;
 function isCommonSelector(spec, selector) {
     return (utils.types.isPlainObject(selector) &&
         utils.types.has(selector, 'selector') &&
-        Object.keys(selector).every(key => ['selector', 'type', 'frame', 'shadow'].includes(key)) &&
+        Object.keys(selector).every(key => ['selector', 'type', 'frame', 'shadow', 'child', 'fallback'].includes(key)) &&
         (utils.types.isString(selector.selector) || spec.isSelector(selector.selector)));
 }
 exports.isCommonSelector = isCommonSelector;
@@ -67,7 +67,11 @@ function splitSelector(spec, selector) {
             activeSelector.selector = targetSelector.selector;
             if (targetSelector.type)
                 activeSelector.type = targetSelector.type;
-            if (targetSelector.shadow) {
+            if (targetSelector.child) {
+                activeSelector = activeSelector.child = {};
+                targetSelector = targetSelector.child;
+            }
+            else if (targetSelector.shadow) {
                 activeSelector = activeSelector.shadow = {};
                 targetSelector = targetSelector.shadow;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applitools/driver",
-  "version": "1.11.1",
+  "version": "1.11.3",
   "description": "Applitools universal framework wrapper",
   "keywords": [
     "applitools",
@@ -87,9 +87,9 @@
     }
   },
   "dependencies": {
-    "@applitools/logger": "1.1.27",
+    "@applitools/logger": "1.1.28",
     "@applitools/snippets": "2.4.6",
-    "@applitools/utils": "1.3.13",
+    "@applitools/utils": "1.3.14",
     "semver": "7.3.7"
   },
   "devDependencies": {

package/types/context.d.ts

@@ -47,15 +47,11 @@ export declare class Context<TDriver, TContext, TElement, TSelector> {
     get isCurrent(): boolean;
     get isInitialized(): boolean;
     get isRef(): boolean;
+    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>>;
-    root(selector: Selector<TSelector>): Promise<{
-        context: Context<TDriver, TContext, TElement, TSelector>;
-        shadow?: Element<TDriver, TContext, TElement, TSelector>;
-        selector: Selector<TSelector>;
-    }>;
     element(elementOrSelector: TElement | Selector<TSelector>): Promise<Element<TDriver, TContext, TElement, TSelector>>;
     elements(selectorOrElement: Selector<TSelector> | TElement): Promise<Element<TDriver, TContext, TElement, TSelector>[]>;
     waitFor(selector: Selector<TSelector>, options?: WaitOptions): Promise<Element<TDriver, TContext, TElement, TSelector>>;

package/types/selector.d.ts

@@ -1,7 +1,9 @@
 export declare type Selector<TSelector = never> = TSelector | string | {
     selector: TSelector | string;
     type?: string;
+    child?: Selector<TSelector>;
     shadow?: Selector<TSelector>;
     frame?: Selector<TSelector>;
+    fallback?: Selector<TSelector>;
 };
 export declare type CommonSelector = Selector;

package/types/spec-utils.d.ts

@@ -1,11 +1,6 @@
 import { type SpecDriver } from './spec-driver';
 import { type Selector } from './selector';
-declare type CommonSelector<TSelector = never> = {
-    selector: TSelector | string;
-    type?: string;
-    shadow?: CommonSelector<TSelector> | TSelector | string;
-    frame?: CommonSelector<TSelector> | TSelector | string;
-};
+declare type CommonSelector<TSelector = never> = Exclude<Selector<TSelector>, TSelector | string>;
 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>;