playthrough 0.3.0 → 0.4.0

package/src/test.js

@@ -1,5 +1,5 @@
-import { a as HANDS, c as PICTURE, d as UNMET, f as WROTE, i as GLIMPSES, l as READINGS, n as ASSETS, o as HOLD, p as firstLine, s as PERSON, t as ACTIONS, u as RECORDING, v as seconds, y as keepAssets } from "./reporter-4C_7joIm.js";
-import { C as make, E as repo, T as setupIn, b as changes, n as REACHES_OUTSIDE, r as WALKED, t as ALONGSIDE, w as personIn, x as firstOf } from "./flows-Dt7fcPLt.js";
+import { a as GLIMPSES, c as PERSON, d as RECORDING, f as WROTE, l as PICTURE, n as ASSETS, o as HANDS, p as firstLine, r as DONE_ON, s as HOLD, t as ACTIONS, u as READINGS, v as seconds, y as keepAssets } from "./reporter-DE8aueAO.js";
+import { C as firstOf, D as setupIn, E as personIn, O as repo, S as changes, T as make, n as REACHES_OUTSIDE, r as WALKED, t as ALONGSIDE } from "./flows-BkG0TgHA.js";
 import { n as readPage, r as unhovered } from "./read-Bg9XVTtn.js";
 import { readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
@@ -83,7 +83,7 @@ function onlyWaits(expect) {
 		if (typeof check !== "function") return check;
 		return (...args) => {
 			try {
-				return Promise.resolve(check.apply(target, args)).catch(() => underway && (underway.unmet = (underway.unmet ?? 0) + 1));
+				return Promise.resolve(check.apply(target, args)).catch(() => {});
 			} catch {}
 		};
 	} });
