@allwright.dev/core 0.0.55 → 0.0.57

package/dist/bootstrap.js

@@ -12,7 +12,7 @@ const ALLWRIGHT_HOME_ENV_VAR = "ALLWRIGHT_HOME";
 const ALLWRIGHT_REPOSITORY_ENV_VAR = "ALLWRIGHT_REPOSITORY";
 const ALLWRIGHT_VERSION_ENV_VAR = "ALLWRIGHT_VERSION";
 const DEFAULT_RELEASE_REPOSITORY = "allwright-dev/allwright";
-const DEFAULT_RELEASE_VERSION = "0.0.55";
+const DEFAULT_RELEASE_VERSION = "0.0.57";
 const STARTUP_TIMEOUT_MS = 20_000;
 const PING_TIMEOUT_MS = 1_000;
 const PROTO_ROOT = fileURLToPath(new URL("../proto/", import.meta.url));

package/dist/mobile.js

@@ -46,6 +46,63 @@ class MobileAndroidAppImpl {
             }
         }
     }
+    async count(selector, options = {}) {
+        const handle = await this.#getHandle();
+        this.#ensureOpen(handle);
+        handle.stream.write({
+            surfaceSessionId: this.#surfaceSessionId,
+            contextSessionId: this.sessionId,
+            countElements: {
+                cssSelector: normalizeMobileSelectorForTransport(selector),
+                retryOptions: retryOptions(options.timeoutMs),
+            },
+        });
+        while (true) {
+            const event = await handle.queue.next();
+            if (event.elementCounted) {
+                return {
+                    selector: event.elementCounted.cssSelector ?? "",
+                    count: event.elementCounted.count ?? 0,
+                    note: event.elementCounted.note ?? "",
+                };
+            }
+            if (event.error?.message) {
+                throw new Error(event.error.message);
+            }
+            if (event.closed) {
+                handle.closed = true;
+                throw new Error(`android app session ${this.sessionId} closed while counting elements`);
+            }
+        }
+    }
+    async focus(selector, options = {}) {
+        const handle = await this.#getHandle();
+        this.#ensureOpen(handle);
+        handle.stream.write({
+            surfaceSessionId: this.#surfaceSessionId,
+            contextSessionId: this.sessionId,
+            focusElement: {
+                cssSelector: normalizeMobileSelectorForTransport(selector),
+                retryOptions: retryOptions(options.timeoutMs),
+            },
+        });
+        while (true) {
+            const event = await handle.queue.next();
+            if (event.elementFocused) {
+                return {
+                    selector: event.elementFocused.cssSelector ?? "",
+                    note: event.elementFocused.note ?? "",
+                };
+            }
+            if (event.error?.message) {
+                throw new Error(event.error.message);
+            }
+            if (event.closed) {
+                handle.closed = true;
+                throw new Error(`android app session ${this.sessionId} closed while focusing`);
+            }
+        }
+    }
     async fill(selector, value, options = {}) {
         const handle = await this.#getHandle();
         this.#ensureOpen(handle);
@@ -76,6 +133,73 @@ class MobileAndroidAppImpl {
             }
         }
     }
+    async press(selector, key, options = {}) {
+        const handle = await this.#getHandle();
+        this.#ensureOpen(handle);
+        handle.stream.write({
+            surfaceSessionId: this.#surfaceSessionId,
+            contextSessionId: this.sessionId,
+            pressKey: {
+                cssSelector: normalizeMobileSelectorForTransport(selector),
+                key,
+                text: options.text,
+                retryOptions: retryOptions(options.timeoutMs),
+            },
+        });
+        while (true) {
+            const event = await handle.queue.next();
+            if (event.keyPressed) {
+                return {
+                    selector: event.keyPressed.cssSelector ?? "",
+                    key: event.keyPressed.key ?? "",
+                    note: event.keyPressed.note ?? "",
+                };
+            }
+            if (event.error?.message) {
+                throw new Error(event.error.message);
+            }
+            if (event.closed) {
+                handle.closed = true;
+                throw new Error(`android app session ${this.sessionId} closed while pressing key`);
+            }
+        }
+    }
+    async textContent(selector, options = {}) {
+        return this.#readText(selector, options, true);
+    }
+    async innerText(selector, options = {}) {
+        return this.#readText(selector, options, false);
+    }
+    async waitForSelector(selector, options = {}) {
+        const handle = await this.#getHandle();
+        this.#ensureOpen(handle);
+        handle.stream.write({
+            surfaceSessionId: this.#surfaceSessionId,
+            contextSessionId: this.sessionId,
+            waitForSelector: {
+                cssSelector: normalizeMobileSelectorForTransport(selector),
+                visible: options.visible,
+                retryOptions: retryOptions(options.timeoutMs),
+            },
+        });
+        while (true) {
+            const event = await handle.queue.next();
+            if (event.selectorWaitSatisfied) {
+                return {
+                    selector: event.selectorWaitSatisfied.cssSelector ?? "",
+                    visible: event.selectorWaitSatisfied.visible ?? false,
+                    note: event.selectorWaitSatisfied.note ?? "",
+                };
+            }
+            if (event.error?.message) {
+                throw new Error(event.error.message);
+            }
+            if (event.closed) {
+                handle.closed = true;
+                throw new Error(`android app session ${this.sessionId} closed while waiting for selector`);
+            }
+        }
+    }
     async screenshot(options = {}) {
         const handle = await this.#getHandle();
         this.#ensureOpen(handle);
@@ -119,6 +243,52 @@ class MobileAndroidAppImpl {
             throw new Error(`android app session ${this.sessionId} is closed`);
         }
     }
