taphound 0.2.0-dev.1

package/dist/domain/proposed-step.d.ts

@@ -0,0 +1,341 @@
+import { z } from "zod";
+export declare const ProposalBindingSchema: z.ZodObject<{
+    generationId: z.ZodString;
+    baseRevision: z.ZodNumber;
+    snapshotHash: z.ZodString;
+}, z.core.$strict>;
+export declare const ProposedStepSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    binding: z.ZodObject<{
+        generationId: z.ZodString;
+        baseRevision: z.ZodNumber;
+        snapshotHash: z.ZodString;
+    }, z.core.$strict>;
+    activity: z.ZodObject<{
+        before: z.ZodString;
+    }, z.core.$strict>;
+    expect: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"activity">;
+        value: z.ZodString;
+        timeoutMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"element">;
+        locator: z.ZodObject<{
+            resourceId: z.ZodOptional<z.ZodString>;
+            text: z.ZodOptional<z.ZodString>;
+            contentDescription: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        timeoutMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"logcat">;
+        tag: z.ZodString;
+        level: z.ZodOptional<z.ZodEnum<{
+            V: "V";
+            D: "D";
+            I: "I";
+            W: "W";
+            E: "E";
+            F: "F";
+            A: "A";
+        }>>;
+        pattern: z.ZodString;
+        match: z.ZodDefault<z.ZodEnum<{
+            literal: "literal";
+            regex: "regex";
+        }>>;
+        timeoutMs: z.ZodNumber;
+    }, z.core.$strict>], "type">>;
+    action: z.ZodLiteral<"click">;
+    locator: z.ZodObject<{
+        resourceId: z.ZodOptional<z.ZodString>;
+        text: z.ZodOptional<z.ZodString>;
+        contentDescription: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    binding: z.ZodObject<{
+        generationId: z.ZodString;
+        baseRevision: z.ZodNumber;
+        snapshotHash: z.ZodString;
+    }, z.core.$strict>;
+    activity: z.ZodObject<{
+        before: z.ZodString;
+    }, z.core.$strict>;
+    expect: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"activity">;
+        value: z.ZodString;
+        timeoutMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"element">;
+        locator: z.ZodObject<{
+            resourceId: z.ZodOptional<z.ZodString>;
+            text: z.ZodOptional<z.ZodString>;
+            contentDescription: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        timeoutMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"logcat">;
+        tag: z.ZodString;
+        level: z.ZodOptional<z.ZodEnum<{
+            V: "V";
+            D: "D";
+            I: "I";
+            W: "W";
+            E: "E";
+            F: "F";
+            A: "A";
+        }>>;
+        pattern: z.ZodString;
+        match: z.ZodDefault<z.ZodEnum<{
+            literal: "literal";
+            regex: "regex";
+        }>>;
+        timeoutMs: z.ZodNumber;
+    }, z.core.$strict>], "type">>;
+    action: z.ZodLiteral<"longClick">;
+    locator: z.ZodObject<{
+        resourceId: z.ZodOptional<z.ZodString>;
+        text: z.ZodOptional<z.ZodString>;
+        contentDescription: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    durationMs: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    binding: z.ZodObject<{
+        generationId: z.ZodString;
+        baseRevision: z.ZodNumber;
+        snapshotHash: z.ZodString;
+    }, z.core.$strict>;
+    activity: z.ZodObject<{
+        before: z.ZodString;
+    }, z.core.$strict>;
+    expect: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"activity">;
+        value: z.ZodString;
+        timeoutMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"element">;
+        locator: z.ZodObject<{
+            resourceId: z.ZodOptional<z.ZodString>;
+            text: z.ZodOptional<z.ZodString>;
+            contentDescription: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        timeoutMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"logcat">;
+        tag: z.ZodString;
+        level: z.ZodOptional<z.ZodEnum<{
+            V: "V";
+            D: "D";
+            I: "I";
+            W: "W";
+            E: "E";
+            F: "F";
+            A: "A";
+        }>>;
+        pattern: z.ZodString;
+        match: z.ZodDefault<z.ZodEnum<{
+            literal: "literal";
+            regex: "regex";
+        }>>;
+        timeoutMs: z.ZodNumber;
+    }, z.core.$strict>], "type">>;
+    action: z.ZodLiteral<"inputText">;
+    text: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    binding: z.ZodObject<{
+        generationId: z.ZodString;
+        baseRevision: z.ZodNumber;
+        snapshotHash: z.ZodString;
+    }, z.core.$strict>;
+    activity: z.ZodObject<{
+        before: z.ZodString;
+    }, z.core.$strict>;
+    expect: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"activity">;
+        value: z.ZodString;
+        timeoutMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"element">;
+        locator: z.ZodObject<{
+            resourceId: z.ZodOptional<z.ZodString>;
+            text: z.ZodOptional<z.ZodString>;
+            contentDescription: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        timeoutMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"logcat">;
+        tag: z.ZodString;
+        level: z.ZodOptional<z.ZodEnum<{
+            V: "V";
+            D: "D";
+            I: "I";
+            W: "W";
+            E: "E";
+            F: "F";
+            A: "A";
+        }>>;
+        pattern: z.ZodString;
+        match: z.ZodDefault<z.ZodEnum<{
+            literal: "literal";
+            regex: "regex";
+        }>>;
+        timeoutMs: z.ZodNumber;
+    }, z.core.$strict>], "type">>;
+    action: z.ZodLiteral<"swipe">;
+    locator: z.ZodObject<{
+        resourceId: z.ZodOptional<z.ZodString>;
+        text: z.ZodOptional<z.ZodString>;
+        contentDescription: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    direction: z.ZodEnum<{
+        left: "left";
+        right: "right";
+        up: "up";
+        down: "down";
+    }>;
+    distancePercent: z.ZodDefault<z.ZodNumber>;
+    durationMs: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    binding: z.ZodObject<{
+        generationId: z.ZodString;
+        baseRevision: z.ZodNumber;
+        snapshotHash: z.ZodString;
+    }, z.core.$strict>;
+    activity: z.ZodObject<{
+        before: z.ZodString;
+    }, z.core.$strict>;
+    expect: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"activity">;
+        value: z.ZodString;
+        timeoutMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"element">;
+        locator: z.ZodObject<{
+            resourceId: z.ZodOptional<z.ZodString>;
+            text: z.ZodOptional<z.ZodString>;
+            contentDescription: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        timeoutMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"logcat">;
+        tag: z.ZodString;
+        level: z.ZodOptional<z.ZodEnum<{
+            V: "V";
+            D: "D";
+            I: "I";
+            W: "W";
+            E: "E";
+            F: "F";
+            A: "A";
+        }>>;
+        pattern: z.ZodString;
+        match: z.ZodDefault<z.ZodEnum<{
+            literal: "literal";
+            regex: "regex";
+        }>>;
+        timeoutMs: z.ZodNumber;
+    }, z.core.$strict>], "type">>;
+    action: z.ZodLiteral<"scrollTo">;
+    locator: z.ZodObject<{
+        resourceId: z.ZodOptional<z.ZodString>;
+        text: z.ZodOptional<z.ZodString>;
+        contentDescription: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    container: z.ZodObject<{
+        resourceId: z.ZodOptional<z.ZodString>;
+        text: z.ZodOptional<z.ZodString>;
+        contentDescription: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    direction: z.ZodEnum<{
+        left: "left";
+        right: "right";
+        up: "up";
+        down: "down";
+    }>;
+    maxSwipes: z.ZodDefault<z.ZodNumber>;
+    distancePercent: z.ZodDefault<z.ZodNumber>;
+    durationMs: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    binding: z.ZodObject<{
+        generationId: z.ZodString;
+        baseRevision: z.ZodNumber;
+        snapshotHash: z.ZodString;
+    }, z.core.$strict>;
+    activity: z.ZodObject<{
+        before: z.ZodString;
+    }, z.core.$strict>;
+    expect: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"activity">;
+        value: z.ZodString;
+        timeoutMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"element">;
+        locator: z.ZodObject<{
+            resourceId: z.ZodOptional<z.ZodString>;
+            text: z.ZodOptional<z.ZodString>;
+            contentDescription: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        timeoutMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"logcat">;
+        tag: z.ZodString;
+        level: z.ZodOptional<z.ZodEnum<{
+            V: "V";
+            D: "D";
+            I: "I";
+            W: "W";
+            E: "E";
+            F: "F";
+            A: "A";
+        }>>;
+        pattern: z.ZodString;
+        match: z.ZodDefault<z.ZodEnum<{
+            literal: "literal";
+            regex: "regex";
+        }>>;
+        timeoutMs: z.ZodNumber;
+    }, z.core.$strict>], "type">>;
+    action: z.ZodLiteral<"back">;
+}, z.core.$strict>, z.ZodObject<{
+    binding: z.ZodObject<{
+        generationId: z.ZodString;
+        baseRevision: z.ZodNumber;
+        snapshotHash: z.ZodString;
+    }, z.core.$strict>;
+    activity: z.ZodObject<{
+        before: z.ZodString;
+    }, z.core.$strict>;
+    expect: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"activity">;
+        value: z.ZodString;
+        timeoutMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"element">;
+        locator: z.ZodObject<{
+            resourceId: z.ZodOptional<z.ZodString>;
+            text: z.ZodOptional<z.ZodString>;
+            contentDescription: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        timeoutMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"logcat">;
+        tag: z.ZodString;
+        level: z.ZodOptional<z.ZodEnum<{
+            V: "V";
+            D: "D";
+            I: "I";
+            W: "W";
+            E: "E";
+            F: "F";
+            A: "A";
+        }>>;
+        pattern: z.ZodString;
+        match: z.ZodDefault<z.ZodEnum<{
+            literal: "literal";
+            regex: "regex";
+        }>>;
+        timeoutMs: z.ZodNumber;
+    }, z.core.$strict>], "type">>;
+    action: z.ZodLiteral<"wait">;
+}, z.core.$strict>], "action">;
+export type ProposedStep = z.infer<typeof ProposedStepSchema>;
+export type ProposalBinding = z.infer<typeof ProposalBindingSchema>;
+export declare function hashProposedStep(step: unknown): string;

