droidline 0.0.0-stage → 0.1.1

package/dist/element.d.ts

@@ -0,0 +1,54 @@
+import type { By, ClearResult, DeviceCommands, InputResult, Node, Query, TapResult, TouchResult } from "./generated.js";
+/**
+ * One screen element, as it was when find() or findAll() returned it.
+ *
+ * The fields are a snapshot. Actions look the element up again by its exact bounds and
+ * class, so after it moved or disappeared they reject with NOT_FOUND; call refresh() or
+ * find it again. Actions do not wait unless you pass a timeout.
+ */
+export declare class Element {
+    readonly device: DeviceCommands;
+    readonly node: Node;
+    constructor(device: DeviceCommands, node: Node);
+    get text(): string;
+    get id(): string;
+    get desc(): string;
+    get className(): string;
+    get package(): string;
+    get bounds(): [number, number, number, number];
+    get center(): [number, number];
+    /** The query that finds this element again: its exact bounds and class. */
+    query(): Query;
+    click(opts?: {
+        timeout?: number;
+    }): Promise<TouchResult>;
+    longClick(opts?: {
+        ms?: number;
+        timeout?: number;
+    }): Promise<TouchResult>;
+    input(text: string, opts?: {
+        append?: boolean;
+        timeout?: number;
+    }): Promise<InputResult>;
+    clear(opts?: {
+        timeout?: number;
+    }): Promise<ClearResult>;
+    /** Tap the center point, without looking the element up again. */
+    tap(): Promise<TapResult>;
+    exists(): Promise<boolean>;
+    /** The same element with its current fields, for example after its text changed. */
+    refresh(opts?: {
+        timeout?: number;
+    }): Promise<Element>;
+    /** An element inside this one. */
+    find(by: By | Query, value?: string, opts?: {
+        nth?: number;
+        timeout?: number;
+    }): Promise<Element>;
+    /** Every element inside this one that matches. */
+    findAll(by: By | Query, value?: string, opts?: {
+        timeout?: number;
+    }): Promise<Element[]>;
+    private within;
+    toString(): string;
+}

package/dist/element.js

@@ -0,0 +1,88 @@
+/**
+ * One screen element, as it was when find() or findAll() returned it.
+ *
+ * The fields are a snapshot. Actions look the element up again by its exact bounds and
+ * class, so after it moved or disappeared they reject with NOT_FOUND; call refresh() or
+ * find it again. Actions do not wait unless you pass a timeout.
+ */
+export class Element {
+    device;
+    node;
+    constructor(device, node) {
+        this.device = device;
+        this.node = { ...node };
+    }
+    get text() {
+        return String(this.node.text ?? "");
+    }
+    get id() {
+        return String(this.node.id ?? "");
+    }
+    get desc() {
+        return String(this.node.desc ?? "");
+    }
+    get className() {
+        return String(this.node.class ?? "");
+    }
+    get package() {
+        return String(this.node.package ?? "");
+    }
+    get bounds() {
+        const b = this.node.bounds ?? [0, 0, 0, 0];
+        return [Number(b[0]), Number(b[1]), Number(b[2]), Number(b[3])];
+    }
+    get center() {
+        const [l, t, r, b] = this.bounds;
+        return [Math.floor((l + r) / 2), Math.floor((t + b) / 2)];
+    }
+    /** The query that finds this element again: its exact bounds and class. */
+    query() {
+        const q = { bounds: this.bounds };
+        if (this.className)
+            q.class = this.className;
+        return q;
+    }
+    click(opts = {}) {
+        return this.device.touch(this.query(), { timeout: opts.timeout ?? 0 });
+    }
+    longClick(opts = {}) {
+        return this.device.long_touch(this.query(), { ms: opts.ms, timeout: opts.timeout ?? 0 });
+    }
+    input(text, opts = {}) {
+        return this.device.input(this.query(), text, { append: opts.append, timeout: opts.timeout ?? 0 });
+    }
+    clear(opts = {}) {
+        return this.device.clear(this.query(), { timeout: opts.timeout ?? 0 });
+    }
+    /** Tap the center point, without looking the element up again. */
+    tap() {
+        const [x, y] = this.center;
+        return this.device.tap(x, y);
+    }
+    exists() {
+        return this.device.exists(this.query());
+    }
+    /** The same element with its current fields, for example after its text changed. */
+    refresh(opts = {}) {
+        return this.device.find(this.query(), { timeout: opts.timeout ?? 0 });
+    }
+    /** An element inside this one. */
+    find(by, value, opts = {}) {
+        return this.device.find(this.within(by, value), opts);
+    }
+    /** Every element inside this one that matches. */
+    findAll(by, value, opts = {}) {
+        return this.device.findAll(this.within(by, value), opts);
+    }
+    within(by, value) {
+        const q = typeof by === "string" ? { [by]: value } : { ...by };
+        if (q.inside !== undefined)
+            throw new TypeError("this query already has inside; call device.find() with your own query instead");
+        q.inside = this.query();
+        return q;
+    }
+    toString() {
+        const label = this.text || this.desc || this.id;
+        return `Element(${this.className || "?"} ${JSON.stringify(label)} [${this.bounds.join(", ")}])`;
+    }
+}

package/dist/errors.d.ts

@@ -0,0 +1,14 @@
+import { type ErrorCode } from "./generated.js";
+/** Codes raised by the SDK itself rather than the server. */
+export type ClientErrorCode = "SERVER_NOT_RUNNING" | "CONNECTION_LOST";
+/**
+ * Every failure the SDK reports. `code` is an error code from spec/commands.json or a
+ * ClientErrorCode; `data` holds the extra fields the server sent, like `screen` or `candidates`.
+ */
+export declare class DroidlineError extends Error {
+    readonly code: ErrorCode | ClientErrorCode | (string & {});
+    readonly retryable: boolean;
+    readonly data: Record<string, unknown>;
+    constructor(message: string, code: string, retryable?: boolean, data?: Record<string, unknown>);
+}
+export declare function errorFromResponse(resp: Record<string, unknown>): DroidlineError;

package/dist/errors.js

@@ -0,0 +1,24 @@
+import { ERRORS } from "./generated.js";
+/**
+ * Every failure the SDK reports. `code` is an error code from spec/commands.json or a
+ * ClientErrorCode; `data` holds the extra fields the server sent, like `screen` or `candidates`.
+ */
+export class DroidlineError extends Error {
+    code;
+    retryable;
+    data;
+    constructor(message, code, retryable = false, data = {}) {
+        super(message);
+        this.name = "DroidlineError";
+        this.code = code;
+        this.retryable = retryable;
+        this.data = data;
+    }
+}
+export function errorFromResponse(resp) {
+    const { id: _id, ok: _ok, error, msg, retryable, ...data } = resp;
+    const code = typeof error === "string" && error ? error : "INTERNAL";
+    const known = ERRORS[code];
+    const flag = typeof retryable === "boolean" ? retryable : (known?.retryable ?? false);
+    return new DroidlineError(typeof msg === "string" && msg ? msg : code, code, flag, data);
+}