+    async #readText(selector, options, textContent) {
+        const handle = await this.#getHandle();
+        this.#ensureOpen(handle);
+        const transportSelector = normalizeMobileSelectorForTransport(selector);
+        handle.stream.write(textContent
+            ? {
+                surfaceSessionId: this.#surfaceSessionId,
+                contextSessionId: this.sessionId,
+                getTextContent: {
+                    cssSelector: transportSelector,
+                    retryOptions: retryOptions(options.timeoutMs),
+                },
+            }
+            : {
+                surfaceSessionId: this.#surfaceSessionId,
+                contextSessionId: this.sessionId,
+                getInnerText: {
+                    cssSelector: transportSelector,
+                    retryOptions: retryOptions(options.timeoutMs),
+                },
+            });
+        while (true) {
+            const event = await handle.queue.next();
+            if (event.textContentResolved) {
+                return {
+                    selector: event.textContentResolved.cssSelector ?? "",
+                    text: event.textContentResolved.text ?? "",
+                    note: event.textContentResolved.note ?? "",
+                };
+            }
+            if (event.innerTextResolved) {
+                return {
+                    selector: event.innerTextResolved.cssSelector ?? "",
+                    text: event.innerTextResolved.text ?? "",
+                    note: event.innerTextResolved.note ?? "",
+                };
+            }
+            if (event.error?.message) {
+                throw new Error(event.error.message);
+            }
+            if (event.closed) {
+                handle.closed = true;
+                throw new Error(`android app session ${this.sessionId} closed while reading text`);
+            }
+        }
+    }
 }
 class MobileAndroidLocatorImpl {
     page;
@@ -133,6 +303,24 @@ class MobileAndroidLocatorImpl {
     async fill(value, options = {}) {
         return this.page.fill(this.selector, value, options);
     }
+    async count(options = {}) {
+        return this.page.count(this.selector, options);
+    }
+    async focus(options = {}) {
+        return this.page.focus(this.selector, options);
+    }
+    async press(key, options = {}) {
+        return this.page.press(this.selector, key, options);
+    }
+    async textContent(options = {}) {
+        return this.page.textContent(this.selector, options);
+    }
+    async innerText(options = {}) {
+        return this.page.innerText(this.selector, options);
+    }
+    async waitFor(options = {}) {
+        return this.page.waitForSelector(this.selector, options);
+    }
     locator(selector) {
         return new MobileAndroidLocatorImpl(this.page, chainMobileSelectorForTransport(this.selector, selector));
     }

package/dist/types.d.ts

@@ -140,14 +140,26 @@ export interface MobileAndroidLocator {
     readonly page: MobileAndroidApp;
     readonly selector: string;
     click(options?: CommandOptions): Promise<ClickResult>;
+    count(options?: CommandOptions): Promise<CountResult>;
+    focus(options?: CommandOptions): Promise<ElementResult>;
     fill(value: string, options?: CommandOptions): Promise<FillResult>;
+    press(key: string, options?: PressOptions): Promise<PressResult>;
+    textContent(options?: CommandOptions): Promise<TextResult>;
+    innerText(options?: CommandOptions): Promise<TextResult>;
+    waitFor(options?: WaitForSelectorOptions): Promise<WaitForSelectorResult>;
     locator(selector: string): MobileAndroidLocator;
 }
 export interface MobileAndroidApp {
     readonly sessionId: string;
     locator(selector: string): MobileAndroidLocator;
     click(selector: string, options?: CommandOptions): Promise<ClickResult>;
+    count(selector: string, options?: CommandOptions): Promise<CountResult>;
+    focus(selector: string, options?: CommandOptions): Promise<ElementResult>;
     fill(selector: string, value: string, options?: CommandOptions): Promise<FillResult>;
+    press(selector: string, key: string, options?: PressOptions): Promise<PressResult>;
+    textContent(selector: string, options?: CommandOptions): Promise<TextResult>;
+    innerText(selector: string, options?: CommandOptions): Promise<TextResult>;
+    waitForSelector(selector: string, options?: WaitForSelectorOptions): Promise<WaitForSelectorResult>;
     screenshot(options?: ScreenshotOptions): Promise<ScreenshotResult>;
 }
 export interface MobileAndroidDevice {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allwright.dev/core",
-  "version": "0.0.55",
+  "version": "0.0.57",
   "description": "High-level TypeScript client for the allwright automation engine.",
   "license": "MIT",
   "type": "module",