package/dist/domain/proposed-step.js

@@ -0,0 +1,87 @@
+import { createHash } from "node:crypto";
+import { z } from "zod";
+import { ExpectSchema } from "./journey.js";
+import { LocatorSchema } from "./layout.js";
+const QualifiedActivitySchema = z.string().regex(/^(?:[A-Za-z_$][\w$]*\.)+[A-Za-z_$][\w$]*$/, "Activity checkpoint must be fully qualified");
+const ProposedActivitySchema = z.strictObject({
+    before: QualifiedActivitySchema
+});
+export const ProposalBindingSchema = z.strictObject({
+    generationId: z.string().regex(/^[A-Za-z\d](?:[A-Za-z\d._-]*[A-Za-z\d])?$/),
+    baseRevision: z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+    snapshotHash: z.string().regex(/^[a-f\d]{64}$/)
+});
+const CommonStepShape = {
+    binding: ProposalBindingSchema,
+    activity: ProposedActivitySchema,
+    expect: ExpectSchema.optional()
+};
+const ClickStepSchema = z.strictObject({
+    action: z.literal("click"),
+    locator: LocatorSchema,
+    ...CommonStepShape
+});
+const LongClickStepSchema = z.strictObject({
+    action: z.literal("longClick"),
+    locator: LocatorSchema,
+    durationMs: z.number().int().positive().default(800),
+    ...CommonStepShape
+});
+const InputTextStepSchema = z.strictObject({
+    action: z.literal("inputText"),
+    text: z.string().min(1),
+    ...CommonStepShape
+});
+const SwipeStepSchema = z.strictObject({
+    action: z.literal("swipe"),
+    locator: LocatorSchema,
+    direction: z.enum(["up", "down", "left", "right"]),
+    distancePercent: z.number().positive().max(1).default(0.6),
+    durationMs: z.number().int().positive().default(300),
+    ...CommonStepShape
+});
+const ScrollToStepSchema = z.strictObject({
+    action: z.literal("scrollTo"),
+    locator: LocatorSchema,
+    container: LocatorSchema,
+    direction: z.enum(["up", "down", "left", "right"]),
+    maxSwipes: z.number().int().positive().max(30).default(20),
+    distancePercent: z.number().positive().max(1).default(0.6),
+    durationMs: z.number().int().positive().default(300),
+    ...CommonStepShape
+});
+const BackStepSchema = z.strictObject({
+    action: z.literal("back"),
+    ...CommonStepShape
+});
+const WaitStepSchema = z.strictObject({
+    action: z.literal("wait"),
+    ...CommonStepShape
+});
+export const ProposedStepSchema = z.discriminatedUnion("action", [
+    ClickStepSchema,
+    LongClickStepSchema,
+    InputTextStepSchema,
+    SwipeStepSchema,
+    ScrollToStepSchema,
+    BackStepSchema,
+    WaitStepSchema
+]);
+function canonicalize(value) {
+    if (Array.isArray(value)) {
+        return value.map(canonicalize);
+    }
+    if (value !== null && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value)
+            .filter(([, item]) => item !== undefined)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, item]) => [key, canonicalize(item)]));
+    }
+    return value;
+}
+export function hashProposedStep(step) {
+    const parsed = ProposedStepSchema.parse(step);
+    return createHash("sha256")
+        .update(JSON.stringify(canonicalize(parsed)))
+        .digest("hex");
+}