@@ -185,7 +185,8 @@ const recorded = test$1.extend({
 			actions: [],
 			inStep: 0,
 			hands: [],
-			assets: []
+			assets: [],
+			doneOn: {}
 		};
 		await page.exposeFunction("__playthrough", (event) => void (flow.page === page && flow.events.push(event)));
 		flow.assets.push(keepAssets(page, run.folder));
@@ -260,9 +261,9 @@ const recorded = test$1.extend({
 			body: flow.wrote,
 			contentType: "text/plain"
 		});
-		if (flow.unmet) await testInfo.attach(UNMET, {
-			body: String(flow.unmet),
-			contentType: "text/plain"
+		await testInfo.attach(DONE_ON, {
+			body: JSON.stringify(flow.doneOn),
+			contentType: "application/json"
 		});
 		for (const picture of pictures) await testInfo.attach(PICTURE, {
 			body: picture,
@@ -592,7 +593,6 @@ const step = Object.assign(async (title, body, options) => {
 	const flow = underway;
 	if (!flow || flow.depth) return playwrightStep(title, body, options);
 	return playwrightStep(title, async (info) => {
-		if (run?.stops?.[test$1.info().title] === title) throw new Error("It stopped here the first time it was recorded.");
 		Object.assign(flow, {
 			step: title,
 			inStep: 0
@@ -688,6 +688,7 @@ function pace(page) {
 			}
 			const timeout = args.findLast((arg) => !!arg && typeof arg === "object" && typeof arg.timeout === "number")?.timeout;
 			if (pointer) await approach(this, pointer, timeout).catch((error) => Promise.reject(asAction(error, action)));
+			if (underway?.depth) await follow(underway, this);
 			const [text, options] = args;
 			const typed = pointer && action === "fill" && typeof text === "string" && text && await typedInto(this) ? text : void 0;
 			const result = await acted(action, () => pathTo(this), typed ? async () => {
@@ -759,6 +760,26 @@ async function acted(does, target, act, given) {
 	if (keeping) await reached(keeping, keeping.step, ++keeping.actions);
 	return result;
 }
+async function follow(flow, target) {
+	const on = await doneOn(target);
+	const done = flow.doneOn[flow.step ?? ""] ??= [];
+	const inRound = run?.before && run.doneInRound?.[test$1.info().title]?.[flow.step ?? ""]?.[done.length];
+	done.push(on ?? null);
+	if (on && inRound && !alike(on, inRound)) throw new Error(`The app as it was has ${on.role} “${on.name}” here, where the round has ${inRound.role} “${inRound.name}”.`);
+}
+const doneOn = (target) => target.ariaSnapshot({ timeout: 1e3 }).then((snapshot) => {
+	const [, role, name, words] = snapshot.match(/^- ([\w-]+)(?: "((?:[^"\\]|\\.)*)")?[^:\n]*(?::\s*(.*))?/) ?? [];
+	return role ? {
+		role,
+		name: name ?? (role === "text" ? words ?? "" : "")
+	} : void 0;
+}, () => void 0);
+function alike(one, other) {
+	if (one.role !== other.role) return false;
+	const words = (name) => name.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter(Boolean);
+	const [few, many] = [words(one.name), words(other.name)].sort((a, b) => a.length - b.length);
+	return !few.length || few.filter((word) => many.includes(word)).length * 2 >= few.length;
+}
 async function walkOn(flow, walk) {
 	await flow.rest();
 	const since = () => seconds(Date.now() - (flow.events[0]?.timestamp ?? Date.now()));

package/types/cli/src/flows.d.ts

@@ -14,8 +14,13 @@ export type Run = {
     taken: string[];
     started: string;
     walk?: Walk;
-    stops?: Record<string, string>;
+    doneInRound?: Record<string, DoneOn>;
 };
+export type On = {
+    role: string;
+    name: string;
+};
+export type DoneOn = Record<string, (On | null)[]>;
 export type Walk = {
     flow: string;
     step: string;
@@ -79,14 +84,16 @@ export declare function makeFlowsFolder(repo: Repo, id: string): Promise<void>;
 export declare const called: (names: string[]) => string;
 export declare const isFlow: (name: string) => boolean;
 export declare function howToWriteFlows(repo: Repo, id: string): string;
-export declare function runFlows(repo: Repo, id: string, round: number, { later, first }: {
-    later?: {
+export declare function flowsOf(repo: Repo, id: string): Promise<string>;
+export declare function runFlows(repo: Repo, id: string, round: number, { before, first }: {
+    before?: {
         flows: string[];
         taken: string[];
+        doneInRound: Record<string, DoneOn>;
     };
-    first: (flow: string) => boolean;
+    first?: (flow: string) => boolean;
 }): Promise<Ran>;
-export declare function keepFailed(repo: Repo, id: string, round: number, failed: Failed[]): Promise<void>;
+export declare function keepFailed(repo: Repo, id: string, failed: Failed[]): Promise<void>;
 export declare const failedLastTime: (repo: Repo, id: string) => Promise<string[]>;
 export declare const whereItStopped: (repo: Repo, id: string, failed: Failed[]) => string;
 export type Ran = {
@@ -97,6 +104,7 @@ export type Ran = {
             bytes: Buffer;
         }[];
         wrote?: string;
+        doneOn?: DoneOn;
     }[];
     failed: Failed[];
     written: Record<string, Written>;

package/types/cli/src/reporter.d.ts

@@ -1,6 +1,7 @@
 import type { Reporter, TestCase, TestError, TestResult } from "@playwright/test/reporter";
 import type { Reading } from "../../page/src/index.js";
 import { type Flow, type Reviews } from "../../review/src/index.js";
+import type { DoneOn } from "./flows.js";
 export declare const RECORDING = "playthrough recording";
 export declare const READINGS = "playthrough readings";
 export declare const GLIMPSES = "playthrough glimpses";
@@ -10,7 +11,7 @@ export declare const PERSON = "playthrough person";
 export declare const HANDS = "playthrough hands";
 export declare const ACTIONS = "playthrough actions";
 export declare const WROTE = "playthrough wrote";
-export declare const UNMET = "playthrough unmet";
+export declare const DONE_ON = "playthrough done on";
 export declare const HOLD = 1500;
 export declare const readingsOf: (flow: Flow) => string;
 export declare function readingsOn(reviews: Reviews, review: string, round: number, flow: Flow): Promise<Reading[]>;
@@ -26,6 +27,7 @@ export type Recorded = {
     flow: Flow;
     files: string[];
     wrote?: string;
+    doneOn?: DoneOn;
 };
 export type Hand = {
     at: number;

package/types/cli/src/try-setup.d.ts

@@ -1,2 +1,3 @@
 import type { Repo } from "./repo.js";
 export declare function trySetup(repo: Repo, again: string): Promise<void>;
+export declare function writtenNow(repo: Repo): Promise<string>;

package/types/page/src/found.d.ts

@@ -1,5 +1,5 @@
-import { type Element, type Flow, type Place } from "../../review/src/index.js";
-import type { Reading, Thing } from "./reading.js";
+import { type Element, type Flow, type Place, type Point } from "../../review/src/index.js";
+import type { Glimpse, Reading, Thing } from "./reading.js";
 export type Recorded = {
     flow: Flow;
     readings: Reading[];
@@ -9,5 +9,7 @@ export type Shown = {
     thing: Thing;
 };
 export declare function placeIn(place: Place, from: Recorded, to: Recorded): Place;
+export declare const HOLDING: RegExp;
+export declare const nearTo: (read: Glimpse[], at: number, point: Point) => Thing | undefined;
 export declare function shownAt(readings: Reading[], element: Element, at: number): Shown | undefined;
 export declare const elementOf: (thing: Thing, name: string) => Element;

package/types/review/src/model.d.ts

@@ -128,6 +128,7 @@ export declare const Change: z.ZodObject<{
             length: z.ZodNumber;
         }, z.core.$strict>>;
     }, z.core.$strict>>;
+    pictureOnly: z.ZodOptional<z.ZodLiteral<true>>;
 }, z.core.$strict>;
 export declare const Comparison: z.ZodObject<{
     round: z.ZodNumber;
@@ -176,6 +177,7 @@ export declare const Comparison: z.ZodObject<{
                 length: z.ZodNumber;
             }, z.core.$strict>>;
         }, z.core.$strict>>;
+        pictureOnly: z.ZodOptional<z.ZodLiteral<true>>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
 export declare const Account: z.ZodUnion<readonly [z.ZodObject<{
@@ -556,6 +558,7 @@ export declare const Review: z.ZodObject<{
                     length: z.ZodNumber;
                 }, z.core.$strict>>;
             }, z.core.$strict>>;
+            pictureOnly: z.ZodOptional<z.ZodLiteral<true>>;
         }, z.core.$strict>>;
     }, z.core.$strict>>;
     sends: z.ZodArray<z.ZodObject<{

package/types/review/src/rules.d.ts

@@ -1,5 +1,6 @@
 import { Comparison, Round, Send, type Account, type Flow, type Note, type Place, type Review, type Verdict } from "./model.js";
 export declare function roundInProgress(review: Review): number;
+export declare function inOrderJoined(review: Review): string[];
 export declare function allNotes(review: Review): Map<string, {
     note: Note;
     round: number;
@@ -27,6 +28,52 @@ export declare function problemsAddingToBefore(review: Review, flows: Flow[], ca
 export declare function withInBefore(before: Round, flows: Flow[], cantStart: string[], gone?: string[]): Round;
 export declare function problemsWithComparison(review: Review, comparison: Comparison): string[];
 export declare const LONGEST_LINE = 140;
+export declare const toAccountFor: (comparison?: Comparison) => {
+    id: string;
+    words: string;
+    seen: {
+        flow: string;
+        at?: number | undefined;
+        until?: number | undefined;
+        element?: {
+            role: string;
+            name: string;
+            css?: string | undefined;
+            node?: number | undefined;
+        } | undefined;
+        alike?: {
+            role: string;
+            name: string;
+            css?: string | undefined;
+            node?: number | undefined;
+        }[] | undefined;
+        box?: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        } | undefined;
+        point?: {
+            x: number;
+            y: number;
+        } | undefined;
+        app?: {
+            from: {
+                flow: string;
+                at: number;
+            };
+            did: {
+                does: string;
+                on: string;
+                with?: string | boolean | string[] | undefined;
+                what?: string | undefined;
+            }[];
+            recording: string;
+            length: number;
+        } | undefined;
+    }[];
+    pictureOnly?: true | undefined;
+}[];
 export declare function problemsFinishing(review: Review, number: number): string[];
 export declare function problemsWithFile(review: Review, round: number, name: string): string[];
 export declare function problemsWithFileName(name: string): string[];

package/types/review/src/store.d.ts

@@ -29,7 +29,6 @@ export declare class Reviews {
             name: string;
             bytes: Uint8Array;
         }[];
-        commit?: string;
         gone?: string[];
     }): Promise<void>;
     saveComparison(id: string, comparison: Comparison): Promise<void>;