@shipvo/cli 0.1.5 → 0.1.6

package/dist/explore.d.ts

@@ -8,6 +8,13 @@ export type Step = {
     role: string;
     name: string;
     nth: number;
+} | {
+    action: "type";
+    role: string;
+    name: string;
+    nth: number;
+    text: string;
+    enter?: boolean;
 } | {
     action: "back";
 };
@@ -26,10 +33,19 @@ export type Driver = {
     openUrl(url: string): Promise<Reply>;
     tap(ref: string): Promise<Reply>;
     back(): Promise<Reply>;
+    /** Type into a text field. Optional: without it the walker does not fill fields. `enter` presses Enter after the text. */
+    type?(ref: string, text: string, enter?: boolean): Promise<Reply>;
+    /** Look at the current screen again without acting. Optional: without it `stuck_loading` is not checked. */
+    snapshot?(): Promise<Reply>;
     /** Uncaught page errors since the last call. */
     errors(): Promise<string[]>;
+    /** Rendered size in px of each ref on the current screen. Optional: without it the size check is skipped. */
+    sizes?(): Promise<Record<string, [number, number]>>;
 };
-export type Kind = "error" | "not_delivered" | "action_failed" | "dead_end" | "unnamed";
+export type Skin = "android" | "ios";
+/** Smallest tap target: 44 x 44 pt on iOS (Apple HIG), 48 x 48 dp on Android (Material and Android accessibility guide). */
+export declare const MIN_TARGET: Record<Skin, number>;
+export type Kind = "error" | "not_delivered" | "action_failed" | "dead_end" | "unnamed" | "small_target" | "duplicate_name" | "network_failed" | "stuck_loading" | "blank_screen";
 export type Finding = {
     kind: Kind;
     message: string;
@@ -49,6 +65,8 @@ export type Report = {
     parityLimits: string[];
 };
 export declare const PARITY_LIMITS: string[];
+/** A value for a field, from its label: one the field should accept, or one it should reject. */
+export declare function sampleValue(name: string, invalid: boolean): string;
 type El = {
     role: string;
     name: string;
@@ -56,29 +74,87 @@ type El = {
     nth: number;
 };
 /** Actionable elements in a tree, in order. `nth` counts earlier elements with the same role and name. Disabled ones are left out. */
-export declare function elements(tree: string): El[];
+export declare const elements: (tree: string) => El[];
+export declare const fieldElements: (tree: string) => El[];
 /** The tree without refs, to tell whether two screens are the same. */
 export declare const signature: (tree: string) => string;
 /** Steps in plain lines, for the report. */
 export declare const describeStep: (s: Step) => string;
-export declare function walk(driver: Driver, o?: {
+export type WalkOptions = {
     routes?: string[];
+    onlyRoutes?: boolean;
     maxDepth?: number;
     maxSteps?: number;
     app?: string;
-}): Promise<Report>;
+    skin?: Skin;
+    /** Seed for tie-breaks and tap order. The same seed on the same app repeats the same walk. Default 1. */
+    seed?: number;
+    /** Wait in ms between looks at a screen that shows a loading indicator. Default 400. */
+    settleMs?: number;
+    /** Start paths to walk instead of the app's start screen and `routes`. Used by `shipvo lumi` to test one flow. */
+    startPaths?: Step[][];
+    /** "bad": only try invalid values in text fields, and try them first. Default "both". */
+    input?: "both" | "bad";
+    /** Called as the walk goes: each action taken, each new screen, each new finding. */
+    onEvent?: (e: WalkEvent) => void;
+    /** Checked before every action. When it returns true the walk ends and says it was stopped. */
+    shouldStop?: () => boolean;
+};
+export type WalkEvent = {
+    type: "step";
+    n: number;
+    step: Step;
+    text: string;
+} | {
+    type: "screen";
+    screens: number;
+    sig: string;
+    controls: {
+        role: string;
+        name: string;
+    }[];
+} | {
+    type: "finding";
+    n: number;
+    finding: Finding;
+};
+/**
+ * Walks the app. Each round it picks the screen to work on with an upper confidence bound: screens with nothing tried yet
+ * come first, then screens whose taps found new screens, with a bonus for rarely tried ones. On that screen it takes safe actions
+ * before risky ones (log out, delete, cancel, remove). Text fields get a valid value, then an invalid one.
+ */
+export declare function walk(driver: Driver, o?: WalkOptions): Promise<Report>;
 export declare function renderMarkdown(r: Report): string;
 /** Driver for a running simulator. */
-export declare function simDriver(base: string, app: string, session?: string): Driver;
+export declare function simDriver(base: string, app: string, session?: string, platform?: Skin): Driver;
 /** Use the simulator at `--sim <url>`, or build the app and start one on `--port` (default 4546). `stop` kills the one we started. */
 export declare function startSim(a: Record<string, string | undefined>, cfg: {
     name: string;
     appId: string;
     controlPlane: string;
-}): Promise<{
+}, quiet?: boolean): Promise<{
     base: string;
     stop: () => void;
 }>;
-/** Returns the exit code. */
+/** Returns the exit code. With `--json`, stdout is one envelope and everything else goes to stderr. */
 export declare function explore(argv: string[]): Promise<number>;
+/** The app's URL scheme: `expo.scheme` in app.json, else the scheme of a configured route such as "tide://cart". */
+export declare function appScheme(routes: string[] | undefined, dir?: string): string | undefined;
+/**
+ * Deep links to walk for `--changed-from <sha>`: the changed, routable screens (up to four), as `<scheme>://<screen>`.
+ * The walker opens them with the simulator's `open_url` action, which needs a URL the app's `onUrl` listener understands.
+ * If the diff cannot be read (for example a shallow checkout), or the app has no known scheme, say so and fall back to the full walk.
+ */
+export declare function routesFromChange(sha: string, log?: (s: string) => void, scheme?: string): Promise<{
+    routes?: string[];
+    onlyRoutes: boolean;
+}>;
+/** Exit code and `--json` code. A failed flow counts as a finding for `--fail-on-findings`; it has its own code when the walk found nothing. */
+export declare function outcome(report: {
+    error?: string | null;
+    findings: unknown[];
+}, flowsFailed: boolean, failOn: boolean): {
+    exit: number;
+    code: string;
+};
 export {};