react-native-tapline 1.4.0 → 1.6.0

package/TaplineNative.podspec

@@ -5,7 +5,9 @@ Pod::Spec.new do |s|
   s.license = { :type => 'MIT' }
   s.author = 'Tapline'
   s.homepage = 'https://github.com/tapline/tapline'
-  s.platforms = { :ios => '16.4' }
+  # 15.1 is the floor of Expo SDK 55 and React Native 0.83. CocoaPods skips a pod that needs a newer iOS than the
+  # app, silently, so a higher number here left SDK 55 apps without the module (found by the native CI job).
+  s.platforms = { :ios => '15.1' }
   s.source = { :git => '' }
   s.static_framework = true
   s.dependency 'ExpoModulesCore'

package/dist/actions.d.ts

@@ -1,6 +1,7 @@
 import { type Entry, type Snapshot } from './inspect';
 import { type ElementSource } from './source';
 import { type AuditType } from './checks';
+import { type UxAction, type UxCheckName, type UxKind } from './uxcheck';
 import { type Fiber } from './fiber';
 import { type Frame, type LogEntry, type TaplineElement } from './types';
 export { tree } from './inspect';
@@ -21,6 +22,8 @@ export interface SettleOutcome {
 export declare function settle(): Promise<number>;
 /** Like `settle`, and says when the wait ended at the cap: spread it into an action's result. */
 export declare function settleOutcome(): Promise<SettleOutcome>;
+/** An action is starting: only requests begun from now on count as its own. */
+export declare function beginAction(): void;
 type ParsedTarget = {
     kind: 'ref';
     ref: string;
@@ -59,8 +62,12 @@ export declare function labelOf(info: {
 }): string;
 /** What the caller means to do; a point target then picks only an element that does it. */
 type ActionHint = 'press' | 'longPress' | 'toggle' | 'scroll' | 'type';
-/** Resolve a protocol target to exactly one element, or throw not_found / ambiguous. */
-export declare function resolveTarget(raw: unknown, hint?: ActionHint): Promise<Resolved>;
+/**
+ * Resolve a protocol target to exactly one element, or throw not_found / ambiguous. A target that isn't there while the screen
+ * is loading (a request in flight, a spinner) is waited for up to the settle cap before `not_found` is answered (AGENT-TOOLS
+ * 1.13 §18.7); the answer after the wait is made from the screen as it is then, so its closest matches are unchanged.
+ */
+export declare function resolveTarget(raw: unknown, hint?: ActionHint, glassOnly?: boolean, loadingWait?: boolean): Promise<Resolved>;
 /** The nearest listed element at or above a host fiber, for naming what covers a target. */
 export declare function describeHit(snapshot: Snapshot, hit: Fiber, actor?: Entry): string;
 /** `back`: what the back button or gesture does, on the focused screen; with a sheet open, closes the sheet. */
@@ -69,6 +76,16 @@ export declare function back(rawParams: unknown): Promise<{
     closed?: 'sheet';
     dryRun?: true;
 } & SettleOutcome>;
+/** What happened to a double tap's second tap, and how long after the first it came. */
+export type PressSecond = {
+    done: true;
+    afterMs: number;
+    threw?: string;
+} | {
+    done: false;
+    reason: string;
+    afterMs: number;
+};
 /**
  * What `press` and `longPress` answer: the element, `closedKeyboard: true` when the keyboard was
  * closed first, and `forced` (the reason word) when `force` let through what the checks refuse.
@@ -86,7 +103,22 @@ export type PressResult = {
         x: number;
         y: number;
     };
+    /** With `again`: the second tap of a double tap. */
+    second?: PressSecond;
+    /** Whose handler took the touch, and its message if it threw (AGENT-TOOLS 1.13 §3). Absent on a dry run. */
+    handler?: HandlerFacts;
+    /** Requests that began during the action. Absent on a dry run. */
+    startedRequests?: number;
 } & SettleOutcome;
+/** An own handler (`threw`: its message), or an ancestor's (`element`: that ancestor) that took the touch. */
+export type HandlerFacts = {
+    kind: 'own';
+    threw?: string;
+} | {
+    kind: 'parent';
+    element: TaplineElement;
+    threw?: string;
+};
 export declare function press(params: unknown): Promise<PressResult>;
 export declare function longPress(params: unknown): Promise<PressResult>;
 /** What the SDK asks of the keyboard and the focused input; replaceable so tests need no native side. */
@@ -142,6 +174,28 @@ export type ScrollResult = {
     dryRun?: true;
 } & SettleOutcome;
 export declare function scroll(rawParams: unknown): Promise<ScrollResult>;
+interface ScrollState {
+    /** The real content offset; negative at rest when the system adds an inset. */
+    offset: {
+        x: number;
+        y: number;
+    };
+    /** The furthest offset a scrollTo can reach. */
+    max: {
+        x: number;
+        y: number;
+    };
+    visible: {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * The scroll view's real offset, from where its content container sits inside it. On the new
+ * architecture `measureInWindow` includes the content offset, so scroll frame minus content frame
+ * is the offset. Null when either can't be measured (old architecture, nothing laid out).
+ */
+export declare function measureScrollState(entry: Entry): Promise<ScrollState | null>;
 export declare function toggle(rawParams: unknown): Promise<{
     element: TaplineElement;
     value: boolean;
@@ -190,6 +244,25 @@ export declare function audit(rawParams: unknown): Promise<{
     issues: AuditIssue[];
     checked: AuditType[];
 }>;
+export interface UxIssue {
+    kind: UxKind;
+    element: TaplineElement | null;
+    where?: AuditWhere;
+    problem: string;
+    basis: string;
+    at?: {
+        file: string;
+        line: number;
+        direct: boolean;
+    };
+}
+/** `ux_check {wayBack?, earlier?}` (AGENT-TOOLS 1.12 §17.3): the screen against the usability basics. */
+export declare function uxCheck(rawParams: unknown): Promise<{
+    issues: UxIssue[];
+    checked: UxCheckName[];
+    choices: number;
+    actions: UxAction[];
+}>;
 export declare function getLogs(rawParams: unknown): Promise<{
     entries: LogEntry[];
 }>;