mirror of
https://github.com/expo/explore.git
synced 2026-11-15 13:18:16 -10:00
Compare commits
11
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
58a9facf1c | ||
|
|
51319403bb | ||
|
|
eaba870ac9 | ||
|
|
40f53e026a | ||
|
|
1be9fe7fde | ||
|
|
431105ff49 | ||
|
|
c9ab89025b | ||
|
|
72bdb8772c | ||
|
|
4ed584c990 | ||
|
|
f2de6c9002 | ||
|
|
d992899292 |
No files matched your search
+1
-1
@@ -32,7 +32,7 @@ This file describes the source layout and the rules that keep it in order.
|
||||
| `cli` | Argument parsing, help, and the command handlers. | `args.ts`, `help.ts`, `*-commands.ts` |
|
||||
| `map` | The local map store, build catalogs and comparisons, and the server for `expo-explore view`. | `store.ts`, `build-workspace.ts`, `compare.ts`, `viewer-server.ts` |
|
||||
| `contracts` | The modules that `viewer/src` imports from `src/`, by value or by type: data shapes, validators and projections that the CLI and the Viewer share. `capture.ts` also defines the review types that the Viewer reads, such as `PublicReview`, and `review-validation.ts` validates them. | `capture.ts`, `review.ts`, `review-validation.ts`, `source-validation.ts` |
|
||||
| `shared` | Small Node utilities that several folders use, and the pinned `agent-device` version that capture and review both check. | `ci-errors.ts`, `canonical-json.ts`, `bounded-bytes.ts`, `png-evidence.ts`, `agent-device-version.ts` |
|
||||
| `shared` | Small Node utilities that several folders use, and the pinned `agent-device` version that capture and review both check. | `ci-errors.ts`, `canonical-json.ts`, `bounded-bytes.ts`, `png-evidence.ts`, `agent-device-version.ts`, `timings.ts` (a capture job's timings and its summary, CI-FLOW §4.0) |
|
||||
|
||||
## Dependency rule
|
||||
|
||||
|
||||
+11
-1
@@ -91,7 +91,7 @@ A failure at any stage is recorded in `state.failure`, a partial report is writt
|
||||
Right after a merge, the next pull request's review starts while the baseline workflow is still capturing the new base: in brentvatne/euxy's review run 39348956443 it had started 15 s before, and every target captured its base too (10–14 minutes per target instead of about 6, on twice the EAS Simulator sessions). A baseline job takes 6–8 minutes and head capture 5–8, so `capture:review` waits for the baseline beside head instead of before it (`src/ci/baseline-wait.ts`):
|
||||
|
||||
1. The wait starts after preflight, only when `EXPLORE_BASELINE_RUN` names a run, no downloaded baseline matches, base has routes to capture, and `capture.baselineWaitMinutes` (default 15, 0 never waits) is not 0. Head starts capturing at once.
|
||||
2. Every 20 s it reads the run (checked again by the same trust rules as `ci:find-baseline`), this target's artifact (`explore-baseline-<sha>-<target>`) in that run, and the run's jobs, logging `waiting for main's baseline run <id> of <sha> (<target>: in progress, 3 min)` once a minute or when the state changes. Each read retries GitHub's 5xx and network failures (`retryGitHubLookup`).
|
||||
2. Every 20 s it reads the run (checked again by the same trust rules as `ci:find-baseline`), this target's artifact (`explore-baseline-<sha>-<target>`) in that run, and the run's jobs, logging `waiting for main's baseline run <id> of <sha> (<target>: in progress, in "<step>" for 2 min, 3 min)` once a minute or when the state changes, after one line with the run's link. The step is the one the baseline job is in: in brentvatne/euxy#179 a baseline sat 19 minutes installing ffmpeg while the line said only "in progress". When the state or the step changes, the sticky comment's line for the target says so too (`head 16/16 · base waits for the default branch's baseline (in "<step>")`), through a post that skips the PR check and never fails the review. Each read retries GitHub's 5xx and network failures (`retryGitHubLookup`).
|
||||
3. When the artifact is listed, it is downloaded in-process (the token goes to GitHub, never to the storage URL it redirects to), unpacked into `<output>/baseline-download` within the cache's size limits, and restored as a downloaded baseline once head has its runtime profile. Another target's failed job does not matter; each target's job uploads its own artifact.
|
||||
4. The wait ends without a baseline when this target's job fails, is cancelled or is skipped, the run ends without listing the artifact for a minute, the time runs out, GitHub refuses the token (`actions: read` missing) or keeps failing, or head fails. Base then captures at once, beside head when the sides capture concurrently. The wait never fails the review.
|
||||
|
||||
@@ -109,6 +109,16 @@ Head capture is never delayed. When the baseline arrives while head captures, ba
|
||||
| 6 | route capture | Mode-specific (§5). `agent-device` drives the simulator and records a screenshot plus the accessibility tree. A capture is accepted only when the observer's reported destination matches the requested route. |
|
||||
| 7 | `export` / `cleanup` | Validate the map, write `<side>-export/` (`bundle.json`, `execution.json`, PNGs, `capture-diagnostics/`), stop the session. |
|
||||
|
||||
### 4.0 Timings and heartbeats
|
||||
|
||||
Every capture job appends its timings to `$RUNNER_TEMP/explore-diagnostics/timings.jsonl` as it runs (`src/shared/timings.ts`). The diagnostics artifact already uploads that folder `if: always()`, so no workflow change is needed, and a job killed partway leaves what it did up to then.
|
||||
|
||||
- **Spans.** The review's and the baseline's phases (`controllers`, `plan`, `preflight`, `capture`, `compare`, `notes`, `report`). For each side and appearance pass: `configuration`, `fingerprint`, `build-lookup`, `native-build`, `repack`, `repack-share-wait`, `build-download`, `session-start` (from the request, beside the repack, to the session EAS hands over), `session-verify`, `install`, `launch`, each `route`, and `session-stop`. Spans overlap: head runs beside the baseline wait, and the session starts beside the repack.
|
||||
- **The wait for a baseline.** `baseline-wait` is the whole wait, beside head; `baseline-blocked` is what it cost, from where base would have started to its end. The steps the baseline job finished, or was still in, are recorded as `baseline-step`.
|
||||
- **What is written.** Phase names, ids, counts, durations and outcome codes; strings pass `safeText` (redacted, no links, one short line), and links are rebuilt from validated ids (`githubRunLink`, `easPageLink`), never copied from eas-cli's output. A simulator session's link is never written: sessions start with `--public-link`.
|
||||
- **The summary.** The capture command appends a table to the job summary when it ends; `ci:after-capture` does for a capture stopped before it could.
|
||||
- **Heartbeats.** A poll-driven wait prints when it starts and once a minute after: the baseline wait, the hosted repack (its state, time waited and budget left) and a shared repack being followed. A call that blocks its thread prints its bound first (`eas build --wait` 45 minutes, `workflow:run` 10, `build:download` 10, the app install 15). A side on a worker thread (sides captured at once, split appearance passes) has its parent print `head: still in install (3 min of at most 15 min)` once a minute while it is blocked; on the main thread nothing can run meanwhile.
|
||||
|
||||
### 4.1 The hosted repack: one budget, retries, and one repack per commit for a run's jobs
|
||||
|
||||
`prepareHostedRepack` (`src/capture/eas-build.ts`) runs the repack job. Three things keep it from failing a target, running long, or repeating work.
|
||||
|
||||
@@ -22,10 +22,10 @@ Explore maps your app: a screenshot of every screen, connected by the taps betwe
|
||||
<a href="docs/screenshots/readme-screens-light.png">
|
||||
<picture>
|
||||
<source media="(prefers-color-scheme: dark)" srcset="docs/screenshots/readme-screens-dark.png">
|
||||
<img width="100%" alt="The Screens view of a euxy review showing Changed 7 of All 19: the app/ route tree on the left, and beside it a grid of the changed screens in the same order, each with its route below the screenshot: a red dot for the removed /lane-editor, orange for the modified /new-pattern and /channel-surf, green for the new /lane-editor/0, and Changed in dark under /p and /patterns" src="docs/screenshots/readme-screens-light.png">
|
||||
<img width="100%" alt="The Screens view of a euxy review showing Changed 7 of All 19: a Search field and the app/ route tree on the left, and beside it a grid of the changed screens in the same order, each with its route below the screenshot: a red dot for the removed /lane-editor, orange for the modified /new-pattern and /channel-surf, green for the new /lane-editor/0, and Changed in dark under /p, /patterns and a /p/ link; at the top right, a switch between Grid and Filmstrip" src="docs/screenshots/readme-screens-light.png">
|
||||
</picture>
|
||||
</a>
|
||||
<strong>Screens</strong>: every capture in one grid, or only the changed ones, beside the route tree, with a dot for what changed.
|
||||
<strong>Screens</strong>: every capture, or only the changed ones, in a grid or one at a time in a filmstrip, beside the route tree, with a dot for what changed.
|
||||
</td>
|
||||
<td width="50%" valign="top">
|
||||
<a href="docs/screenshots/readme-pr-comment-light.png">
|
||||
@@ -579,6 +579,7 @@ sequenceDiagram
|
||||
- The review workflow runs on open, non-draft PRs from the repository whose author has write access. Bots such as Devin go under `ci.trustedAuthors` in `.expo-explore/config.yaml`.
|
||||
- A screen with a source change is **Modified** if its captures differ.
|
||||
- If EAS fails to start a session, Explore starts a new one, up to five times within 30 minutes. On your machine, a local simulator can stand in for EAS Simulator.
|
||||
- Each capture job's summary shows where its time went, phase by phase, and its diagnostics artifact keeps the timings (`timings.jsonl`). When a review waits for the baseline of its base commit, its log and the PR comment name the step that baseline job is in.
|
||||
|
||||
The same review runs for any two commits without a PR ([`explore-compare.yml`](#compare-any-two-commits), linking the report from the run summary) and on your machine (`capture`, [above](#quick-start)). The workflows' logic lives in `expo-explore ci:*` commands, so a fix reaches CI with the `@expo/explore` version the workflows pin.
|
||||
|
||||
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 315 KiB After Width: | Height: | Size: 324 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 316 KiB After Width: | Height: | Size: 326 KiB |
@@ -0,0 +1,9 @@
|
||||
# Ideas
|
||||
|
||||
Plans for work we may build later. An idea records the problem, the evidence
|
||||
for it, and a plan someone can pick up. Nothing here is scheduled. Defects that
|
||||
CI hits today belong in [`issues/`](../issues/README.md), not here.
|
||||
|
||||
Start each file with its status: `Not started`, `In progress` (with a link to
|
||||
the branch or PR), or `Built` (with a link to what shipped). Line references
|
||||
are to the commit named at the top of each file and will drift.
|
||||
@@ -0,0 +1,245 @@
|
||||
# Capture base and head under the same conditions
|
||||
|
||||
Status: Not started. Line references are to `4ed584c9` (Release 0.20.7).
|
||||
|
||||
A review compares a route's base frame with its head frame and reports the
|
||||
difference as the PR's change. That only holds when both frames were captured
|
||||
from the same app state and the same keyboard. Today neither is guaranteed,
|
||||
and a screen the PR did not touch can lead the comment with a large change.
|
||||
|
||||
## What we saw
|
||||
|
||||
In euxy#176's 0.20.7 review (iPhone, runs 39521260432 head and 39521251171
|
||||
baseline), two rows were wrong:
|
||||
|
||||
1. **App state.** Dark `/rename-pattern` showed "Untitled" on base and
|
||||
"Lo-Fi Bounce" on head. The row led with "Added button 'Pattern Lo-Fi
|
||||
Bounce — menu'".
|
||||
2. **Keyboard.** The software keyboard was drawn in some captures of the
|
||||
autofocused rename sheet and not others, a 46–48% visual mismatch.
|
||||
`keyboard.jsonl` said `shown` for every frame, drawn or not.
|
||||
|
||||
## Why
|
||||
|
||||
**App data carries from one appearance pass to the next.** Head ran light
|
||||
routes 1–16 and then dark routes 1–16 in one session. The light pass's `/p`
|
||||
import (routes 10–11) appends a pattern and makes it active, persisted in
|
||||
sqlite:
|
||||
|
||||
```ts
|
||||
// euxy src/state/store.ts
|
||||
patterns: [...s.patterns, pattern],
|
||||
activePatternId: pattern.id,
|
||||
```
|
||||
|
||||
euxy captures with `launch: video`, so the dark pass relaunches through
|
||||
`captureLaunch` ([`run.ts:1030`](../src/capture/run.ts)), which keeps app data
|
||||
on purpose. Launch errors there are caught and logged, and routes are captured
|
||||
anyway. The plain relaunch at [`run.ts:1041`](../src/capture/run.ts) only runs
|
||||
when launch observation is off. The baseline split light and dark into fresh
|
||||
sessions, so its dark pass started clean. Session layout is excluded from the
|
||||
capture recipe on the grounds that it does not change the evidence
|
||||
([`artifact-cache.ts:34`](../src/ci/artifact-cache.ts)), which is not true
|
||||
today.
|
||||
|
||||
**Partial baseline reuse changes the order.** When only some routes are cached,
|
||||
the base side captures just the rest
|
||||
([`run.ts:357`](../src/capture/run.ts)):
|
||||
|
||||
```ts
|
||||
const missingRoutes = routes.filter(route => !cachedImages[route.id]);
|
||||
```
|
||||
|
||||
Those frames see a different history within the pass from head's.
|
||||
|
||||
**"Shown" is only the accessibility tree's word.** `keyboardSettle`
|
||||
([`keyboard.ts`](../src/capture/keyboard.ts)) reports `shown` after two
|
||||
matching tree reads, including frames with no keyboard drawn.
|
||||
`keyboard.jsonl` is not in the exported diagnostics
|
||||
([`run.ts:384`](../src/capture/run.ts)).
|
||||
|
||||
**A caveat cannot win the row.** `decideReview`
|
||||
([`evidence-assessment.ts:471`](../src/review/evidence-assessment.ts)) makes
|
||||
any difference `modified` and uses the first fact as the description:
|
||||
|
||||
```ts
|
||||
const differs = visual.verdict === "modified" || changes.length > 0;
|
||||
```
|
||||
|
||||
Review issues are appended only when there are no facts. Added and removed
|
||||
elements rank ahead of text changes (priority 20 vs 30,
|
||||
[`evidence-comparator.ts:143`](../src/review/evidence-comparator.ts)). With the
|
||||
keyboard up, euxy's raised sheet covers Hat, Clap and Bass, so those become the
|
||||
leading "Added/Removed button" facts.
|
||||
|
||||
**Reinstalling is not a clean slate.** Argent's `reinstall-app`
|
||||
([`argent-driver.ts:712`](../src/capture/argent-driver.ts)) uninstalls and
|
||||
installs, but ignores uninstall errors. iOS keychain and SecureStore data
|
||||
survive an uninstall. EAS `simulator:control` has no clear-data, keychain or
|
||||
keyboard action.
|
||||
|
||||
## Goal
|
||||
|
||||
For each route, base and head frames in the same appearance come from the same
|
||||
app history and an equally verified keyboard state, whatever the session layout
|
||||
and including reused baselines. Where the conditions still differ, the row says
|
||||
so instead of reporting a PR change. Real text changes are still reported.
|
||||
|
||||
Done means:
|
||||
|
||||
- Rerun euxy#176 against a fresh baseline. Dark `/rename-pattern` and
|
||||
`/patterns` show the same pattern on both sides.
|
||||
- Each keyboard screen either draws the keyboard on both sides, or reads
|
||||
"Added text 'Pattern name' · keyboard shown on one side only". It no longer
|
||||
leads with a 46% visual change or with buttons the sheet covers.
|
||||
- An unchanged screen with an autofocused field is never a PR change.
|
||||
|
||||
## Plan
|
||||
|
||||
### Phase 0: probes and diagnostics
|
||||
|
||||
These results decide whether phase 2 goes ahead and which reset each backend
|
||||
uses.
|
||||
|
||||
1. **Fuller keyboard log.** Add the scheme, the pass, the tree's keyboard
|
||||
bounds, Argent's `keyboardVisible`, the screen size and the app's keyboard
|
||||
metrics to `keyboard.jsonl`, and export it.
|
||||
2. **App-side keyboard probe on EAS**, with Argent and with agent-device. Read
|
||||
`Keyboard.metrics()` and the show and hide events, and work out how much of
|
||||
the window the keyboard covers. Compare that with a screenshot, a tree read,
|
||||
and a second screenshot about 2 s later. Capture at least one session where
|
||||
the keyboard is not drawn. The question is whether any signal separates
|
||||
drawn from not drawn, and whether a missing keyboard is a late draw or a
|
||||
suppressed one.
|
||||
3. **Reset probe.** Write a test value into app storage through a fixture
|
||||
app's deep link, reinstall through each controller on EAS and locally, and
|
||||
check that it is gone. Check the keychain too, and time each reset.
|
||||
|
||||
### Phase 1: identical app history
|
||||
|
||||
4. **`resetAppData` per backend**, using what phase 0 verified:
|
||||
- Argent: `reinstall-app`, checked with the test value.
|
||||
- agent-device: uninstall, then install.
|
||||
- Local iOS: `simctl uninstall` and `install`, plus
|
||||
`simctl keychain <udid> reset`.
|
||||
- Local Android: `pm clear`.
|
||||
|
||||
Reuse the built `localApp`. Any other backend reports `unsupported`.
|
||||
5. **Reset at the start of every later captured pass** (`capturePass` in
|
||||
`run.ts`):
|
||||
- Run it before appearance and launch observation, so it covers
|
||||
`launch: video` and `launch: off` alike.
|
||||
- Count the passes captured in this session, not the loop index. A
|
||||
dark-only split session starts at index 1.
|
||||
- A failed reset escapes into the per-pass `try` and lands in
|
||||
`sessionFailures`, not in the launch catch.
|
||||
- Clear `deepLinkPromptAccepted` in the bridge's install case and approve
|
||||
URL schemes again.
|
||||
6. **Fall back to separate sessions.** When no verified reset exists, or the
|
||||
app keeps state in the keychain on EAS, run each appearance in its own
|
||||
session ([`session-plan.ts`](../src/ci/session-plan.ts)).
|
||||
7. **Same history on both sides.**
|
||||
- Reuse a baseline pass only if every selected route in it is cached;
|
||||
otherwise capture the whole pass.
|
||||
- Capture routes that exist on only one side last in that side's pass.
|
||||
- Record `passStart: "fresh" | "continued"` and `reused` on each image
|
||||
entry.
|
||||
8. **Cache recipe.** Add `passStart` to `captureRecipeConfig`, so a capture
|
||||
without the reset is never reused against one with it, even without a
|
||||
version bump. Reword the `maxSessions` comment.
|
||||
|
||||
### Phase 2: keyboard state and an honest row
|
||||
|
||||
Only if phase 0 finds a signal that separates a drawn keyboard from an
|
||||
undrawn one.
|
||||
|
||||
9. **Keyboard signal from the app.** The observer
|
||||
([`observer.ts`](../src/capture/observer.ts)) reads `Keyboard.metrics()`
|
||||
when it mounts, then listens for show and hide. Add the key to the
|
||||
`parseCaptureDestination` allowlist so it never becomes a text node.
|
||||
10. **Three-state wait:**
|
||||
- `shown` when the tree and the app agree;
|
||||
- `suppressed` after two reads with the tree stable and the app reporting
|
||||
no coverage, without waiting out the 4 s cap;
|
||||
- `unknown` when the app gives no signal.
|
||||
11. **Tie the state to the screenshot.** Read it just before and just after
|
||||
the screenshot ([`route-capture.ts`](../src/capture/route-capture.ts)). If
|
||||
it changed, retake once, or record `unstable`. Store it on
|
||||
`images[id].keyboard` so it survives the scheme merge, `export-merge`,
|
||||
restore and the schema.
|
||||
12. **Review rule** (`evidence-assessment.ts`, after the facts are computed).
|
||||
It applies when the two sides' states differ, or when either is `unknown`
|
||||
or `unstable` on a screen with a focused text field. Then:
|
||||
- mark the visual verdict not comparable;
|
||||
- drop added or removed elements that sit where the other side's raised
|
||||
sheet or keyboard would cover them;
|
||||
- keep paired text edits, and text inside the focused container;
|
||||
- if text facts remain, the row is `modified` with the keyboard caveat
|
||||
appended to the description after `decideReview`;
|
||||
- otherwise a `scope === "none"` screen stays a variant, and anything else
|
||||
is `needs-review` with the caveat;
|
||||
- show the caveat in the PR comment and the Viewer.
|
||||
13. **Keep the keyboard on screen where possible.** Local Android:
|
||||
`settings put secure show_ime_with_hard_keyboard 1`. EAS: a serve-sim
|
||||
action, if one is added. Local iOS boots headless, so phase 0 confirms
|
||||
whether the Simulator.app preference applies.
|
||||
|
||||
### Rejected
|
||||
|
||||
- Dismissing the keyboard: Return submits euxy's sheet.
|
||||
- Masking the keyboard band: the sheet shift is most of the mismatch.
|
||||
- Detecting the keyboard from pixels: brittle across keyboards and themes.
|
||||
- A fresh context for every route: cost, and
|
||||
[`route-reset.ts`](../src/capture/route-reset.ts) records the settle
|
||||
failures that led away from it.
|
||||
- Replaying the other side's history: fragile; whole-pass reuse covers the
|
||||
case.
|
||||
|
||||
## Risks
|
||||
|
||||
- **Cost:** about 25 s of reset per extra pass, measured in phase 0.
|
||||
Whole-pass reuse costs more only when a pass is partly cached.
|
||||
- **No usable keyboard signal:** phase 2 ships only the "keyboard couldn't be
|
||||
verified" path.
|
||||
- **A real change hidden behind the sheet gets dropped:** the visual verdict is
|
||||
already not comparable there, and the caveat flags the screen for a person.
|
||||
- **New fields lost in merge or restore:** one test runs them through every
|
||||
step.
|
||||
|
||||
## Tests
|
||||
|
||||
- **`ci-map`:** reset before later passes with `launch: video` and
|
||||
`launch: off`; no reset for a dark-only first pass; a failed reset lands in
|
||||
`sessionFailures`; the session split when no reset exists; whole-pass reuse;
|
||||
one-side-only routes last.
|
||||
- **`keyboard`:** each state, Android `keyboardVisible`, and an `unstable`
|
||||
change around the screenshot.
|
||||
- **Observer:** the keyboard key never becomes a text node.
|
||||
- **Merge, cache and schema:** `images[id].keyboard` and `passStart` survive.
|
||||
- **Assessment, on the real rename trees from the runs above:** covered Hat,
|
||||
Clap and Bass are dropped; "Pattern name" carries the caveat; an unchanged
|
||||
autofocus screen is not a PR change; the comment row wording.
|
||||
- **Local end to end:** force no keyboard on Android
|
||||
(`show_ime_with_hard_keyboard 0` with a hardware keyboard) and check the
|
||||
recorded state and the row.
|
||||
- **Real run:** a fresh euxy baseline, then #176. Check the reset log and
|
||||
timing, dark rename and `/patterns`, `keyboard.jsonl`, and the row wording.
|
||||
|
||||
## Open questions
|
||||
|
||||
1. Can serve-sim add clear-app-data, keychain-reset and hardware-keyboard
|
||||
actions to EAS sessions? Without them, EAS relies on Argent's reinstall and
|
||||
on separate sessions for apps that keep state in the keychain.
|
||||
2. Is about 25 s per extra appearance pass acceptable by default, or should
|
||||
the reset be a setting?
|
||||
3. If phase 0 finds no signal that separates a drawn keyboard from an undrawn
|
||||
one, is labelling every focused-field screen with a differing or unverified
|
||||
keyboard as "keyboard couldn't be verified" acceptable?
|
||||
|
||||
## How this plan was made
|
||||
|
||||
Codex `gpt-6-astra`, Grok `grok-4.7` and Claude each wrote a plan
|
||||
independently. Each plan was reviewed by a different model, merged, and the
|
||||
merged plan reviewed again by all three, at high effort. The backbone is
|
||||
Claude's; the per-frame condition record came from Codex's; keeping the
|
||||
keyboard on screen and rejecting dismissal came from Grok's.
|
||||
Generated
+2
-2
@@ -1,12 +1,12 @@
|
||||
{
|
||||
"name": "@expo/explore",
|
||||
"version": "0.20.6",
|
||||
"version": "0.22.0",
|
||||
"lockfileVersion": 3,
|
||||
"requires": true,
|
||||
"packages": {
|
||||
"": {
|
||||
"name": "@expo/explore",
|
||||
"version": "0.20.6",
|
||||
"version": "0.22.0",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"@expo/repack-app": "0.10.1",
|
||||
|
||||
+1
-1
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "@expo/explore",
|
||||
"version": "0.20.6",
|
||||
"version": "0.22.0",
|
||||
"description": "Source-driven mobile app maps, deterministic CI capture, and visual reviews",
|
||||
"license": "MIT",
|
||||
"type": "module",
|
||||
|
||||
+44
-12
@@ -6,6 +6,7 @@ import { setTimeout as delay } from "node:timers/promises";
|
||||
import type { SourceRoute } from "../contracts/source-route.js";
|
||||
import { CiError } from "../shared/ci-errors.js";
|
||||
import { EXPLORE_VERSION } from "../shared/package-paths.js";
|
||||
import { blockingCall, easPageLink, silentTimings, throttledProgress, type BlockingNotice, type Timings } from "../shared/timings.js";
|
||||
import { prepareCaptureObserver, captureObserverParameterKeys } from "./observer.js";
|
||||
import { isRecord, parseJson, nonEmpty } from "./common.js";
|
||||
import { isWithin } from "./fs-safety.js";
|
||||
@@ -454,6 +455,8 @@ export function hostedRepackRetries(error: unknown): number {
|
||||
}
|
||||
|
||||
const EXPO_URL = /^https:\/\/expo\.dev\/\S+$/;
|
||||
/** A workflow-run or build page eas-cli printed, rebuilt without any query or fragment it carried (easPageLink). */
|
||||
const easLogLink = (value: string | undefined) => easPageLink(value, "workflows") ?? easPageLink(value, "builds");
|
||||
const EAS_ID = /^[A-Za-z0-9-]{1,128}$/;
|
||||
|
||||
/**
|
||||
@@ -461,7 +464,7 @@ const EAS_ID = /^[A-Za-z0-9-]{1,128}$/;
|
||||
* error. `evidence` is the rest of what the run said: the CLI's stderr and the failed job's logs.
|
||||
*/
|
||||
export function hostedRepackBuildId(stdout: string, evidence: string, platform: "ios" | "android"): string {
|
||||
let logs = /See logs: (https:\/\/expo\.dev\/\S+)/.exec(evidence)?.[1];
|
||||
let logs = easLogLink(/See logs: (https:\/\/expo\.dev\/\S+)/.exec(evidence)?.[1]);
|
||||
let value: unknown;
|
||||
try {
|
||||
value = parseJson(stdout, "eas workflow:run");
|
||||
@@ -478,7 +481,7 @@ export function hostedRepackBuildId(stdout: string, evidence: string, platform:
|
||||
}
|
||||
for (const field of ["url", "logURL"]) {
|
||||
const link = isRecord(value) ? value[field] : undefined;
|
||||
if (typeof link === "string" && EXPO_URL.test(link)) logs = link;
|
||||
if (typeof link === "string" && EXPO_URL.test(link)) logs = easLogLink(link) ?? logs;
|
||||
}
|
||||
const where = logs ? ` Logs: ${logs}` : "";
|
||||
const jobs = isRecord(value) && Array.isArray(value.jobs) ? value.jobs.filter(isRecord) : [];
|
||||
@@ -517,8 +520,10 @@ export function hostedRepackRunStart(stdout: string, stderr: string, platform: "
|
||||
const printed = /See logs: (https:\/\/expo\.dev\/\S+)/.exec(stderr)?.[1];
|
||||
let value: unknown;
|
||||
try { value = JSON.parse(stdout); } catch { value = undefined; }
|
||||
const url = isRecord(value) && typeof value.url === "string" && EXPO_URL.test(value.url) ? value.url : printed;
|
||||
const id = isRecord(value) && typeof value.id === "string" ? value.id : url ? /\/workflows\/([^/?#\s]+)$/.exec(url)?.[1] : undefined;
|
||||
const printedUrl = isRecord(value) && typeof value.url === "string" && EXPO_URL.test(value.url) ? value.url : printed;
|
||||
const id = isRecord(value) && typeof value.id === "string" ? value.id : printedUrl ? /\/workflows\/([^/?#\s]+)$/.exec(printedUrl)?.[1] : undefined;
|
||||
// The link goes into logs, error messages and their diagnostics: only the page itself, never what eas-cli appended to it.
|
||||
const url = easPageLink(printedUrl, "workflows");
|
||||
if (id && EAS_ID.test(id)) return { id, ...(url ? { url } : {}) };
|
||||
const tail = stderr.trim().split("\n").slice(-3).join(" | ").slice(0, 600);
|
||||
throw new CiError({ code: "EAS_REPACK_FAILED", stage: "instrumentation",
|
||||
@@ -590,12 +595,17 @@ function printedBy(error: unknown): { stdout: string; stderr: string } {
|
||||
* followed by another. A start that timed out or was stopped is waited on when it printed its run, and otherwise
|
||||
* not replaced, since it may have started one.
|
||||
*/
|
||||
async function hostedRepackRun(options: { eas: EasCall; staged: string; platform: "ios" | "android"; clock: RepackClock }): Promise<string> {
|
||||
async function hostedRepackRun(options: { eas: EasCall; staged: string; platform: "ios" | "android"; clock: RepackClock;
|
||||
say: (message: string) => void; onBlocking?: BlockingNotice | undefined }): Promise<string> {
|
||||
const { clock, platform } = options;
|
||||
let started: { stdout: string; stderr: string };
|
||||
let startFailure: unknown;
|
||||
try { started = options.eas(["workflow:run", HOSTED_REPACK_WORKFLOW, "--json", "--non-interactive"], Math.min(10 * 60_000, clock.deadline - clock.now()), { cwd: options.staged }); }
|
||||
const startMs = Math.min(10 * 60_000, clock.deadline - clock.now());
|
||||
options.say(`uploading the project and starting the hosted EAS repack (up to ${Math.ceil(startMs / 60_000)} minutes)`);
|
||||
const uploaded = options.onBlocking?.("repack", startMs);
|
||||
try { started = options.eas(["workflow:run", HOSTED_REPACK_WORKFLOW, "--json", "--non-interactive"], startMs, { cwd: options.staged }); }
|
||||
catch (error) { started = printedBy(error); startFailure = error; }
|
||||
finally { uploaded?.(); }
|
||||
let run: { id: string; url?: string };
|
||||
try { run = hostedRepackRunStart(started.stdout, started.stderr, platform); }
|
||||
catch (error) {
|
||||
@@ -608,6 +618,10 @@ async function hostedRepackRun(options: { eas: EasCall; staged: string; platform
|
||||
const cancel = (): boolean => {
|
||||
try { options.eas(["workflow:cancel", run.id, "--non-interactive"], 2 * 60_000, { strict: true }); return true; } catch { return false; }
|
||||
};
|
||||
options.say(`waiting for the hosted EAS repack ${run.id}${run.url ? `: ${run.url}` : ""}`);
|
||||
const waitedFrom = clock.now();
|
||||
// Once a minute: the run's state, how long it has run and how long the capture still gives it.
|
||||
const tick = throttledProgress(options.say, { now: clock.now });
|
||||
try {
|
||||
let unreadable = 0;
|
||||
for (;;) {
|
||||
@@ -626,6 +640,8 @@ async function hostedRepackRun(options: { eas: EasCall; staged: string; platform
|
||||
}
|
||||
return hostedRepackBuildId(view.stdout, `${started.stderr}\n${logs}`, platform);
|
||||
}
|
||||
tick(`hosted EAS repack ${run.id}: ${status && /^[A-Z_]{1,32}$/.test(status) ? status.toLowerCase().replaceAll("_", " ") : "state unreadable"}, `
|
||||
+ `${Math.floor((clock.now() - waitedFrom) / 60_000)} min, ${Math.max(0, Math.floor((clock.deadline - clock.now()) / 60_000))} min left`);
|
||||
unreadable = status ? 0 : unreadable + 1;
|
||||
if (unreadable >= HOSTED_REPACK_UNREADABLE_READS) {
|
||||
const cancelled = cancel();
|
||||
@@ -782,6 +798,8 @@ async function sharedHostedRepack(options: { share: RepackShare; marker: string;
|
||||
const setAside = new Set<string>();
|
||||
let unreadable = 0;
|
||||
let announced = false;
|
||||
// When the followed repack last had a line: one a minute while it runs, as the repack this job waits on has.
|
||||
let beat = 0;
|
||||
for (;;) {
|
||||
clock.signal?.throwIfAborted();
|
||||
let read: ListedBuild[] | null | undefined;
|
||||
@@ -810,6 +828,7 @@ async function sharedHostedRepack(options: { share: RepackShare; marker: string;
|
||||
lookUntil = Math.min(clock.now() + sharedRepackWaitMs(options.share, true), lookLatest);
|
||||
} else if (!followed && live) {
|
||||
followed = live.id;
|
||||
beat = clock.now();
|
||||
say(`waiting for EAS build ${live.id}, the hosted repack of this commit another target of this run started, instead of repacking it again`);
|
||||
}
|
||||
}
|
||||
@@ -827,6 +846,10 @@ async function sharedHostedRepack(options: { share: RepackShare; marker: string;
|
||||
announced = true;
|
||||
say(`waiting up to ${Math.round(firstWait / 60_000)} minutes for the hosted repack ${options.share.leader} or another target makes of this commit, instead of repacking it again`);
|
||||
}
|
||||
if (followed && now - beat >= 60_000) {
|
||||
beat = now;
|
||||
say(`waiting for EAS build ${followed}, the shared repack: ${Math.floor((now - start) / 60_000)} min, ${Math.max(0, Math.floor((clock.deadline - now) / 60_000))} min left`);
|
||||
}
|
||||
const until = followed ? clock.deadline : lookUntil;
|
||||
await pause(Math.max(0, Math.min(followed ? SHARED_REPACK_FOLLOW_POLL_MS : SHARED_REPACK_APPEAR_POLL_MS, until - now)), clock);
|
||||
}
|
||||
@@ -857,6 +880,8 @@ async function prepareHostedRepack(options: {
|
||||
share?: RepackShare | undefined;
|
||||
say: (message: string) => void;
|
||||
clock: RepackClock;
|
||||
timings: Timings;
|
||||
onBlocking?: BlockingNotice | undefined;
|
||||
}): Promise<string> {
|
||||
const { clock, platform } = options;
|
||||
const staged = join(options.root, "project");
|
||||
@@ -897,7 +922,7 @@ async function prepareHostedRepack(options: {
|
||||
const environment = options.repackProfile.easEnvironment;
|
||||
const variables = easEnvironmentSnapshot(scope => {
|
||||
try {
|
||||
const listedVariables = options.runner({ command: options.easCommand, args: ["env:list", "--environment", environment, "--scope", scope, "--format", "long", "--non-interactive"],
|
||||
const listedVariables = options.runner({ command: options.easCommand, args: ["env:list", "--environment", environment, "--scope", scope, "--format", "long"],
|
||||
cwd: options.project, environment: privateEnvironment, timeoutMs: 2 * 60_000 });
|
||||
return listedVariables.stdout;
|
||||
} catch { return undefined; }
|
||||
@@ -907,9 +932,9 @@ async function prepareHostedRepack(options: {
|
||||
// The digest is taken before the workflow file is written: the file's message carries the key made from it.
|
||||
const marker = hostedRepackShareMarker(hostedRepackShareKey({ scope: options.share.scope, platform, nativeBuildId: options.nativeBuildId,
|
||||
easProfile: options.easProfile, environment, environmentVariables: variables, project: await stagedProjectDigest(staged) }));
|
||||
const shared = await sharedHostedRepack({ share: options.share, marker, platform, say: options.say, clock,
|
||||
const shared = await options.timings.measure("repack-share-wait", () => sharedHostedRepack({ share: options.share!, marker, platform, say: options.say, clock,
|
||||
list: () => eas(["build:list", "--platform", platform, "--limit", String(SHARED_REPACK_LIST_LIMIT), "--json", "--non-interactive"], 2 * 60_000).stdout,
|
||||
view: id => eas(["build:view", id, "--json"], 2 * 60_000).stdout });
|
||||
view: id => eas(["build:view", id, "--json"], 2 * 60_000).stdout }));
|
||||
if (shared) return shared;
|
||||
message = `${message} ${marker}`;
|
||||
}
|
||||
@@ -922,7 +947,8 @@ async function prepareHostedRepack(options: {
|
||||
for (;;) {
|
||||
if (clock.deadline - clock.now() < HOSTED_REPACK_MIN_ATTEMPT_MS) throw timeoutError(platform, retries ? "too little time was left for another repack" : "too little time was left for a repack of its own");
|
||||
try {
|
||||
return await hostedRepackRun({ eas, staged, platform, clock });
|
||||
return await options.timings.measure("repack", () => hostedRepackRun({ eas, staged, platform, clock, say: options.say, onBlocking: options.onBlocking }),
|
||||
{ attempt: retries + 1 });
|
||||
} catch (error) {
|
||||
// Only a run EAS reported finished gets here with a failure that earns another (hostedRepackRun), so none is left beside it.
|
||||
const allowed = hostedRepackRetries(error);
|
||||
@@ -969,6 +995,10 @@ export async function prepareExactSourceBuild(options: {
|
||||
now?: (() => number) | undefined;
|
||||
sleep?: ((milliseconds: number) => void) | undefined;
|
||||
signal?: AbortSignal | undefined;
|
||||
/** Records the repack, the wait for another job's, and the download. */
|
||||
timings?: Timings | undefined;
|
||||
/** Told before a synchronous call blocks for minutes (CiMapOptions.onBlocking). */
|
||||
onBlocking?: BlockingNotice | undefined;
|
||||
}): Promise<PreparedBuild | undefined> {
|
||||
const platform = options.platform ?? "ios";
|
||||
const root = await mkdtemp(join(tmpdir(), "expo-explore-repack-"));
|
||||
@@ -985,12 +1015,14 @@ export async function prepareExactSourceBuild(options: {
|
||||
nativeBuildId: options.nativeBuildId, easProfile: options.easProfile, repackProfile: options.repackProfile,
|
||||
easEnvironment: options.easEnvironment, restrictedEnvironment: options.repackEnvironment, provider: providers[0]!,
|
||||
parameterKeys: captureObserverParameterKeys(options.routes), root, share: options.share, say: options.progress ?? (() => undefined),
|
||||
timings: options.timings ?? silentTimings, onBlocking: options.onBlocking,
|
||||
clock: { deadline: options.deadline ?? (options.now ?? Date.now)() + HOSTED_REPACK_BUDGET_MS, now: options.now ?? Date.now, sleep: options.sleep, signal: options.signal } });
|
||||
{
|
||||
// The hosted job leaves its app on EAS; the capture installs a copy downloaded here.
|
||||
const downloaded = await downloadedAppPath(options.runner({ command: options.easCommand,
|
||||
options.progress?.(`downloading the repacked app, EAS build ${hosted} (up to 10 minutes)`);
|
||||
const downloaded = await downloadedAppPath(blockingCall(options.timings ?? silentTimings, options.onBlocking, "build-download", 10 * 60_000, () => options.runner({ command: options.easCommand,
|
||||
args: ["build:download", "--build-id", hosted, "--json", "--non-interactive"], cwd: options.project,
|
||||
environment: { ...options.easEnvironment, TMPDIR: root, TMP: root, TEMP: root }, timeoutMs: 10 * 60_000 }).stdout, root, platform);
|
||||
environment: { ...options.easEnvironment, TMPDIR: root, TMP: root, TEMP: root }, timeoutMs: 10 * 60_000 })).stdout, root, platform);
|
||||
await rename(downloaded, options.keepApp);
|
||||
outcome = { buildId: hosted, app: options.keepApp };
|
||||
}
|
||||
|
||||
@@ -15,6 +15,7 @@ import type { SourceRoute } from "../contracts/source-route.js";
|
||||
import { CiError, serializeCiError, toCiError } from "../shared/ci-errors.js";
|
||||
import { type CaptureSetupSnapshot, credentialSavePromptDecline, describeSetupAction, executeCaptureSetup, isUnreadableSystemSurface, setupReadinessHolds } from "./setup-actions.js";
|
||||
import { silentProgress } from "../shared/progress.js";
|
||||
import { silentTimings, type Timings } from "../shared/timings.js";
|
||||
import type { CaptureSetupReady } from "../config/explore-config.js";
|
||||
import { READINESS_POLL_MS, defaultReadinessSeconds } from "./readiness.js";
|
||||
import { KEYBOARD_POLL_MS, keyboardSettle, type KeyboardRead, type KeyboardSettle } from "./keyboard.js";
|
||||
@@ -176,6 +177,8 @@ export async function capturePlannedRoutes(options: {
|
||||
outcomes?: CaptureBundle["outcomes"];
|
||||
/** Set when the review captures several appearances: the primary scheme keeps the route's screen id. */
|
||||
appearance?: { scheme: ColorScheme; primary: boolean };
|
||||
/** Records each route's span, from its first open to its outcome. */
|
||||
timings?: Timings;
|
||||
}): Promise<NonNullable<CaptureBundle["outcomes"]>> {
|
||||
const screenIdFor = (routeId: string) => schemeScreenId(routeId, options.appearance && !options.appearance.primary ? options.appearance.scheme : undefined);
|
||||
const colorScheme = options.appearance?.scheme;
|
||||
@@ -1140,7 +1143,9 @@ export async function capturePlannedRoutes(options: {
|
||||
const route = options.routes.find(route => outcomes[route.id]?.status !== "captured"
|
||||
&& captureDestinationMatches(destination, route, inventory));
|
||||
if (!route) return;
|
||||
await capturePreparedTarget(route, action.ready, current.nodes);
|
||||
const endRoute = (options.timings ?? silentTimings).span("route", { route: route.route, via: "setup" });
|
||||
try { await capturePreparedTarget(route, action.ready, current.nodes); }
|
||||
finally { endRoute(outcomes[route.id]?.status === "captured" ? "ok" : "failed", { status: outcomes[route.id]?.status ?? "none" }); }
|
||||
reportOutcome(route, `after setup step ${index + 1}`);
|
||||
},
|
||||
});
|
||||
@@ -1257,6 +1262,7 @@ export async function capturePlannedRoutes(options: {
|
||||
continue;
|
||||
}
|
||||
attempted.add(route.id);
|
||||
const endRoute = (options.timings ?? silentTimings).span("route", { route: route.route });
|
||||
timingPhase = `route ${route.route}`;
|
||||
say(`route ${++opened}/${linked.length} ${route.route}: opening by app link`);
|
||||
for (let attempt = 1; attempt <= 2; attempt++) {
|
||||
@@ -1305,6 +1311,7 @@ export async function capturePlannedRoutes(options: {
|
||||
}
|
||||
const outcome = outcomes[route.id];
|
||||
if (setupIncomplete && outcome?.status === "captured") outcomes[route.id] = { ...outcome, reason: outcome.reason ? `${outcome.reason} ${setupIncomplete}` : setupIncomplete };
|
||||
endRoute(outcome?.status === "captured" ? "ok" : "failed", { status: outcome?.status ?? "none" });
|
||||
reportOutcome(route, "by app link");
|
||||
}
|
||||
return outcomes;
|
||||
|
||||
+48
-24
@@ -21,6 +21,7 @@ import { lstatIfExists, isWithin, temporaryCaptureDirectory, absoluteContractFil
|
||||
import { loadAppIcon, loadCachedAppIcon, storeAppIcon } from "./app-icon.js";
|
||||
import { defaultRunner, runAgentControllerCommand } from "./controller.js";
|
||||
import { silentProgress, type Progress } from "../shared/progress.js";
|
||||
import { blockingCall, createTimings, phaseSequence, type BlockingNotice, type Timings } from "../shared/timings.js";
|
||||
import { assertCaptureEasProfile, assertSimulatorAvailable, fingerprintFrom, hasEasEnvironmentFetchFailure, nativeBuildFrom, existingBuild, repackProfileFrom, prepareExactSourceBuild, HOSTED_REPACK_BUDGET_MS, type RepackMode, type RepackShare } from "./eas-build.js";
|
||||
import { SIMULATOR_DOTENV_FILE_NAME, SIMULATOR_DOTENV_HEADER, endedOwnSimulatorSession, liveSimulatorSessionsNamed, simulatorSessionName, simulatorStartFailure, readSimulatorDotenvHandoff, assertSimulatorSessionIdentity, assertSimulatorStopped, collectRuntime, controllerVersion, simulatorOsVersion, type ActiveSimulatorRuntime, type SimulatorConnection } from "./simulator.js";
|
||||
import { argentControllerInvocation } from "./controller-invocation.js";
|
||||
@@ -91,6 +92,11 @@ export type CiMapOptions = {
|
||||
readinessSeconds?: number;
|
||||
/** Reports each step as it starts; capture output stays in the map and bundle. */
|
||||
progress?: Progress;
|
||||
/** Where this capture appends its timings (timings.jsonl), labelled with `timingsSide` or else `side`. A path crosses to a worker thread; a recorder could not. */
|
||||
timingsPath?: string;
|
||||
timingsSide?: string;
|
||||
/** Told before a synchronous call blocks this thread for minutes: a worker's parent prints while it is (runCiMapOnWorker). */
|
||||
onBlocking?: BlockingNotice;
|
||||
/** Stops the capture between steps (before the build, the session and each route); a session it started is still stopped. */
|
||||
signal?: AbortSignal;
|
||||
};
|
||||
@@ -191,16 +197,20 @@ export function revisionSetup(setup: readonly CaptureSetupStep[], plan: SourceCa
|
||||
/** Source-plan capture. App state is observed as it runs; optional agents cannot change the inventory. */
|
||||
export async function runCiMap(input: Omit<CiMapOptions, "platform"> & { platform?: Platform }): Promise<CiMapResult> {
|
||||
const options: CiMapOptions = { ...input, platform: input.platform ?? "ios" };
|
||||
const timings = createTimings({ path: options.timingsPath, labels: { side: options.timingsSide ?? options.side, pass: options.appearancePass?.capture.join("+") },
|
||||
secrets: [options.expoToken, ...environmentSecrets(options.environment ?? process.env)] });
|
||||
let stage = "preflight";
|
||||
try { return await executeCiMap(options, value => { stage = value; }); }
|
||||
catch (error) {
|
||||
throw toCiError(error, { code: `CAPTURE_${stage.toUpperCase().replace(/-/g, "_")}_FAILED`, stage,
|
||||
nextAction: stage === "cleanup" ? "Stop the exact session identified in the session handoff, then retry."
|
||||
: "Inspect the capture diagnostic, correct the failing prerequisite, and rerun Explore." });
|
||||
}
|
||||
return timings.measure("pass", async () => {
|
||||
try { return await executeCiMap(options, value => { stage = value; }, timings); }
|
||||
catch (error) {
|
||||
throw toCiError(error, { code: `CAPTURE_${stage.toUpperCase().replace(/-/g, "_")}_FAILED`, stage,
|
||||
nextAction: stage === "cleanup" ? "Stop the exact session identified in the session handoff, then retry."
|
||||
: "Inspect the capture diagnostic, correct the failing prerequisite, and rerun Explore." });
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
async function executeCiMap(options: CiMapOptions, setStage: (stage: string) => void): Promise<CiMapResult> {
|
||||
async function executeCiMap(options: CiMapOptions, setStage: (stage: string) => void, timings: Timings): Promise<CiMapResult> {
|
||||
if (!options.confirmExternalRun || !options.confirmTrustedSource) throw new Error("EAS capture requires authorized external execution of the selected source commit.");
|
||||
positiveInteger(options.maxScreens, "maxScreens");
|
||||
positiveInteger(options.maxActions, "maxActions");
|
||||
@@ -465,7 +475,7 @@ async function executeCiMap(options: CiMapOptions, setStage: (stage: string) =>
|
||||
const controlOptions = { sleep: options.sleep };
|
||||
// What the EAS session's host can do through simulator:control (iOS sessions on serve-sim 0.10.0 or later).
|
||||
let controlActions = new Set<string>();
|
||||
const configResult = eas(["config", "--platform", options.platform, "--profile", options.easProfile, "--json", "--non-interactive"]);
|
||||
const configResult = timings.measure("configuration", () => eas(["config", "--platform", options.platform, "--profile", options.easProfile, "--json", "--non-interactive"]));
|
||||
const profile = repackProfileFrom(configResult.stdout);
|
||||
const configValue = parseJson(configResult.stdout, "eas config") as { appConfig: Record<string, unknown>; buildProfile: Record<string, unknown> };
|
||||
scheme ??= appScheme(configValue.appConfig.scheme);
|
||||
@@ -570,6 +580,8 @@ async function executeCiMap(options: CiMapOptions, setStage: (stage: string) =>
|
||||
if (local || sessionStart) return;
|
||||
if (!retry) say(`starting an EAS Simulator session (${options.device}) while the app is repacked`);
|
||||
sessionStartedAt = (options.now ?? Date.now)();
|
||||
// From the request to the session EAS hands over, beside the repack: the queue and boot time of the session.
|
||||
const started = timings.span("session-start", { attempt: sessionRetries });
|
||||
const request = (minutes: number) => ({ command: options.easCommand, args: ["simulator:start", "--name", sessionName, "--platform", options.platform, "--device", options.device,
|
||||
"--type", controller, "--package-version", controllerVersion(controller), "--public-link",
|
||||
"--max-duration-minutes", String(minutes), "--out-config-type", "dotenv", "--non-interactive"], cwd: simulatorProject, environment: easEnvironment,
|
||||
@@ -584,7 +596,8 @@ async function executeCiMap(options: CiMapOptions, setStage: (stage: string) =>
|
||||
say(`EAS allows ${limit}-minute sessions on this plan; starting the session again without the full repack allowance`);
|
||||
return start(Math.max(options.maxDurationMinutes, limit));
|
||||
}))
|
||||
.then(() => undefined, (error: unknown) => error);
|
||||
.then(() => undefined, (error: unknown) => error)
|
||||
.then(error => { started(error ? "failed" : "ok"); return error; });
|
||||
};
|
||||
setStage("build");
|
||||
// The instrumented app stays on this machine: a local device installs it, and an EAS session gets it through the
|
||||
@@ -596,17 +609,17 @@ async function executeCiMap(options: CiMapOptions, setStage: (stage: string) =>
|
||||
// What a hosted repack waits with and reports through: one deadline from the moment the session starts beside it, for
|
||||
// the wait for another job's repack and every repack of its own. The repack is shared with this run's other matrix
|
||||
// jobs only when it repacks a build EAS already had: a native build this job made is its own, so nobody else's key matches it.
|
||||
const repackWaits = (shared: boolean) => ({ ...(shared ? { share: options.repackShare } : {}), progress: say, now: options.now, sleep: options.sleep,
|
||||
const repackWaits = (shared: boolean) => ({ ...(shared ? { share: options.repackShare } : {}), progress: say, now: options.now, sleep: options.sleep, timings, onBlocking: options.onBlocking,
|
||||
signal: options.signal, deadline: (options.now ?? Date.now)() + HOSTED_REPACK_BUDGET_MS });
|
||||
// `repacking` tells the captures sharing this build that their sessions can start too (sharedBuild).
|
||||
const buildApp = async (keepApp: string, repacking?: () => Promise<void>): Promise<BuiltApp> => {
|
||||
options.signal?.throwIfAborted();
|
||||
say("computing the native fingerprint");
|
||||
const fingerprintResult = eas(["fingerprint:generate", "--platform", options.platform, "--build-profile", options.easProfile, "--json", "--non-interactive"]);
|
||||
const fingerprintResult = timings.measure("fingerprint", () => eas(["fingerprint:generate", "--platform", options.platform, "--build-profile", options.easProfile, "--json", "--non-interactive"]));
|
||||
const sourceFingerprint = fingerprintFrom(fingerprintResult.stdout);
|
||||
const reusable = options.forceFreshBuild || hasEasEnvironmentFetchFailure(configResult.stderr) || hasEasEnvironmentFetchFailure(fingerprintResult.stderr)
|
||||
? undefined : existingBuild(eas(["build:list", "--platform", options.platform, "--status", "finished", "--build-profile", options.easProfile,
|
||||
"--fingerprint-hash", sourceFingerprint, ...(options.platform === "ios" ? ["--simulator"] : []), "--limit", "20", "--json", "--non-interactive"]).stdout);
|
||||
? undefined : existingBuild(timings.measure("build-lookup", () => eas(["build:list", "--platform", options.platform, "--status", "finished", "--build-profile", options.easProfile,
|
||||
"--fingerprint-hash", sourceFingerprint, ...(options.platform === "ios" ? ["--simulator"] : []), "--limit", "20", "--json", "--non-interactive"])).stdout);
|
||||
if (reusable) {
|
||||
say(`reusing EAS build ${reusable.id} (fingerprint ${sourceFingerprint.slice(0, 12)}); repacking it with this commit's JavaScript and the route observer`);
|
||||
startSession(); await repacking?.();
|
||||
@@ -619,9 +632,10 @@ async function executeCiMap(options: CiMapOptions, setStage: (stage: string) =>
|
||||
...(reusable.appVersion ? { version: reusable.appVersion } : {}), ...(reusable.appBuildVersion ? { buildNumber: reusable.appBuildVersion } : {}) };
|
||||
}
|
||||
options.signal?.throwIfAborted();
|
||||
say(options.forceFreshBuild ? "building on EAS (a fresh build was requested); waiting for it to finish"
|
||||
: `no finished simulator build has fingerprint ${sourceFingerprint.slice(0, 12)}; building on EAS and waiting for it to finish`);
|
||||
const built = nativeBuildFrom(eas(["build", "--platform", options.platform, "--profile", options.easProfile, "--wait", "--json", "--non-interactive"], 45 * 60_000).stdout);
|
||||
say(options.forceFreshBuild ? "building on EAS (a fresh build was requested); waiting up to 45 minutes for it to finish"
|
||||
: `no finished simulator build has fingerprint ${sourceFingerprint.slice(0, 12)}; building on EAS and waiting up to 45 minutes for it to finish`);
|
||||
const built = nativeBuildFrom(blockingCall(timings, options.onBlocking, "native-build", 45 * 60_000,
|
||||
() => eas(["build", "--platform", options.platform, "--profile", options.easProfile, "--wait", "--json", "--non-interactive"], 45 * 60_000)).stdout);
|
||||
say(`EAS build ${built.id} finished; repacking it with the route observer`);
|
||||
startSession(); await repacking?.();
|
||||
const repacked = await prepareExactSourceBuild({ platform: options.platform, runner, easCommand: options.easCommand, repackCommand: options.repackCommand,
|
||||
@@ -674,8 +688,11 @@ async function executeCiMap(options: CiMapOptions, setStage: (stage: string) =>
|
||||
}
|
||||
let primaryError: unknown;
|
||||
let runtimeStage = "session";
|
||||
// The session's handover and the app's install, in turn; the passes after them have spans of their own.
|
||||
const runtimePhases = phaseSequence(timings);
|
||||
try {
|
||||
setStage(runtimeStage);
|
||||
runtimePhases.enter("session-verify");
|
||||
let connection: SimulatorConnection | undefined;
|
||||
if (localApp && localEmulator && localEmulatorStart) {
|
||||
await assertLocalEmulatorCompatible(localApp, hostEmulatorAbi());
|
||||
@@ -814,6 +831,7 @@ async function executeCiMap(options: CiMapOptions, setStage: (stage: string) =>
|
||||
outcomes[schemeScreenId(id, scheme)] = { status: "failed", attempts: 0, landing: "unverified", reason: error.message, error };
|
||||
}
|
||||
// The finally block below stops the session after the export.
|
||||
runtimePhases.end("skipped");
|
||||
return await finish();
|
||||
}
|
||||
}
|
||||
@@ -845,9 +863,10 @@ async function executeCiMap(options: CiMapOptions, setStage: (stage: string) =>
|
||||
}
|
||||
if (!local && localApp) {
|
||||
// The session started empty while the app was repacked; the controller installs it now.
|
||||
say(`installing the app on session ${sessionId}`);
|
||||
runner({ command: controllerCommand, args: ["install", localApp, "--session", CONTROLLER_SESSION, ...deviceArgs({ platform: options.platform, deviceModel: options.device }),
|
||||
"--platform", options.platform, "--json"], cwd: simulatorProject, environment: controllerEnvironment, timeoutMs: 15 * 60_000 });
|
||||
say(`installing the app on session ${sessionId} (up to 15 minutes)`);
|
||||
runtimePhases.end();
|
||||
blockingCall(timings, options.onBlocking, "install", 15 * 60_000, () => runner({ command: controllerCommand, args: ["install", localApp, "--session", CONTROLLER_SESSION,
|
||||
...deviceArgs({ platform: options.platform, deviceModel: options.device }), "--platform", options.platform, "--json"], cwd: simulatorProject, environment: controllerEnvironment, timeoutMs: 15 * 60_000 }));
|
||||
// Before any link opens, as a local capture does with simctl: the app's own links then open without the prompt.
|
||||
if (sessionId && scheme) {
|
||||
const approved = approveSessionUrlSchemes(sessionEas, sessionId, controlActions, options.bundleId, [scheme], controlOptions);
|
||||
@@ -1008,10 +1027,13 @@ async function executeCiMap(options: CiMapOptions, setStage: (stage: string) =>
|
||||
const recordingTools = launchSetting === "off" ? undefined : options.recordingTools === undefined ? ffmpegRecordingTools() : options.recordingTools ?? undefined;
|
||||
const capturedSchemes = options.appearancePass ? colorSchemes.filter(scheme => options.appearancePass!.capture.includes(scheme)) : colorSchemes;
|
||||
const activeRuntime = runtime;
|
||||
runtimePhases.end();
|
||||
for (const [index, colorScheme] of colorSchemes.entries()) {
|
||||
// A pass another session makes leaves its slot empty, so the passes stay aligned with the appearances they merge by.
|
||||
if (!capturedSchemes.includes(colorScheme)) { passes.push({}); continue; }
|
||||
const passOutcomes: CaptureBundle["outcomes"] = index === 0 ? outcomes : {};
|
||||
// Each appearance's launch and routes are labelled with it, also when one session captures them in turn.
|
||||
const passTimings = colorSchemes.length > 1 ? timings.labelled({ pass: colorScheme }) : timings;
|
||||
const capturePass = async () => {
|
||||
// Argent cannot switch the appearance yet (software-mansion/argent#1509): the host does, simctl or adb on this
|
||||
// machine and serve-sim on an EAS iOS session; elsewhere its single pass runs as the device starts.
|
||||
@@ -1027,11 +1049,12 @@ async function executeCiMap(options: CiMapOptions, setStage: (stage: string) =>
|
||||
say(`observing the app launch${colorSchemes.length > 1 ? ` (${colorScheme})` : ""}`);
|
||||
try {
|
||||
// A restored baseline's launch evidence is replaced only by a fresh observation.
|
||||
const record = await captureLaunch({ bundleId: options.bundleId, keepVideo: launchSetting === "video", platform: options.platform,
|
||||
const record = await passTimings.measure("launch", () => captureLaunch({ bundleId: options.bundleId, keepVideo: launchSetting === "video", platform: options.platform,
|
||||
directory: join(launchWorkDirectory, launchDirectory(colorScheme)), relativeDirectory: launchDirectory(colorScheme), ...(options.now ? { now: options.now } : {}),
|
||||
...(recordingTools ? { recordingTools } : {}),
|
||||
controller: (args, controllerOptions) => runner({ command: controllerCommand, args: [...args, "--session", CONTROLLER_SESSION, ...deviceArgs(activeRuntime), "--platform", options.platform],
|
||||
cwd: simulatorProject, environment: controllerEnvironment, timeoutMs: controllerOptions?.timeoutMs ?? 60_000, ...(controllerOptions?.allowFailure ? { allowFailure: true } : {}) }) });
|
||||
cwd: simulatorProject, environment: controllerEnvironment, timeoutMs: controllerOptions?.timeoutMs ?? 60_000, ...(controllerOptions?.allowFailure ? { allowFailure: true } : {}) }) }),
|
||||
{ scheme: colorScheme });
|
||||
launch[colorScheme] = { root: launchWorkDirectory, record };
|
||||
} catch (error) {
|
||||
// The launch is supplementary evidence: a failure to observe it leaves the route capture intact.
|
||||
@@ -1043,7 +1066,7 @@ async function executeCiMap(options: CiMapOptions, setStage: (stage: string) =>
|
||||
activeRuntime.colorScheme = colorScheme;
|
||||
if (colorSchemes.length > 1) say(`appearance ${colorScheme} (${index + 1}/${colorSchemes.length})`);
|
||||
return await capturePlannedRoutes({ capture: { ...options, ...(argentBridge && !options.agent ? { runner: argentBridge.runner } : {}), agentDeviceCommand: controllerCommand, setup, progress: say }, routes: missingRoutes, inventory, scheme, appName: app.name, runtime: activeRuntime,
|
||||
connection, environment: controllerEnvironment, store, map, acceptedFrames, outcomes: passOutcomes,
|
||||
connection, environment: controllerEnvironment, store, map, acceptedFrames, outcomes: passOutcomes, timings: passTimings,
|
||||
...(colorSchemes.length > 1 ? { appearance: { scheme: colorScheme, primary: index === 0 } } : {}) });
|
||||
};
|
||||
// A later pass of a session whose primary pass captured fails only its own appearance, as a secondary session does
|
||||
@@ -1074,7 +1097,7 @@ async function executeCiMap(options: CiMapOptions, setStage: (stage: string) =>
|
||||
const pass = passes[colorSchemes.indexOf(failedScheme)] ?? {};
|
||||
for (const id of selectedIds) if (!pass[id]) outcomes[schemeScreenId(id, failedScheme)] = { status: "failed", attempts: 0, landing: "unverified", reason: error.message, error };
|
||||
}
|
||||
} catch (error) { primaryError = toCiError(error, { code: `CAPTURE_${runtimeStage.toUpperCase()}_FAILED`, stage: runtimeStage,
|
||||
} catch (error) { runtimePhases.end("failed"); primaryError = toCiError(error, { code: `CAPTURE_${runtimeStage.toUpperCase()}_FAILED`, stage: runtimeStage,
|
||||
nextAction: "Inspect the capture diagnostic, correct the failing prerequisite, and rerun Explore." }); }
|
||||
finally {
|
||||
if (appDirectory) await rm(appDirectory, { recursive: true, force: true });
|
||||
@@ -1116,7 +1139,8 @@ async function executeCiMap(options: CiMapOptions, setStage: (stage: string) =>
|
||||
try {
|
||||
setStage("cleanup");
|
||||
say(`stopping simulator session ${sessionId}`);
|
||||
assertSimulatorStopped(eas(["simulator:stop", "--id", sessionId, "--json", "--non-interactive"], 2 * 60_000).stdout, sessionId);
|
||||
const stopping = sessionId;
|
||||
assertSimulatorStopped(timings.measure("session-stop", () => eas(["simulator:stop", "--id", stopping, "--json", "--non-interactive"], 2 * 60_000)).stdout, stopping);
|
||||
if (statePath) await rm(statePath, { force: true });
|
||||
await rm(simulatorProject, { recursive: true, force: true });
|
||||
} catch (error) { throw new CiError({ code: "SESSION_CLEANUP_FAILED", stage: "cleanup",
|
||||
|
||||
+53
-3
@@ -3,8 +3,9 @@ import { mkdir, mkdtemp, open, rm, writeFile } from "node:fs/promises";
|
||||
import { dirname, join, relative, resolve } from "node:path";
|
||||
import { setTimeout as delay } from "node:timers/promises";
|
||||
import { BlobReader, Uint8ArrayWriter, ZipReader, configure } from "@zip.js/zip.js";
|
||||
import { CiError } from "../shared/ci-errors.js";
|
||||
import { CiError, environmentSecrets } from "../shared/ci-errors.js";
|
||||
import { silentProgress, type Progress } from "../shared/progress.js";
|
||||
import { githubRunLink, safeText, silentTimings, type Timings } from "../shared/timings.js";
|
||||
import { retryGitHubLookup } from "../report/github-lookup.js";
|
||||
import { safeRelativePath } from "../binary/archive.js";
|
||||
import { CAPTURE_CACHE_MAX_BYTES, CAPTURE_CACHE_MAX_FILES } from "./artifact-cache.js";
|
||||
@@ -26,7 +27,11 @@ const ARTIFACT_LISTING_GRACE_MS = 60_000;
|
||||
/** A zip of the largest capture cache, stored rather than deflated, plus its headers. */
|
||||
const MAX_ARTIFACT_ZIP_BYTES = CAPTURE_CACHE_MAX_BYTES + 16 * 1024 * 1024;
|
||||
|
||||
type GithubJob = { name: string; status?: string; conclusion?: string | null };
|
||||
type GithubStep = { name?: string; number?: number; status?: string; conclusion?: string | null; started_at?: string | null; completed_at?: string | null };
|
||||
type GithubJob = { name: string; status?: string; conclusion?: string | null; steps?: GithubStep[] };
|
||||
|
||||
/** What the review is waiting on, as it changes: the baseline job's state and the step it is in, from the same poll. */
|
||||
export type BaselineWaitUpdate = { state: string; step?: string; stepSince?: number; waitedMs: number };
|
||||
|
||||
export type BaselineWaitOptions = {
|
||||
/** The baseline run `ci:find-baseline` named; it is checked again here, by the same trust rules. */
|
||||
@@ -35,6 +40,10 @@ export type BaselineWaitOptions = {
|
||||
timeoutMs: number; pollMs?: number;
|
||||
environment?: NodeJS.ProcessEnv; transport?: typeof fetch; progress?: Progress; signal?: AbortSignal;
|
||||
now?: () => number; sleep?: (milliseconds: number, signal?: AbortSignal) => Promise<void>;
|
||||
/** Called when the baseline job's state or step changes: the review's sticky comment says what it waits on. */
|
||||
onUpdate?: (update: BaselineWaitUpdate) => void;
|
||||
/** Records the wait, and the steps the baseline job finished (or was still in) while the review waited. */
|
||||
timings?: Timings;
|
||||
};
|
||||
|
||||
/** A failed GitHub read that may succeed later: no answer or a 5xx. A bad token or a missing permission is not. */
|
||||
@@ -49,7 +58,26 @@ const statusText = (status: string | undefined) => (status ?? "queued").replaceA
|
||||
* the time limit, a missing permission and GitHub failures that outlast their retries. The reason says which.
|
||||
*/
|
||||
export async function waitForBaselineArtifact(options: BaselineWaitOptions): Promise<{ artifact: { id: number; run: number } } | { reason: string }> {
|
||||
const timings = options.timings ?? silentTimings;
|
||||
const now = options.now ?? Date.now;
|
||||
const end = timings.span("baseline-wait", { run: options.run });
|
||||
// The step the baseline job was last seen in: when the wait ends there, it is recorded with the time it had taken so far.
|
||||
const watch: BaselineWatch = { recorded: new Set() };
|
||||
const outcome = await pollBaselineArtifact(options, watch);
|
||||
if (watch.current) timings.record({ type: "baseline-step", name: watch.current.name, ms: Math.max(0, now() - watch.current.since), conclusion: "still running" });
|
||||
end("artifact" in outcome ? "ok" : "skipped", "artifact" in outcome ? { result: "artifact" } : { result: "gave up", reason: outcome.reason });
|
||||
return outcome;
|
||||
}
|
||||
|
||||
type BaselineWatch = { recorded: Set<number>; current?: { name: string; since: number } };
|
||||
|
||||
/** A step's start or end as GitHub reports it, as a time on the wait's clock; GitHub's clock and the runner's agree to seconds. */
|
||||
const stepTime = (value: string | null | undefined) => { const time = Date.parse(value ?? ""); return Number.isFinite(time) ? time : undefined; };
|
||||
|
||||
async function pollBaselineArtifact(options: BaselineWaitOptions, watch: BaselineWatch): Promise<{ artifact: { id: number; run: number } } | { reason: string }> {
|
||||
const now = options.now ?? Date.now;
|
||||
const timings = options.timings ?? silentTimings;
|
||||
const secrets = environmentSecrets(options.environment ?? process.env);
|
||||
const sleep = options.sleep ?? ((milliseconds: number, signal?: AbortSignal) => delay(milliseconds, undefined, signal ? { signal } : {}));
|
||||
const progress = options.progress ?? silentProgress;
|
||||
const started = now();
|
||||
@@ -64,9 +92,12 @@ export async function waitForBaselineArtifact(options: BaselineWaitOptions): Pro
|
||||
const jobNames = [`baseline (${target})`, ...(target === "ios" ? ["baseline"] : [])];
|
||||
let finishedAt: number | undefined;
|
||||
let logged = "";
|
||||
let reported = "";
|
||||
let link = githubRunLink(options.environment ?? process.env, options.run);
|
||||
for (;;) {
|
||||
const run = await get<GithubRun>(`repos/${context.repository}/actions/runs/${options.run}`);
|
||||
if (!trustedBaselineRun(run, lookup)) return { reason: `run ${options.run} is not a baseline run of ${short} on ${lookup.defaultBranch}` };
|
||||
if (link) { progress(`waiting for ${lookup.defaultBranch}'s baseline run ${run.id} of ${short}: ${link}`); link = undefined; }
|
||||
for (const name of lookup.names) {
|
||||
const listed = await get<{ artifacts?: GithubArtifact[] }>(`repos/${context.repository}/actions/runs/${run.id}/artifacts?name=${encodeURIComponent(name)}&per_page=100`);
|
||||
const artifact = (listed?.artifacts ?? []).filter(candidate => !candidate.expired && (candidate.name ?? name) === name
|
||||
@@ -75,6 +106,18 @@ export async function waitForBaselineArtifact(options: BaselineWaitOptions): Pro
|
||||
}
|
||||
const jobs = await get<{ jobs?: GithubJob[] }>(`repos/${context.repository}/actions/runs/${run.id}/jobs?per_page=100`);
|
||||
const job = jobs?.jobs?.find(candidate => jobNames.includes(candidate.name));
|
||||
// The job's steps say where it is: in brentvatne/euxy#179 a baseline sat 19 minutes installing ffmpeg while the
|
||||
// review's line said only "in progress". Each finished step is recorded once; the one running is named.
|
||||
for (const step of job?.steps ?? []) {
|
||||
const started = stepTime(step.started_at), completed = stepTime(step.completed_at);
|
||||
if (step.status !== "completed" || typeof step.number !== "number" || watch.recorded.has(step.number) || started === undefined || completed === undefined) continue;
|
||||
watch.recorded.add(step.number);
|
||||
timings.record({ type: "baseline-step", name: step.name ?? "?", ms: Math.max(0, completed - started), conclusion: step.conclusion ?? "unknown" });
|
||||
}
|
||||
const running = job?.status === "in_progress" ? job.steps?.find(step => step.status === "in_progress" && step.name) : undefined;
|
||||
const since = stepTime(running?.started_at);
|
||||
if (running && since !== undefined) watch.current = { name: running.name!, since };
|
||||
else delete watch.current;
|
||||
if (job?.status === "completed" && job.conclusion !== "success") {
|
||||
return { reason: `its ${target} job ${job.conclusion === "cancelled" ? "was cancelled" : job.conclusion === "failure" ? "failed" : `ended (${job.conclusion ?? "no conclusion"})`}` };
|
||||
}
|
||||
@@ -86,8 +129,15 @@ export async function waitForBaselineArtifact(options: BaselineWaitOptions): Pro
|
||||
const waited = now() - started;
|
||||
const state = job ? statusText(job.status) : run.status === "completed" ? "finished" : "not started";
|
||||
if (waited >= options.timeoutMs) return { reason: `its ${target} job is still ${state} after ${Math.round(waited / 60_000)} min` };
|
||||
const step = watch.current ? safeText(watch.current.name, secrets) : undefined;
|
||||
const update = `${state}\0${step ?? ""}`;
|
||||
if (update !== reported) {
|
||||
reported = update;
|
||||
options.onUpdate?.({ state, ...(step && watch.current ? { step, stepSince: watch.current.since } : {}), waitedMs: waited });
|
||||
}
|
||||
// A line when the state changes and once a minute, not on every poll.
|
||||
const line = `waiting for ${lookup.defaultBranch}'s baseline run ${run.id} of ${short} (${target}: ${state}, ${Math.floor(waited / 60_000)} min)`;
|
||||
const where = step && watch.current ? `, in "${step}" for ${Math.max(0, Math.floor((now() - watch.current.since) / 60_000))} min` : "";
|
||||
const line = `waiting for ${lookup.defaultBranch}'s baseline run ${run.id} of ${short} (${target}: ${state}${where}, ${Math.floor(waited / 60_000)} min)`;
|
||||
if (line !== logged) { progress(line); logged = line; }
|
||||
await sleep(Math.min(options.pollMs ?? POLL_MS, options.timeoutMs - waited), options.signal);
|
||||
}
|
||||
|
||||
@@ -2,18 +2,40 @@ import { Worker, isMainThread, parentPort, workerData } from "node:worker_thread
|
||||
import { runCiMap, type CiMapOptions, type CiMapResult } from "../capture/run.js";
|
||||
import { CiError, environmentSecrets, serializeCiError, type CiErrorData } from "../shared/ci-errors.js";
|
||||
import type { Progress } from "../shared/progress.js";
|
||||
import { TIMING_PHASES, formatDuration, type TimingPhase } from "../shared/timings.js";
|
||||
|
||||
type WorkerMessage = { type: "progress"; message: string } | { type: "done"; result: CiMapResult } | { type: "error"; error: CiErrorData };
|
||||
type WorkerMessage = { type: "progress"; message: string } | { type: "done"; result: CiMapResult } | { type: "error"; error: CiErrorData }
|
||||
| { type: "blocking"; phase: TimingPhase; boundMs: number } | { type: "unblocked" };
|
||||
/** From the parent: stop between steps, as `signal` does for a capture on the main thread. */
|
||||
type ParentMessage = { type: "abort"; reason: CiErrorData };
|
||||
|
||||
/** Options a worker can receive: the controller runs through synchronous subprocesses, so a side only overlaps another from its own thread. */
|
||||
export type CaptureWorkerOptions = Omit<CiMapOptions, "progress" | "runner" | "now" | "fetch" | "agent" | "signal">;
|
||||
export type CaptureWorkerOptions = Omit<CiMapOptions, "progress" | "runner" | "now" | "fetch" | "agent" | "signal" | "onBlocking">;
|
||||
|
||||
/** Run one capture side on a worker thread so head and base can drive their simulator sessions at the same time. */
|
||||
/**
|
||||
* Run one capture side on a worker thread so head and base can drive their simulator sessions at the same time. While
|
||||
* the worker is blocked in a synchronous call it named (a native build, an install), this thread is free and says so
|
||||
* every `heartbeatMs`: the worker itself can print nothing until the call returns.
|
||||
*/
|
||||
export function runCiMapOnWorker(options: CaptureWorkerOptions, progress: Progress, signal?: AbortSignal): Promise<CiMapResult> {
|
||||
return settleCaptureWorker(new Worker(new URL("./capture-worker.js", import.meta.url), { workerData: options }), options, progress, signal);
|
||||
}
|
||||
|
||||
/** The parent's side of a capture worker: its messages, its heartbeat while blocked, and how it ends. Tests drive it with a stub worker. */
|
||||
export function settleCaptureWorker(worker: Worker, options: Pick<CaptureWorkerOptions, "side" | "timingsSide" | "appearancePass">, progress: Progress,
|
||||
signal?: AbortSignal, heartbeatMs = 60_000): Promise<CiMapResult> {
|
||||
return new Promise((resolve, reject) => {
|
||||
const worker = new Worker(new URL("./capture-worker.js", import.meta.url), { workerData: options });
|
||||
let heartbeat: ReturnType<typeof setInterval> | undefined;
|
||||
const unblocked = () => { clearInterval(heartbeat); heartbeat = undefined; };
|
||||
const blocked = (phase: TimingPhase, boundMs: number) => {
|
||||
unblocked();
|
||||
const since = Date.now();
|
||||
// Named as the capture's timings are: a baseline captures its commit as head.
|
||||
const who = [options.timingsSide ?? options.side ?? "capture", options.appearancePass?.capture.join("+")].filter(Boolean).join(" ");
|
||||
heartbeat = setInterval(() => progress(`${who}: still in ${phase} (${formatDuration(Date.now() - since)} of at most ${formatDuration(boundMs)})`), heartbeatMs);
|
||||
heartbeat.unref();
|
||||
};
|
||||
worker.once("exit", unblocked);
|
||||
// An AbortSignal cannot cross threads; the worker aborts its own, and its capture stops its session as usual.
|
||||
const abort = () => worker.postMessage({ type: "abort", reason: serializeCiError(signal!.reason) } satisfies ParentMessage);
|
||||
if (signal?.aborted) abort(); else signal?.addEventListener("abort", abort, { once: true });
|
||||
@@ -21,6 +43,9 @@ export function runCiMapOnWorker(options: CaptureWorkerOptions, progress: Progre
|
||||
let settled = false;
|
||||
const finish = (callback: () => void) => { if (!settled) { settled = true; callback(); } };
|
||||
worker.on("message", (message: WorkerMessage) => {
|
||||
// Handled before the catch-all below, which settles the capture as failed on any message it does not know.
|
||||
if (message.type === "blocking") { if (TIMING_PHASES.includes(message.phase)) blocked(message.phase, message.boundMs); return; }
|
||||
if (message.type === "unblocked") { unblocked(); return; }
|
||||
if (message.type === "progress") progress(message.message);
|
||||
else if (message.type === "done") finish(() => resolve(message.result));
|
||||
else finish(() => reject(new CiError({ ...message.error, ...(message.error.details ? { details: message.error.details } : {}) })));
|
||||
@@ -39,7 +64,12 @@ if (!isMainThread && parentPort) {
|
||||
port.on("message", (message: ParentMessage) => { if (message.type === "abort") controller.abort(new CiError(message.reason)); });
|
||||
// Listening for an abort must not keep the worker alive once its capture is done.
|
||||
port.unref();
|
||||
runCiMap({ ...options, signal: controller.signal, progress: message => port.postMessage({ type: "progress", message } satisfies WorkerMessage) })
|
||||
runCiMap({ ...options, signal: controller.signal, progress: message => port.postMessage({ type: "progress", message } satisfies WorkerMessage),
|
||||
// Posted before the call blocks this thread: the parent receives it while the call runs.
|
||||
onBlocking: (phase, boundMs) => {
|
||||
port.postMessage({ type: "blocking", phase, boundMs } satisfies WorkerMessage);
|
||||
return () => port.postMessage({ type: "unblocked" } satisfies WorkerMessage);
|
||||
} })
|
||||
.then(result => port.postMessage({ type: "done", result } satisfies WorkerMessage))
|
||||
.catch((error: unknown) => port.postMessage({ type: "error", error: serializeCiError(error, { secrets: [options.expoToken, ...environmentSecrets(options.environment ?? {})] }) } satisfies WorkerMessage));
|
||||
}
|
||||
+116
-21
@@ -19,7 +19,7 @@ import { quarantineReviewContract } from "../contracts/review-validation.js";
|
||||
import { agentCaptureConstraints } from "../capture/agent/source-context.js";
|
||||
import { captureArtifactCacheMayMatch, captureRecipeConfig, incompleteCaptureReason, restoreCaptureArtifactCache, writeCaptureArtifactCache } from "./artifact-cache.js";
|
||||
import { runCiMapOnWorker } from "./capture-worker.js";
|
||||
import { DEFAULT_BASELINE_WAIT_MINUTES, awaitPendingBaseline } from "./baseline-wait.js";
|
||||
import { DEFAULT_BASELINE_WAIT_MINUTES, awaitPendingBaseline, type BaselineWaitOptions } from "./baseline-wait.js";
|
||||
import { writeCiReportInput, readAppDirectory } from "../report/artifact.js";
|
||||
import { assessPublicEvidence, readExportedMap, type PublicEvidenceSide } from "../review/evidence-assessment.js";
|
||||
import { parseRuntimeExecutionContext } from "../review/runtime-adapter.js";
|
||||
@@ -34,9 +34,10 @@ import { CiError, environmentSecrets, serializeCiError, toCiError } from "../sha
|
||||
import type { SourceCapturePlan } from "../source/capture-plan.js";
|
||||
import { createSourceChangeSummaries } from "../source/change-summary.js";
|
||||
import { assertNoCaptureHealthIssues, capturedEvidenceInDoubt, partitionCaptureHealthIssues, renderCaptureIssueAnnotation, renderComparisonDiagnosticAnnotation, renderNotesUnavailableAnnotation, renderReviewGapAnnotation, sortedCaptureHealthIssues } from "../capture/health.js";
|
||||
import { EXPLORE_PACKAGE, packageBin } from "../shared/package-paths.js";
|
||||
import { EXPLORE_PACKAGE, EXPLORE_VERSION, packageBin } from "../shared/package-paths.js";
|
||||
import { agentDeviceLauncher, ensureArgentToolServer, ensureController } from "../shared/controller-cache.js";
|
||||
import { silentProgress, type Progress } from "../shared/progress.js";
|
||||
import { createTimings, phaseSequence, silentTimings, type RecordedEvent, type Timings } from "../shared/timings.js";
|
||||
|
||||
|
||||
function requireSecret(environment: NodeJS.ProcessEnv, name: string): string {
|
||||
@@ -160,7 +161,7 @@ export async function captureSideInSessions(mapOptions: CiMapOptions, passes: re
|
||||
progress: Progress, signal: AbortSignal | undefined, worker: boolean,
|
||||
runPass?: (passOptions: CiMapOptions) => Promise<Awaited<ReturnType<typeof runCiMap>>>): Promise<Awaited<ReturnType<typeof runCiMap>>> {
|
||||
const runOnWorker = runPass ?? ((passOptions: CiMapOptions) =>
|
||||
runCiMapOnWorker((({ progress: _progress, runner: _runner, agent: _agent, signal: _signal, ...rest }) => rest)(passOptions), progress, signal));
|
||||
runCiMapOnWorker((({ progress: _progress, runner: _runner, agent: _agent, signal: _signal, onBlocking: _onBlocking, ...rest }) => rest)(passOptions), progress, signal));
|
||||
if (!passes || passes.length <= 1) return worker ? runOnWorker(mapOptions) : runCiMap(mapOptions);
|
||||
const schemes = passes.flat();
|
||||
progress(`${mapOptions.side}: capturing ${passes.map(pass => pass.join("+")).join(" and ")} in separate sessions`);
|
||||
@@ -240,11 +241,14 @@ export async function sideAppearancePasses(config: ExploreConfig, environment: N
|
||||
* base is never started for a review that has already failed.
|
||||
*/
|
||||
export async function captureBaseAfterWait(input: { waited: Promise<string | undefined> | undefined; head: Promise<void>; stopWaiting: () => void;
|
||||
captureBase: (cacheDirectory?: string) => Promise<void> }): Promise<void> {
|
||||
captureBase: (cacheDirectory?: string) => Promise<void>; timings?: Timings }): Promise<void> {
|
||||
if (!input.waited) return input.captureBase();
|
||||
let headFailed = false;
|
||||
input.head.catch(() => { headFailed = true; input.stopWaiting(); });
|
||||
// What the wait cost: from where base would have started to the wait's end. The wait itself began beside head.
|
||||
const blocked = (input.timings ?? silentTimings).span("baseline-blocked");
|
||||
const waited = await input.waited;
|
||||
blocked(waited ? "ok" : "skipped");
|
||||
if (headFailed) return;
|
||||
if (!waited) return input.captureBase();
|
||||
await input.head;
|
||||
@@ -291,12 +295,18 @@ export type PublicCiOptions = {
|
||||
/** Internal dependency injection for tests: replaces the wait for a baseline run that EXPLORE_BASELINE_RUN names. */
|
||||
awaitBaseline?: BaselineWait;
|
||||
progress?: Progress;
|
||||
/** Where the run's timings are appended (`$RUNNER_TEMP/explore-diagnostics/timings.jsonl`); none are kept without it. */
|
||||
timingsPath?: string;
|
||||
progressPostMs?: number;
|
||||
/** Stops the captures between steps (a cancelled job): a session is still stopped, and a hosted repack run cancelled. */
|
||||
signal?: AbortSignal;
|
||||
};
|
||||
|
||||
/** Waits for a baseline of the base commit still being captured: its downloaded export's directory, or undefined. */
|
||||
type BaselineWait = (signal: AbortSignal) => Promise<string | undefined>;
|
||||
/**
|
||||
* Waits for a baseline of the base commit still being captured: its downloaded export's directory, or undefined.
|
||||
* `watch` hears what the baseline job is doing and records the wait.
|
||||
*/
|
||||
type BaselineWait = (signal: AbortSignal, watch?: Pick<BaselineWaitOptions, "onUpdate" | "timings">) => Promise<string | undefined>;
|
||||
|
||||
/**
|
||||
* The wait for a baseline still capturing the base commit: for the run `ci:find-baseline` named in
|
||||
@@ -310,8 +320,8 @@ function pendingBaselineWait(options: Pick<PublicCiOptions, "awaitBaseline" | "c
|
||||
const minutes = options.config.capture.baselineWaitMinutes ?? DEFAULT_BASELINE_WAIT_MINUTES;
|
||||
if (!Number.isSafeInteger(run) || run <= 0 || minutes === 0) return undefined;
|
||||
const target = options.target ?? options.platform ?? options.config.target?.id ?? "ios";
|
||||
return signal => awaitPendingBaseline({ run, sha: baseSha, target, timeoutMs: minutes * 60_000, directory: join(resolve(options.output), "baseline-download"),
|
||||
environment, transport, signal, ...(options.progress ? { progress: options.progress } : {}) });
|
||||
return (signal, watch) => awaitPendingBaseline({ run, sha: baseSha, target, timeoutMs: minutes * 60_000, directory: join(resolve(options.output), "baseline-download"),
|
||||
environment, transport, signal, ...(options.progress ? { progress: options.progress } : {}), ...watch });
|
||||
}
|
||||
|
||||
function assertRunIdentity(environment: NodeJS.ProcessEnv): void {
|
||||
@@ -359,7 +369,7 @@ export async function runCompareCi(options: Omit<PublicCiOptions, "pullRequestPa
|
||||
const awaitBaseline = pendingBaselineWait(options, environment, options.transport ?? fetch, comparison.base.sha);
|
||||
return runCiReview({ ...options, projects, output, state, presentation: comparison, ...(awaitBaseline ? { awaitBaseline } : {}),
|
||||
environment, runId: environment.GITHUB_RUN_ID!, runAttempt: environment.GITHUB_RUN_ATTEMPT!,
|
||||
assertCurrentHead, postComment: async () => {} });
|
||||
assertCurrentHead, postComment: async () => {}, postProgress: async () => {} });
|
||||
}
|
||||
|
||||
export async function runPublicCi(options: PublicCiOptions) {
|
||||
@@ -370,12 +380,17 @@ export async function runPublicCi(options: PublicCiOptions) {
|
||||
assertRunIdentity(environment);
|
||||
const pr = projectPullRequestPresentation(JSON.parse(await readFile(options.pullRequestPath, "utf8")));
|
||||
const { projects, output, state } = await prepareCiRun(options, environment, pr);
|
||||
const postComment = async () => {
|
||||
await assertCurrentPr();
|
||||
// One write at a time, each rendering the state when its turn comes: a progress post still in flight can never land
|
||||
// after a later phase's post, or the failure's, and undo it.
|
||||
let writing = Promise.resolve();
|
||||
const upsert = () => (writing = writing.then(async () => {
|
||||
state.updatedAt = now(); const body = renderPublicComment(state); options.onComment?.(state, body);
|
||||
try { await upsertStickyComment({ repository: pr.repository, issueNumber: pr.number, body, ...platformSectionMerge(state, options.target ?? options.platform), token: githubToken, fetchImpl: transport }); }
|
||||
catch (error) { process.stderr.write(`Progress comment unavailable: ${serializeCiError(error).message}\n`); }
|
||||
};
|
||||
}));
|
||||
const postComment = async () => { await assertCurrentPr(); await upsert(); };
|
||||
// A status update between the phases' posts: it skips the PR check, whose failure would fail the review, and never throws.
|
||||
const postProgress = async () => { if (!prVerificationFailed) await upsert().catch(() => undefined); };
|
||||
let prVerificationFailed = false;
|
||||
const assertCurrentPr = async () => {
|
||||
try {
|
||||
@@ -431,7 +446,27 @@ export async function runPublicCi(options: PublicCiOptions) {
|
||||
const awaitBaseline = pendingBaselineWait(options, environment, transport, pr.base.sha);
|
||||
return runCiReview({ ...options, projects, output, state, presentation: pr, ...(awaitBaseline ? { awaitBaseline } : {}),
|
||||
environment, runId: environment.GITHUB_RUN_ID!, runAttempt: environment.GITHUB_RUN_ATTEMPT!,
|
||||
assertCurrentHead, postComment, canPublish: () => !prVerificationFailed });
|
||||
assertCurrentHead, postComment, postProgress, canPublish: () => !prVerificationFailed });
|
||||
}
|
||||
|
||||
/** The least time between two posts of the comment's waiting status, besides the posts that start and end the wait. */
|
||||
const PROGRESS_POST_MS = 3 * 60_000;
|
||||
|
||||
/** Fetches the controllers in a span; a failure there ends the run before its phases, so it records the run's finish too. */
|
||||
async function controllersTimed(timings: Timings, fetch: () => Promise<void>): Promise<void> {
|
||||
try { await timings.measure("controllers", fetch); }
|
||||
catch (error) {
|
||||
timings.record({ type: "finish", outcome: "failed", code: toCiError(error).code });
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
/** The run a timings file belongs to: the workflow, target, release, and run attempt, from the runner's variables. */
|
||||
function runHeader(environment: NodeJS.ProcessEnv, config: ExploreConfig): RecordedEvent {
|
||||
return { type: "run", release: EXPLORE_VERSION, ...(config.target ? { target: config.target.id } : {}),
|
||||
...(environment.GITHUB_WORKFLOW ? { workflow: environment.GITHUB_WORKFLOW } : {}),
|
||||
...(/^\d+$/.test(environment.GITHUB_RUN_ID ?? "") ? { run: environment.GITHUB_RUN_ID! } : {}),
|
||||
...(/^\d+$/.test(environment.GITHUB_RUN_ATTEMPT ?? "") ? { attempt: environment.GITHUB_RUN_ATTEMPT! } : {}) };
|
||||
}
|
||||
|
||||
function planSummary(plan: SourceCapturePlan, baseline = false): string {
|
||||
@@ -458,6 +493,12 @@ export async function runCiReview(options: {
|
||||
measure?: Parameters<typeof assessPublicEvidence>[0]["measure"];
|
||||
state: PublicCommentState; environment: NodeJS.ProcessEnv;
|
||||
assertCurrentHead: () => Promise<void>; postComment: () => Promise<void>; canPublish?: () => boolean;
|
||||
/** Posts the comment's state without verifying the PR first; best effort, for what changes between phases. */
|
||||
postProgress?: () => Promise<void>;
|
||||
/** The least time between two progress posts while base waits for a baseline (PROGRESS_POST_MS); tests shorten it. */
|
||||
progressPostMs?: number;
|
||||
/** Where the run's timings are appended; none are kept without it. */
|
||||
timingsPath?: string;
|
||||
now?: () => number; sleep?: (milliseconds: number) => void; runner?: CommandRunner; subscription?: boolean; useLocalEasSession?: boolean;
|
||||
agentSessionFactory?: PrepareCiExplorationOptions["createSession"];
|
||||
prepareCapture?: () => Promise<void>;
|
||||
@@ -472,10 +513,13 @@ export async function runCiReview(options: {
|
||||
}) {
|
||||
const { projects, output, config, environment, state, assertCurrentHead, postComment } = options;
|
||||
const progress = options.progress ?? silentProgress;
|
||||
const timings = createTimings({ path: options.timingsPath, secrets: environmentSecrets(environment) });
|
||||
timings.record(runHeader(environment, config));
|
||||
const phases = phaseSequence(timings);
|
||||
// The controllers are fetched before any EAS work, so a blocked download fails before a session is paid for. agent-device
|
||||
// also compares the screenshots. An injected runner (tests) stands in for the controllers' calls, but not for that
|
||||
// comparison: it still runs the real agent-device, which fetches itself on first use.
|
||||
if (!options.runner) await prefetchControllers(config, environment, progress);
|
||||
if (!options.runner) await controllersTimed(timings, () => prefetchControllers(config, environment, progress));
|
||||
const pr = options.presentation;
|
||||
const now = options.now ?? Date.now;
|
||||
const secretValues = environmentSecrets(environment);
|
||||
@@ -485,7 +529,10 @@ export async function runCiReview(options: {
|
||||
let reportWritten = false;
|
||||
// Stops a baseline wait still polling once the review no longer needs it: done, failed, or stopped.
|
||||
const stopWaiting = new AbortController();
|
||||
let progressPost: ReturnType<typeof setTimeout> | undefined;
|
||||
let progressPostedAt = -Infinity;
|
||||
try {
|
||||
phases.enter("plan");
|
||||
progress(`planning the review of ${pr.head.sha.slice(0, 8)} against base ${pr.base.sha.slice(0, 8)} (scope ${config.exploration.scope})`);
|
||||
const plan = await buildVerifiedPlan({ baseProject: projects.base, headProject: projects.head,
|
||||
baseSha: pr.base.sha, headSha: pr.head.sha, config, output });
|
||||
@@ -500,7 +547,7 @@ export async function runCiReview(options: {
|
||||
state.capture = { planned: { base: plan.baseCaptureSurfaceIds.length, head: plan.headCaptureSurfaceIds.length },
|
||||
done: { base: 0, head: 0 }, baseFromCache: false };
|
||||
await assertCurrentHead(); await postComment();
|
||||
stage = "preflight";
|
||||
stage = "preflight"; phases.enter("preflight");
|
||||
const active = plan.headCaptureSurfaceIds.length + plan.baseCaptureSurfaceIds.length > 0;
|
||||
if (active && !options.useLocalEasSession) requireSecret(environment, "EXPO_TOKEN");
|
||||
const exploration = await prepareCiExploration(config, projects.head, environment, active,
|
||||
@@ -517,8 +564,22 @@ export async function runCiReview(options: {
|
||||
...(environment.EXPLORE_CAPTURE_CACHE ? { sourceDirectory: environment.EXPLORE_CAPTURE_CACHE } : {}), commit: pr.base.sha });
|
||||
// With no finished baseline to reuse, one still being captured is waited for: from now, alongside head, and base
|
||||
// waits for it only where it would start. Head is never delayed by it (brentvatne/euxy's review run 39348956443).
|
||||
// While it waits, the comment says so and names the step the baseline job is in. It is posted when the wait starts
|
||||
// and ends, and in between at most every `progressPostMs` with the latest step: every post rewrites the whole
|
||||
// comment, which the other targets' jobs write too.
|
||||
const waitingFor = (step?: string) => {
|
||||
if (step === undefined) delete state.capture!.waiting;
|
||||
else state.capture!.waiting = { on: "baseline", ...(step ? { step } : {}) };
|
||||
clearTimeout(progressPost);
|
||||
const post = () => { progressPostedAt = Date.now(); void options.postProgress?.(); };
|
||||
const due = progressPostedAt + (options.progressPostMs ?? PROGRESS_POST_MS) - Date.now();
|
||||
if (step === undefined || due <= 0) post();
|
||||
else (progressPost = setTimeout(post, due)).unref();
|
||||
};
|
||||
const waitedBaseline = !baselineMayExist && plan.baseCaptureSurfaceIds.length > 0 && options.awaitBaseline
|
||||
? options.awaitBaseline(options.signal ? AbortSignal.any([stopWaiting.signal, options.signal]) : stopWaiting.signal).catch(() => undefined) : undefined;
|
||||
? options.awaitBaseline(options.signal ? AbortSignal.any([stopWaiting.signal, options.signal]) : stopWaiting.signal,
|
||||
{ timings, onUpdate: update => waitingFor(update.step ?? "") }).catch(() => undefined)
|
||||
.finally(() => { if (state.capture?.waiting) waitingFor(undefined); }) : undefined;
|
||||
const share = targetSessionShare(config, options.targets, options.posedTargets);
|
||||
// A share of one session captures the sides in turn.
|
||||
const concurrent = captureSidesConcurrently({ plan, agent: !!exploration.agent, injectedRunner: !!options.runner, baselineMayExist }) && share >= 2;
|
||||
@@ -554,6 +615,7 @@ export async function runCiReview(options: {
|
||||
mapDirectory: join(output, `${side}-map`), outputDirectory: directory,
|
||||
name: config.app.name ?? pr.repository, buildId: pr.origin === "local" ? `local-${pr.runId}-${side}` : pr.origin === "compare" ? `compare-${options.runId}-${side}` : `pr-${pr.number}-${side}`, buildVersion: pr[side].sha.slice(0, 8), gitCommit: pr[side].sha,
|
||||
planPath: join(output, "execution-plan.json"), side, sessionStatePath: join(output, `${side}-session`), ...(options.buildShare ? { buildShare: options.buildShare } : {}),
|
||||
...(options.timingsPath ? { timingsPath: options.timingsPath } : {}),
|
||||
...repackShareOption(config, environment, options.repackPeers),
|
||||
...(reuseDirectory ? { reuseDirectory } : {}), ...(options.signal ? { signal: options.signal } : {}) };
|
||||
// A restored baseline already holds every appearance pass, so it never splits.
|
||||
@@ -576,7 +638,8 @@ export async function runCiReview(options: {
|
||||
await writeCaptureArtifactCache(directory, cacheRecipe);
|
||||
};
|
||||
const captureBase = (head: Promise<void>) => captureBaseAfterWait({ waited: waitedBaseline, head, stopWaiting: () => stopWaiting.abort(),
|
||||
captureBase: cacheDirectory => captureSide("base", cacheDirectory) });
|
||||
captureBase: cacheDirectory => captureSide("base", cacheDirectory), timings });
|
||||
phases.enter("capture");
|
||||
if (waitedBaseline) progress(`base waits for the baseline run of ${pr.base.sha.slice(0, 8)} still being captured; head captures meanwhile`);
|
||||
if (concurrent) {
|
||||
stage = "capture-head"; state.phase = "capturing"; state.capture.current = "head"; usagePhase = "capture-head";
|
||||
@@ -598,7 +661,7 @@ export async function runCiReview(options: {
|
||||
}
|
||||
}
|
||||
delete state.capture.current;
|
||||
stage = "compare";
|
||||
stage = "compare"; phases.enter("compare");
|
||||
progress("comparing base and head captures");
|
||||
const sides = { base: await evidenceSide(join(output, "base-export")), head: await evidenceSide(join(output, "head-export")) };
|
||||
const system = systemRegions({ platform: config.app.platform, device: config.device.name, pose: config.device.pose });
|
||||
@@ -655,7 +718,7 @@ export async function runCiReview(options: {
|
||||
for (const diagnostic of failedComparisons) progress(renderComparisonDiagnosticAnnotation(diagnostic));
|
||||
if (failedComparisons.length) progress(`${failedComparisons.length} comparison${failedComparisons.length === 1 ? "" : "s"} failed; the affected screens read as needing review`);
|
||||
if (exploration.agent) {
|
||||
stage = "notes";
|
||||
stage = "notes"; phases.enter("notes");
|
||||
usagePhase = "notes";
|
||||
try {
|
||||
const notes = await generateAgentChangeNotes({ review: result.review, assets: result.assets,
|
||||
@@ -678,12 +741,18 @@ export async function runCiReview(options: {
|
||||
await writeFile(join(output, "agent-notes-diagnostics.json"), JSON.stringify({ error: serializeCiError(failure) }));
|
||||
}
|
||||
}
|
||||
phases.enter("report");
|
||||
await preserveReport();
|
||||
progress(pr.origin === "compare" || pr.origin === "local" ? "writing the report" : "writing the report and updating the pull request comment");
|
||||
await assertCurrentHead(); await postComment();
|
||||
phases.end();
|
||||
timings.record({ type: "finish", outcome: "ok" });
|
||||
return { ...result, evidence, inputPath };
|
||||
} catch (error) {
|
||||
state.phase = "failed"; const diagnostic = serializeCiError(error, { secrets: secretValues });
|
||||
const cancelled = diagnostic.code === "CAPTURE_CANCELLED";
|
||||
phases.end(cancelled ? "cancelled" : "failed", diagnostic.code);
|
||||
timings.record({ type: "finish", outcome: cancelled ? "cancelled" : "failed", code: diagnostic.code });
|
||||
state.failure = { step: stage, message: `${diagnostic.code}: ${diagnostic.message} ${diagnostic.nextAction}` };
|
||||
try { await preserveReport?.(); } catch { /* Retain the original failure if its report cannot be written. */ }
|
||||
// An exhausted verification already established that publication is unavailable; do not repeat its attempts.
|
||||
@@ -693,6 +762,7 @@ export async function runCiReview(options: {
|
||||
throw error;
|
||||
} finally {
|
||||
stopWaiting.abort();
|
||||
clearTimeout(progressPost);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -710,10 +780,31 @@ export async function runBaselineCi(options: { platform?: ExplorePlatform; proje
|
||||
/** Agent mode with the local claude or codex login instead of the provider's API key. */
|
||||
subscription?: boolean;
|
||||
/** Stops the capture between steps (a cancelled job): its session is still stopped, and a hosted repack run cancelled. */
|
||||
signal?: AbortSignal }) {
|
||||
signal?: AbortSignal;
|
||||
/** Where the run's timings are appended; none are kept without it. */
|
||||
timingsPath?: string }) {
|
||||
const environment = options.environment ?? process.env;
|
||||
assertCheckout(options.project, options.sha);
|
||||
if (!options.runner) await prefetchControllers(options.config, environment, options.progress ?? silentProgress);
|
||||
const timings = createTimings({ path: options.timingsPath, labels: { side: "baseline" }, secrets: environmentSecrets(environment) });
|
||||
timings.record(runHeader(environment, options.config));
|
||||
if (!options.runner) await controllersTimed(timings, () => prefetchControllers(options.config, environment, options.progress ?? silentProgress));
|
||||
const phases = phaseSequence(timings);
|
||||
try {
|
||||
phases.enter("plan");
|
||||
const baseline = await captureBaseline(options, environment, phases);
|
||||
phases.end();
|
||||
timings.record({ type: "finish", outcome: "ok" });
|
||||
return baseline;
|
||||
} catch (error) {
|
||||
const code = toCiError(error).code;
|
||||
const outcome = code === "CAPTURE_CANCELLED" ? "cancelled" : "failed";
|
||||
phases.end(outcome, code);
|
||||
timings.record({ type: "finish", outcome, code });
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
async function captureBaseline(options: Parameters<typeof runBaselineCi>[0], environment: NodeJS.ProcessEnv, phases: ReturnType<typeof phaseSequence>) {
|
||||
const output = resolve(options.output);
|
||||
const relativeOutput = relative(await realpath(options.project), output);
|
||||
if (!relativeOutput.startsWith("..") || isAbsolute(relativeOutput)) throw new Error("Baseline output must be outside the source checkout");
|
||||
@@ -723,6 +814,7 @@ export async function runBaselineCi(options: { platform?: ExplorePlatform; proje
|
||||
baseSha: options.sha, headSha: options.sha, config: options.config, output, scope: "all" });
|
||||
progress(planSummary(plan, true));
|
||||
const active = plan.headCaptureSurfaceIds.length > 0;
|
||||
phases.enter("preflight");
|
||||
if (active && !options.useLocalEasSession) requireSecret(environment, "EXPO_TOKEN");
|
||||
let usagePhase: AgentUsagePhase = "preflight";
|
||||
const exploration = await prepareCiExploration(options.config, options.project, environment, active,
|
||||
@@ -736,6 +828,7 @@ export async function runBaselineCi(options: { platform?: ExplorePlatform; proje
|
||||
mapDirectory: join(output, "baseline-map"), outputDirectory: directory, name: options.config.app.name ?? options.config.app.bundleId,
|
||||
buildId: `baseline-${options.sha.slice(0, 12)}`, buildVersion: options.sha.slice(0, 8), gitCommit: options.sha,
|
||||
side: "head", planPath: join(output, "execution-plan.json"), sessionStatePath: join(output, "baseline-session"),
|
||||
...(options.timingsPath ? { timingsPath: options.timingsPath, timingsSide: "baseline" } : {}),
|
||||
...repackShareOption(options.config, environment, options.repackPeers), ...(options.signal ? { signal: options.signal } : {}) };
|
||||
const share = targetSessionShare(options.config, options.targets, options.posedTargets);
|
||||
// Passes on worker threads cannot take an injected runner or an agent session.
|
||||
@@ -743,7 +836,9 @@ export async function runBaselineCi(options: { platform?: ExplorePlatform; proje
|
||||
? await sideAppearancePasses(options.config, environment, { share, sides: 1, routes: plan.headCaptureSurfaceIds.length, project: options.project }) : undefined;
|
||||
progress(`sessions: ${share} of ${options.config.capture.maxSessions ?? DEFAULT_MAX_SESSIONS} for this target; `
|
||||
+ (passes ? `capturing ${passes.map(pass => pass.join("+")).join(" and ")} in separate sessions` : "one session"));
|
||||
phases.enter("capture");
|
||||
const result = await captureSideInSessions(baselineOptions, passes, progress, options.signal, passes !== undefined);
|
||||
phases.enter("report");
|
||||
const cacheRecipe = await recipe(options.config, plan, "head", environment, exploration.instructionsSha256);
|
||||
if (options.subscription) cacheRecipe.toolsCommit += ":local-subscription";
|
||||
const bundle = await readCaptureBundle(directory); bundle.profile = cacheRecipe.profile;
|
||||
|
||||
+15
-5
@@ -21,6 +21,7 @@ import { help } from "./help.js";
|
||||
import { CiError } from "../shared/ci-errors.js";
|
||||
import { cleanupAfterCapture, findOptionalBaseline, resolveCompareRefs, resolvePullRequest, writeCaptureOutputs, writeStepOutputs } from "../ci/workflow-steps.js";
|
||||
import { stderrProgress } from "../shared/progress.js";
|
||||
import { appendTimingsSummary, timingsPathFor } from "../shared/timings.js";
|
||||
import { maxParallelTargets } from "../ci/session-plan.js";
|
||||
|
||||
export async function doctor(): Promise<void> {
|
||||
@@ -137,6 +138,8 @@ export async function ciCompareRefs(): Promise<void> {
|
||||
|
||||
/** `ci:after-capture --output DIR --checkout DIR...`: stop recorded sessions and check the checkouts are untouched; fails after reporting every problem. */
|
||||
export async function ciAfterCapture(): Promise<void> {
|
||||
// The timings table of a capture stopped before it could write one; a summary that cannot be written changes nothing here.
|
||||
await appendTimingsSummary().catch(() => false);
|
||||
const result = await cleanupAfterCapture({ output: required("output"), checkouts: flags("checkout") });
|
||||
for (const failure of result.failures) console.error(`::error title=${failure.code}::${failure.message} ${failure.nextAction}`);
|
||||
output({ ok: result.failures.length === 0, ...result });
|
||||
@@ -261,9 +264,13 @@ export async function captureReview(): Promise<void> {
|
||||
const common = { ...(named ? { target: config.target!.id } : {}), ...(selection.platform ? { platform: selection.platform } : {}),
|
||||
platforms: listPlatforms(rawConfig), targets: configTargets(rawConfig), posedTargets: posedTargets(rawConfig), repackPeers: hostedRepackPeers(rawConfig, config, overrides),
|
||||
baseProject: required("base-project"), headProject,
|
||||
output: required("output"), config, configPath, progress: stderrProgress(), signal: ciInterrupt() };
|
||||
const result = has("compare") ? await runCompareCi({ ...common, comparePath: required("compare") })
|
||||
: await runPublicCi({ ...common, pullRequestPath: required("pull-request") });
|
||||
output: required("output"), config, configPath, progress: stderrProgress(), signal: ciInterrupt(),
|
||||
...(timingsPathFor(process.env) ? { timingsPath: timingsPathFor(process.env)! } : {}) };
|
||||
let result;
|
||||
try {
|
||||
result = has("compare") ? await runCompareCi({ ...common, comparePath: required("compare") })
|
||||
: await runPublicCi({ ...common, pullRequestPath: required("pull-request") });
|
||||
} finally { await appendTimingsSummary().catch(() => false); }
|
||||
// The deploy job runs only when the reviewed config asks for a hosted report.
|
||||
await writeCaptureOutputs(result.inputPath);
|
||||
output({ ok: true, inputPath: result.inputPath });
|
||||
@@ -274,8 +281,11 @@ export async function captureBaseline(): Promise<void> {
|
||||
const rawConfig = await readExploreConfig(project, flag("config") ?? DEFAULT_EXPLORE_CONFIG_PATH);
|
||||
const overrides = { controller: flag("controller"), simulator: flag("simulator"), repack: flag("repack") };
|
||||
const config = withRunOverrides(resolveTargetConfig(rawConfig, targetSelection()), overrides);
|
||||
output({ ok: true, ...await runBaselineCi({ platform: config.app.platform, project, sha: required("sha"), output: required("output"), config, targets: configTargets(rawConfig), posedTargets: posedTargets(rawConfig),
|
||||
repackPeers: hostedRepackPeers(rawConfig, config, overrides), progress: stderrProgress(), signal: ciInterrupt() }) });
|
||||
const timingsPath = timingsPathFor(process.env);
|
||||
try {
|
||||
output({ ok: true, ...await runBaselineCi({ platform: config.app.platform, project, sha: required("sha"), output: required("output"), config, targets: configTargets(rawConfig), posedTargets: posedTargets(rawConfig),
|
||||
repackPeers: hostedRepackPeers(rawConfig, config, overrides), progress: stderrProgress(), signal: ciInterrupt(), ...(timingsPath ? { timingsPath } : {}) }) });
|
||||
} finally { await appendTimingsSummary().catch(() => false); }
|
||||
}
|
||||
|
||||
/** `capture` (or `capture:review`) `[--base REF] [--head REF | --committed]`: a local review, opened in the Viewer or hosted with --upload. */
|
||||
|
||||
@@ -48,6 +48,8 @@ export type PublicCommentState = {
|
||||
baseFromCache: boolean;
|
||||
/** Which side is being captured right now, while `capturing`. */
|
||||
current?: "base" | "head";
|
||||
/** Base waits for the default branch's baseline of its commit, still being captured; `step` is the baseline job's current step. */
|
||||
waiting?: { on: "baseline"; step?: string };
|
||||
};
|
||||
review?: PublicReview;
|
||||
evidence?: PublicEvidenceSummary;
|
||||
@@ -290,7 +292,8 @@ export function platformRecordOf(state: PublicCommentState, target?: CommentTarg
|
||||
record.app = { ...(state.build.appName ? { name: state.build.appName } : {}), ...(state.build.appVersion ? { version: state.build.appVersion } : {}),
|
||||
...(state.build.appBuildNumber ? { build: state.build.appBuildNumber } : {}) };
|
||||
}
|
||||
if (state.capture) record.capture = { planned: { ...state.capture.planned }, done: { ...state.capture.done }, baseFromCache: state.capture.baseFromCache, ...(state.capture.current ? { current: state.capture.current } : {}) };
|
||||
if (state.capture) record.capture = { planned: { ...state.capture.planned }, done: { ...state.capture.done }, baseFromCache: state.capture.baseFromCache, ...(state.capture.current ? { current: state.capture.current } : {}),
|
||||
...(state.capture.waiting ? { waiting: { ...state.capture.waiting } } : {}) };
|
||||
const health = captureHealth(state);
|
||||
if (health && (state.phase === "ready" || state.phase === "failed")) record.health = { base: { ...health.base }, head: { ...health.head } };
|
||||
if (state.phase === "ready") {
|
||||
@@ -515,6 +518,9 @@ function statusLine(record: PlatformRecord): string | undefined {
|
||||
case "capturing": {
|
||||
const capture = record.capture;
|
||||
if (!capture) return `${label} · capturing · ${run}`;
|
||||
// Head goes on while base waits for the baseline; once head is done, the wait is all there is to say.
|
||||
if (capture.waiting) return `${label} · head ${capture.done.head}/${capture.planned.head} · base waits for the default branch's baseline`
|
||||
+ `${capture.waiting.step ? ` (in “${inlineText(capture.waiting.step, 80)}”)` : ""} · ${run}`;
|
||||
const side = capture.current ?? (capture.done.head > 0 || capture.baseFromCache ? "head" : "base");
|
||||
return `${label} · capturing ${side} ${capture.done[side]}/${capture.planned[side]}${capture.baseFromCache && side === "head" ? " · base reused" : ""} · ${run}`;
|
||||
}
|
||||
|
||||
@@ -96,7 +96,8 @@ export type PlatformRecord = {
|
||||
device?: string;
|
||||
app?: { name?: string; version?: string; build?: string };
|
||||
links: { run: string; report?: string; download?: string; artifacts: string; config: string; expiresAt?: number | null; deploying?: true };
|
||||
capture?: { planned: { base: number; head: number }; done: { base: number; head: number }; baseFromCache: boolean; current?: "base" | "head" };
|
||||
capture?: { planned: { base: number; head: number }; done: { base: number; head: number }; baseFromCache: boolean; current?: "base" | "head";
|
||||
waiting?: { on: "baseline"; step?: string } };
|
||||
health?: { base: SideHealth; head: SideHealth };
|
||||
validation?: {
|
||||
visual?: { compared: number; threshold: number; eligible?: number; skipped?: number; failed: number };
|
||||
@@ -252,7 +253,9 @@ export function parsePlatformRecord(value: unknown): PlatformRecord | undefined
|
||||
}
|
||||
if (isRecord(value.capture) && pair(value.capture.planned) && pair(value.capture.done) && typeof value.capture.baseFromCache === "boolean") {
|
||||
record.capture = { planned: { base: value.capture.planned.base, head: value.capture.planned.head }, done: { base: value.capture.done.base, head: value.capture.done.head },
|
||||
baseFromCache: value.capture.baseFromCache, ...(isSide(value.capture.current) ? { current: value.capture.current } : {}) };
|
||||
baseFromCache: value.capture.baseFromCache, ...(isSide(value.capture.current) ? { current: value.capture.current } : {}),
|
||||
...(isRecord(value.capture.waiting) && value.capture.waiting.on === "baseline"
|
||||
? { waiting: { on: "baseline" as const, ...(isString(value.capture.waiting.step, 80) ? { step: value.capture.waiting.step } : {}) } } : {}) };
|
||||
}
|
||||
if (isRecord(value.health) && health(value.health.base) && health(value.health.head)) {
|
||||
const pick = (side: SideHealth): SideHealth => ({ planned: side.planned, captured: side.captured, verified: side.verified, unverified: side.unverified, unavailable: side.unavailable });
|
||||
|
||||
@@ -60,7 +60,8 @@ export function environmentSecrets(environment: NodeJS.ProcessEnv): string[] {
|
||||
return Object.entries(environment).filter(([key]) => /(?:TOKEN|SECRET|PASSWORD|API_KEY)/i.test(key)).flatMap(([, value]) => value ? [value] : []);
|
||||
}
|
||||
|
||||
function redact(value: string, secrets: readonly string[]): string {
|
||||
/** Redacts secret values, bearer and provider tokens, credentials in URLs, and signed-URL parameters from any text Explore writes. */
|
||||
export function redactSecrets(value: string, secrets: readonly string[]): string {
|
||||
let result = value;
|
||||
// Controller failures may embed JSON or URLs inside their message rather than
|
||||
// returning the original input as a separate structured field.
|
||||
@@ -77,12 +78,14 @@ function redact(value: string, secrets: readonly string[]): string {
|
||||
return result
|
||||
.replace(/\bBearer\s+[^\s,;]+/gi, "Bearer [REDACTED]")
|
||||
.replace(/\b(?:gh[pousr]_[A-Za-z0-9_]+|github_pat_[A-Za-z0-9_]+|sk-(?:ant-)?[A-Za-z0-9_-]{12,})\b/g, "[REDACTED]")
|
||||
.replace(/([?&](?:access_token|token|api_key|key|signature|sig)=)[^&#\s]*/gi, "$1[REDACTED]")
|
||||
// In a query or a fragment: a simulator session's public preview link carries its token in the fragment, and an
|
||||
// object store's signed link its credential and signature among the query's X-Amz- or X-Goog- parameters.
|
||||
.replace(/([?&#](?:access_token|token|api_key|key|signature|sig|se|sv|x-(?:amz|goog)-(?:signature|credential|security-token))=)[^&#\s]*/gi, "$1[REDACTED]")
|
||||
.replace(/(https?:\/\/)[^\s/@]+:[^\s/@]+@/gi, "$1[REDACTED]@");
|
||||
}
|
||||
|
||||
function clean(value: unknown, secrets: readonly string[], seen = new Set<object>()): unknown {
|
||||
if (typeof value === "string") return redact(value, secrets);
|
||||
if (typeof value === "string") return redactSecrets(value, secrets);
|
||||
if (value === null || typeof value !== "object") return value;
|
||||
if (seen.has(value)) return "[Circular]";
|
||||
seen.add(value);
|
||||
@@ -183,7 +186,7 @@ export async function reportCiError(error: unknown, options: {
|
||||
for (const [index, result] of results.entries()) {
|
||||
if (result.status === "rejected") {
|
||||
const code = (result.reason as NodeJS.ErrnoException | undefined)?.code;
|
||||
const reason = typeof code === "string" ? ` (${redact(code, secrets)})` : "";
|
||||
const reason = typeof code === "string" ? ` (${redactSecrets(code, secrets)})` : "";
|
||||
write(`::warning title=Explore diagnostics::${annotationData(`Could not write the ${outputs[index]!.label}${reason}. Check runner output permissions. The original failure above still applies.`)}`);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,308 @@
|
||||
import { randomUUID } from "node:crypto";
|
||||
import { appendFileSync, mkdirSync } from "node:fs";
|
||||
import { appendFile, readFile, writeFile } from "node:fs/promises";
|
||||
import { dirname, resolve } from "node:path";
|
||||
import { redactSecrets, type CiError } from "./ci-errors.js";
|
||||
import type { Progress } from "./progress.js";
|
||||
|
||||
/**
|
||||
* Where a capture job's time goes, appended as JSON lines to `explore-diagnostics/timings.jsonl` as the job runs, so a
|
||||
* job killed partway still leaves what it did up to then, and rendered as a table in the job summary at the end.
|
||||
*
|
||||
* What is written is closed by construction: a phase from this list, ids, counts, durations and outcome codes. Strings
|
||||
* pass through `safeText`, which redacts secrets and drops anything shaped like a link; links are built only by
|
||||
* `githubRunLink` and `easPageLink`. The diagnostics artifact is uploaded from public repositories.
|
||||
*/
|
||||
export const TIMING_PHASES = [
|
||||
"controllers", "plan", "preflight", "appearance-config", "baseline-wait", "baseline-blocked", "baseline-restore",
|
||||
"configuration", "fingerprint", "build-lookup", "native-build", "repack", "repack-share-wait", "build-download",
|
||||
"session-start", "session-verify", "install", "launch", "route", "pass", "export", "session-stop",
|
||||
"capture", "compare", "notes", "report",
|
||||
] as const;
|
||||
export type TimingPhase = typeof TIMING_PHASES[number];
|
||||
export type TimingOutcome = "ok" | "failed" | "cancelled" | "skipped";
|
||||
export type TimingAttributes = Readonly<Record<string, string | number | boolean | undefined>>;
|
||||
/** Which capture an event belongs to: a side of a review (or the baseline), and the appearance pass of a split side. */
|
||||
export type TimingLabels = { side?: string | undefined; pass?: string | undefined };
|
||||
|
||||
/** What a recorder writes besides spans: the run it belongs to, how it finished, and a step of the baseline job it waited for. */
|
||||
export type RecordedEvent =
|
||||
| { type: "run"; workflow?: string; target?: string; release?: string; run?: string; attempt?: string }
|
||||
| { type: "baseline-step"; name: string; ms: number; conclusion: string }
|
||||
| { type: "finish"; outcome: TimingOutcome; code?: string };
|
||||
export type TimingEvent = (
|
||||
| RecordedEvent
|
||||
| { type: "start"; id: string; phase: TimingPhase; attributes?: TimingAttributes }
|
||||
| { type: "end"; id: string; phase: TimingPhase; ms: number; outcome: TimingOutcome; attributes?: TimingAttributes }
|
||||
) & { at: number; side?: string; pass?: string };
|
||||
|
||||
export type SpanEnd = (outcome?: TimingOutcome, attributes?: TimingAttributes) => void;
|
||||
|
||||
export type Timings = {
|
||||
/** Opens a span; the function it returns closes it, once. */
|
||||
span(phase: TimingPhase, attributes?: TimingAttributes): SpanEnd;
|
||||
/** Runs `run` in a span that ends `ok` when it returns (or its promise resolves) and `failed` or `cancelled` when it throws. */
|
||||
measure<T>(phase: TimingPhase, run: () => T, attributes?: TimingAttributes): T;
|
||||
/** A run header, a finish line or a step of the baseline job. */
|
||||
record(event: RecordedEvent): void;
|
||||
/** The same file, with these labels on every event. */
|
||||
labelled(labels: TimingLabels): Timings;
|
||||
};
|
||||
|
||||
/**
|
||||
* Says that the calling thread is about to block in a synchronous subprocess for up to `boundMs`, and returns the
|
||||
* function that says it is done. A capture on a worker thread passes one that tells the parent, whose thread is free
|
||||
* to print a line while the worker is blocked (runCiMapOnWorker); on the main thread nothing can run meanwhile.
|
||||
*/
|
||||
export type BlockingNotice = (phase: TimingPhase, boundMs: number) => () => void;
|
||||
|
||||
export const silentTimings: Timings = {
|
||||
span: () => () => {},
|
||||
measure: (_phase, run) => run(),
|
||||
record: () => {},
|
||||
labelled: () => silentTimings,
|
||||
};
|
||||
|
||||
const SAFE_TEXT_LENGTH = 80;
|
||||
|
||||
/** Text from outside Explore (a workflow step's name), made safe to publish: redacted, without links, on one short line. */
|
||||
export function safeText(value: string, secrets: readonly string[] = []): string {
|
||||
const text = redactSecrets(value, secrets).replace(/\b[a-z][a-z0-9+.-]*:\/\/\S+/gi, "[link]").replace(/\s+/g, " ").trim();
|
||||
return text.length > SAFE_TEXT_LENGTH ? `${text.slice(0, SAFE_TEXT_LENGTH - 1)}…` : text;
|
||||
}
|
||||
|
||||
function safeAttributes(attributes: TimingAttributes | undefined, secrets: readonly string[]): TimingAttributes | undefined {
|
||||
if (!attributes) return undefined;
|
||||
const entries = Object.entries(attributes).filter(([, value]) => value !== undefined)
|
||||
.map(([key, value]) => [key, typeof value === "string" ? safeText(value, secrets) : value] as const);
|
||||
return entries.length ? Object.fromEntries(entries) : undefined;
|
||||
}
|
||||
|
||||
/** A failure's closed code, never its message: a CiError's code (read by shape, as one rebuilt from a worker is), or none. */
|
||||
function failure(error: unknown): { outcome: TimingOutcome; code?: string } {
|
||||
const code = error instanceof Error && typeof (error as Partial<CiError>).code === "string" && /^[A-Z][A-Z0-9_]{0,63}$/.test((error as CiError).code)
|
||||
? (error as CiError).code : undefined;
|
||||
if (code === "CAPTURE_CANCELLED" || error instanceof Error && error.name === "AbortError") return { outcome: "cancelled", ...(code ? { code } : {}) };
|
||||
return { outcome: "failed", ...(code ? { code } : {}) };
|
||||
}
|
||||
|
||||
/**
|
||||
* A recorder appending to `path`, or one that records nothing without a path. Each event is one synchronous append,
|
||||
* small enough that two threads appending to the same file never interleave within a line. A failed write is
|
||||
* dropped: timing a capture must never fail it.
|
||||
*/
|
||||
export function createTimings(options: { path?: string | undefined; labels?: TimingLabels; secrets?: readonly string[]; now?: () => number }): Timings {
|
||||
if (!options.path) return silentTimings;
|
||||
const path = options.path;
|
||||
const now = options.now ?? Date.now;
|
||||
const secrets = options.secrets ?? [];
|
||||
const prefix = randomUUID().slice(0, 8);
|
||||
let next = 0;
|
||||
let ready = false;
|
||||
const write = (event: TimingEvent) => {
|
||||
try {
|
||||
if (!ready) { mkdirSync(dirname(path), { recursive: true }); ready = true; }
|
||||
appendFileSync(path, `${JSON.stringify(event)}\n`);
|
||||
} catch { /* Best effort. */ }
|
||||
};
|
||||
const build = (labels: TimingLabels): Timings => {
|
||||
const tagged = { ...(labels.side ? { side: labels.side } : {}), ...(labels.pass ? { pass: labels.pass } : {}) };
|
||||
const span = (phase: TimingPhase, attributes?: TimingAttributes): SpanEnd => {
|
||||
const id = `${prefix}-${next++}`;
|
||||
const started = now();
|
||||
const opened = safeAttributes(attributes, secrets);
|
||||
write({ type: "start", id, phase, at: started, ...tagged, ...(opened ? { attributes: opened } : {}) });
|
||||
let ended = false;
|
||||
return (outcome = "ok", more) => {
|
||||
if (ended) return;
|
||||
ended = true;
|
||||
// The end repeats what the span opened with, so each line reads on its own.
|
||||
const closed = safeAttributes(more ? { ...attributes, ...more } : attributes, secrets);
|
||||
write({ type: "end", id, phase, at: now(), ms: Math.max(0, now() - started), outcome, ...tagged, ...(closed ? { attributes: closed } : {}) });
|
||||
};
|
||||
};
|
||||
return {
|
||||
span,
|
||||
measure: (phase, run, attributes) => {
|
||||
const end = span(phase, attributes);
|
||||
const fail = (error: unknown) => {
|
||||
const { outcome, code } = failure(error);
|
||||
end(outcome, code ? { code } : undefined);
|
||||
};
|
||||
let result;
|
||||
try { result = run(); } catch (error) { fail(error); throw error; }
|
||||
if (result instanceof Promise) return result.then(value => { end(); return value; }, (error: unknown) => { fail(error); throw error; }) as typeof result;
|
||||
end();
|
||||
return result;
|
||||
},
|
||||
record: event => {
|
||||
const cleaned = Object.fromEntries(Object.entries(event).map(([key, value]) => [key, typeof value === "string" && key !== "type" ? safeText(value, secrets) : value]));
|
||||
write({ ...cleaned as RecordedEvent, at: now(), ...tagged });
|
||||
},
|
||||
labelled: more => build({ ...labels, ...Object.fromEntries(Object.entries(more).filter(([, value]) => value !== undefined)) }),
|
||||
};
|
||||
};
|
||||
return build(options.labels ?? {});
|
||||
}
|
||||
|
||||
/**
|
||||
* Consecutive phases of one flow (plan, preflight, capture, compare, report): entering a phase ends the one before it
|
||||
* as `ok`; `end` closes the current one with how the flow ended.
|
||||
*/
|
||||
export function phaseSequence(timings: Timings): { enter(phase: TimingPhase): void; end(outcome?: TimingOutcome, code?: string): void } {
|
||||
let current: SpanEnd | undefined;
|
||||
return {
|
||||
enter: phase => { current?.(); current = timings.span(phase); },
|
||||
end: (outcome = "ok", code) => { current?.(outcome, code ? { code } : undefined); current = undefined; },
|
||||
};
|
||||
}
|
||||
|
||||
/** Runs a synchronous call that can block for minutes in a span, telling `notice` (when there is one) while it runs. */
|
||||
export function blockingCall<T>(timings: Timings, notice: BlockingNotice | undefined, phase: TimingPhase, boundMs: number, run: () => T): T {
|
||||
const done = notice?.(phase, boundMs);
|
||||
try { return timings.measure(phase, run, { boundMs }); }
|
||||
finally { done?.(); }
|
||||
}
|
||||
|
||||
/** Prints the first line at once, then at most one every `intervalMs`: a wait's heartbeat, driven by its own poll loop. */
|
||||
export function throttledProgress(progress: Progress, options: { now?: () => number; intervalMs?: number } = {}): Progress {
|
||||
const now = options.now ?? Date.now;
|
||||
const interval = options.intervalMs ?? 60_000;
|
||||
let last: number | undefined;
|
||||
return message => {
|
||||
const at = now();
|
||||
if (last !== undefined && at - last < interval) return;
|
||||
last = at;
|
||||
progress(message);
|
||||
};
|
||||
}
|
||||
|
||||
/** The Actions run's page, from the server and repository the runner names and a numeric run id. */
|
||||
export function githubRunLink(environment: NodeJS.ProcessEnv, run: number | string): string | undefined {
|
||||
const server = environment.GITHUB_SERVER_URL ?? "https://github.com";
|
||||
const repository = environment.GITHUB_REPOSITORY ?? "";
|
||||
if (!/^\d{1,20}$/.test(String(run)) || !/^[\w.-]+\/[\w.-]+$/.test(repository) || !/^https:\/\/[\w.-]+(?::\d+)?$/.test(server)) return undefined;
|
||||
return `${server}/${repository}/actions/runs/${run}`;
|
||||
}
|
||||
|
||||
const EAS_PAGE = /^\/accounts\/([\w.-]{1,100})\/projects\/([\w.-]{1,100})\/(workflows|builds)\/([A-Za-z0-9-]{1,128})\/?$/;
|
||||
|
||||
/**
|
||||
* An expo.dev workflow-run or build page, rebuilt from the parts of `value` that name it, or nothing. eas-cli prints
|
||||
* these links; this keeps a query or a fragment it might carry from ever being written out.
|
||||
*/
|
||||
export function easPageLink(value: string | undefined, kind: "workflows" | "builds"): string | undefined {
|
||||
// A link at the end of a sentence ("See logs: https://…/workflows/01AB.") brings its punctuation along.
|
||||
const trimmed = value?.replace(/[.,;:!?)\]'"]+$/, "");
|
||||
if (!trimmed || !URL.canParse(trimmed)) return undefined;
|
||||
const url = new URL(trimmed);
|
||||
const match = EAS_PAGE.exec(url.pathname);
|
||||
if (url.protocol !== "https:" || url.hostname !== "expo.dev" || url.port || url.username || url.password || !match || match[3] !== kind) return undefined;
|
||||
return `https://expo.dev/accounts/${match[1]}/projects/${match[2]}/${kind}/${match[4]}`;
|
||||
}
|
||||
|
||||
/** "850 ms", "42 s", "2 min 14 s". */
|
||||
export function formatDuration(ms: number): string {
|
||||
if (ms < 1000) return `${Math.round(ms)} ms`;
|
||||
const seconds = Math.round(ms / 1000);
|
||||
if (seconds < 60) return `${seconds} s`;
|
||||
const minutes = Math.floor(seconds / 60);
|
||||
return seconds % 60 ? `${minutes} min ${seconds % 60} s` : `${minutes} min`;
|
||||
}
|
||||
|
||||
function readEvents(jsonl: string): TimingEvent[] {
|
||||
return jsonl.split("\n").flatMap(line => {
|
||||
if (!line.trim()) return [];
|
||||
try {
|
||||
const value = JSON.parse(line) as TimingEvent;
|
||||
return value && typeof value === "object" && typeof value.type === "string" && typeof value.at === "number" ? [value] : [];
|
||||
} catch { return []; }
|
||||
});
|
||||
}
|
||||
|
||||
const markdownCell = (value: string) => value.replace(/[|\\`*_[\]<>]/g, character => `\\${character}`);
|
||||
const percentile = (sorted: readonly number[], p: number) => sorted[Math.min(sorted.length - 1, Math.max(0, Math.ceil(p * sorted.length) - 1))]!;
|
||||
|
||||
/** Rows each section of the summary keeps, so a long run cannot crowd out another section. */
|
||||
const SUMMARY_ROWS = { phases: 24, slowest: 3, steps: 12, unfinished: 8 };
|
||||
|
||||
/**
|
||||
* The job summary's table: what each phase took per side and pass (spans overlap, so their sum exceeds the job's
|
||||
* wall time), the routes, what the baseline job spent its time on, and spans that never ended.
|
||||
*/
|
||||
export function renderTimingsSummary(jsonl: string): string {
|
||||
const events = readEvents(jsonl);
|
||||
if (!events.length) return "";
|
||||
const header = events.find(event => event.type === "run") as Extract<TimingEvent, { type: "run" }> | undefined;
|
||||
const finish = [...events].reverse().find(event => event.type === "finish") as Extract<TimingEvent, { type: "finish" }> | undefined;
|
||||
const ends = events.filter((event): event is Extract<TimingEvent, { type: "end" }> => event.type === "end");
|
||||
const ended = new Set(ends.map(event => event.id));
|
||||
const unfinished = events.filter((event): event is Extract<TimingEvent, { type: "start" }> => event.type === "start" && !ended.has(event.id));
|
||||
const first = Math.min(...events.map(event => event.at));
|
||||
const last = Math.max(...events.map(event => event.at));
|
||||
const label = (event: { side?: string; pass?: string }) => [event.side, event.pass].filter(Boolean).join(" · ") || "—";
|
||||
|
||||
const lines = [`### Explore capture timings${header?.target ? ` · ${markdownCell(header.target)}` : ""}`, ""];
|
||||
lines.push(`${formatDuration(last - first)} from the first event to the last${finish ? `; ${finish.outcome}${finish.code ? ` (${markdownCell(finish.code)})` : ""}` : "; no finish recorded"}. Phases overlap, so they add up to more.`, "");
|
||||
|
||||
const groups = new Map<string, { phase: TimingPhase; who: string; count: number; total: number; longest: number; failed: number }>();
|
||||
for (const event of ends) {
|
||||
if (event.phase === "route") continue;
|
||||
const key = `${event.phase}\0${label(event)}`;
|
||||
const group = groups.get(key) ?? { phase: event.phase, who: label(event), count: 0, total: 0, longest: 0, failed: 0 };
|
||||
group.count += 1; group.total += event.ms; group.longest = Math.max(group.longest, event.ms);
|
||||
if (event.outcome !== "ok") group.failed += 1;
|
||||
groups.set(key, group);
|
||||
}
|
||||
const rows = [...groups.values()].sort((a, b) => b.total - a.total);
|
||||
if (rows.length) {
|
||||
lines.push("| Phase | Side | Count | Total | Longest | Not ok |", "| --- | --- | --: | --: | --: | --: |");
|
||||
for (const row of rows.slice(0, SUMMARY_ROWS.phases)) {
|
||||
lines.push(`| ${row.phase} | ${markdownCell(row.who)} | ${row.count} | ${formatDuration(row.total)} | ${formatDuration(row.longest)} | ${row.failed || ""} |`);
|
||||
}
|
||||
if (rows.length > SUMMARY_ROWS.phases) lines.push(`| … ${rows.length - SUMMARY_ROWS.phases} more in timings.jsonl | | | | | |`);
|
||||
lines.push("");
|
||||
}
|
||||
|
||||
const routes = ends.filter(event => event.phase === "route");
|
||||
if (routes.length) {
|
||||
const sorted = routes.map(event => event.ms).sort((a, b) => a - b);
|
||||
const slowest = [...routes].sort((a, b) => b.ms - a.ms).slice(0, SUMMARY_ROWS.slowest)
|
||||
.map(event => `${markdownCell(String(event.attributes?.route ?? "?"))} ${formatDuration(event.ms)}`);
|
||||
lines.push(`**Routes:** ${routes.length}, median ${formatDuration(percentile(sorted, 0.5))}, p90 ${formatDuration(percentile(sorted, 0.9))}; slowest ${slowest.join(", ")}.`, "");
|
||||
}
|
||||
|
||||
const steps = events.filter((event): event is Extract<TimingEvent, { type: "baseline-step" }> => event.type === "baseline-step");
|
||||
if (steps.length) {
|
||||
lines.push("**The baseline job's steps while this review waited for it:**", "");
|
||||
for (const step of steps.slice(0, SUMMARY_ROWS.steps)) lines.push(`- ${markdownCell(step.name)}: ${formatDuration(step.ms)} (${markdownCell(step.conclusion)})`);
|
||||
lines.push("");
|
||||
}
|
||||
|
||||
if (unfinished.length) {
|
||||
lines.push(`**Never finished** (the job ended first): ${unfinished.slice(0, SUMMARY_ROWS.unfinished)
|
||||
.map(event => `${event.phase}${event.side ? ` (${markdownCell(label(event))})` : ""}, ${formatDuration(last - event.at)}+`).join("; ")}.`, "");
|
||||
}
|
||||
return `${lines.join("\n")}\n`;
|
||||
}
|
||||
|
||||
/** Where a CI job's timings go: the diagnostics folder every capture job uploads `if: always()`. None outside Actions. */
|
||||
export function timingsPathFor(environment: NodeJS.ProcessEnv): string | undefined {
|
||||
return environment.GITHUB_ACTIONS === "true" && environment.RUNNER_TEMP ? resolve(environment.RUNNER_TEMP, "explore-diagnostics", "timings.jsonl") : undefined;
|
||||
}
|
||||
|
||||
/**
|
||||
* Appends the job's timings table to its summary, once per job: the capture command does when it ends, and
|
||||
* `ci:after-capture` does for a capture that was stopped before it could (a second signal ends it at once).
|
||||
*/
|
||||
export async function appendTimingsSummary(environment: NodeJS.ProcessEnv = process.env): Promise<boolean> {
|
||||
const path = timingsPathFor(environment);
|
||||
if (!path || !environment.GITHUB_STEP_SUMMARY) return false;
|
||||
const mark = `${path}.summarized`;
|
||||
if (await readFile(mark).then(() => true, () => false)) return false;
|
||||
const summary = renderTimingsSummary(await readFile(path, "utf8").catch(() => ""));
|
||||
if (!summary) return false;
|
||||
await appendFile(environment.GITHUB_STEP_SUMMARY, `${summary}\n`);
|
||||
await writeFile(mark, "");
|
||||
return true;
|
||||
}
|
||||
@@ -85,10 +85,20 @@ jobs:
|
||||
- *install-explore
|
||||
- name: Install the launch recording decoder
|
||||
shell: bash
|
||||
# Launch recordings (capture.launch) are decoded with ffmpeg; GitHub's Ubuntu runners do not ship it.
|
||||
# Launch recordings (capture.launch) are decoded with ffmpeg; GitHub's Ubuntu runners do not ship it. A package
|
||||
# mirror can stall without failing, so each apt-get call has network timeouts and a time limit, and a stalled
|
||||
# attempt is tried once more: the step fails in minutes rather than holding the job to its timeout.
|
||||
timeout-minutes: 10
|
||||
run: |
|
||||
set -euo pipefail
|
||||
command -v ffmpeg > /dev/null || { sudo apt-get update -qq && sudo apt-get install -y -qq --no-install-recommends ffmpeg > /dev/null; }
|
||||
if ! command -v ffmpeg > /dev/null; then
|
||||
apt=(sudo apt-get -qq -o Acquire::Retries=3 -o Acquire::http::Timeout=30 -o Acquire::https::Timeout=30 -o DPkg::Lock::Timeout=120)
|
||||
for attempt in 1 2; do
|
||||
if timeout 120 "${apt[@]}" update && timeout 120 "${apt[@]}" install -y --no-install-recommends ffmpeg > /dev/null; then break; fi
|
||||
if [ "$attempt" = 2 ]; then echo '::error title=LAUNCH_DECODER_INSTALL_FAILED::apt-get could not install ffmpeg; rerun the job.'; exit 1; fi
|
||||
echo "::warning title=LAUNCH_DECODER_INSTALL_RETRY::apt-get did not install ffmpeg on attempt $attempt; trying again."
|
||||
done
|
||||
fi
|
||||
ffmpeg -version | head -1
|
||||
- name: Verify deterministic source planning
|
||||
shell: bash
|
||||
|
||||
@@ -122,10 +122,20 @@ jobs:
|
||||
- *install-explore
|
||||
- name: Install the launch recording decoder
|
||||
shell: bash
|
||||
# Launch recordings (capture.launch) are decoded with ffmpeg; GitHub's Ubuntu runners do not ship it.
|
||||
# Launch recordings (capture.launch) are decoded with ffmpeg; GitHub's Ubuntu runners do not ship it. A package
|
||||
# mirror can stall without failing, so each apt-get call has network timeouts and a time limit, and a stalled
|
||||
# attempt is tried once more: the step fails in minutes rather than holding the job to its timeout.
|
||||
timeout-minutes: 10
|
||||
run: |
|
||||
set -euo pipefail
|
||||
command -v ffmpeg > /dev/null || { sudo apt-get update -qq && sudo apt-get install -y -qq --no-install-recommends ffmpeg > /dev/null; }
|
||||
if ! command -v ffmpeg > /dev/null; then
|
||||
apt=(sudo apt-get -qq -o Acquire::Retries=3 -o Acquire::http::Timeout=30 -o Acquire::https::Timeout=30 -o DPkg::Lock::Timeout=120)
|
||||
for attempt in 1 2; do
|
||||
if timeout 120 "${apt[@]}" update && timeout 120 "${apt[@]}" install -y --no-install-recommends ffmpeg > /dev/null; then break; fi
|
||||
if [ "$attempt" = 2 ]; then echo '::error title=LAUNCH_DECODER_INSTALL_FAILED::apt-get could not install ffmpeg; rerun the job.'; exit 1; fi
|
||||
echo "::warning title=LAUNCH_DECODER_INSTALL_RETRY::apt-get did not install ffmpeg on attempt $attempt; trying again."
|
||||
done
|
||||
fi
|
||||
ffmpeg -version | head -1
|
||||
- name: Verify deterministic source planning
|
||||
env:
|
||||
|
||||
@@ -111,10 +111,20 @@ jobs:
|
||||
with: { ref: '${{ steps.pr.outputs.head }}', path: app-head, fetch-depth: 0, persist-credentials: false }
|
||||
- name: Install the launch recording decoder
|
||||
shell: bash
|
||||
# Launch recordings (capture.launch) are decoded with ffmpeg; GitHub's Ubuntu runners do not ship it.
|
||||
# Launch recordings (capture.launch) are decoded with ffmpeg; GitHub's Ubuntu runners do not ship it. A package
|
||||
# mirror can stall without failing, so each apt-get call has network timeouts and a time limit, and a stalled
|
||||
# attempt is tried once more: the step fails in minutes rather than holding the job to its timeout.
|
||||
timeout-minutes: 10
|
||||
run: |
|
||||
set -euo pipefail
|
||||
command -v ffmpeg > /dev/null || { sudo apt-get update -qq && sudo apt-get install -y -qq --no-install-recommends ffmpeg > /dev/null; }
|
||||
if ! command -v ffmpeg > /dev/null; then
|
||||
apt=(sudo apt-get -qq -o Acquire::Retries=3 -o Acquire::http::Timeout=30 -o Acquire::https::Timeout=30 -o DPkg::Lock::Timeout=120)
|
||||
for attempt in 1 2; do
|
||||
if timeout 120 "${apt[@]}" update && timeout 120 "${apt[@]}" install -y --no-install-recommends ffmpeg > /dev/null; then break; fi
|
||||
if [ "$attempt" = 2 ]; then echo '::error title=LAUNCH_DECODER_INSTALL_FAILED::apt-get could not install ffmpeg; rerun the job.'; exit 1; fi
|
||||
echo "::warning title=LAUNCH_DECODER_INSTALL_RETRY::apt-get did not install ffmpeg on attempt $attempt; trying again."
|
||||
done
|
||||
fi
|
||||
ffmpeg -version | head -1
|
||||
- name: Verify deterministic source planning
|
||||
env:
|
||||
|
||||
@@ -2342,6 +2342,18 @@ test("on a phone, a Screens card's screenshot keeps its height while it loads an
|
||||
assert.deepEqual(errors, []);
|
||||
});
|
||||
|
||||
test("the Screens filmstrip shows a downloaded report's screenshots, resolved as the grid's are", { timeout: 60_000 }, async t => {
|
||||
const { bytes } = await changedScreensArchive(3);
|
||||
const { page, errors } = await harness(t, bytes, { app: true, open: false });
|
||||
await chooseFile(page, bytes);
|
||||
await expect(page.locator(".app-shell")).toBeVisible();
|
||||
await page.goto(`${page.url().split("#")[0]}#/screens?layout=filmstrip`);
|
||||
const middle = page.locator(".screens-strip-frame.focused img");
|
||||
await expect(middle).toHaveAttribute("data-screenshot-state", "ready");
|
||||
assert.match(await middle.getAttribute("src"), /^blob:/);
|
||||
assert.deepEqual(errors, []);
|
||||
});
|
||||
|
||||
test("a target switch blanks every card whose screenshot differs, never showing the other target's picture, and switching back reuses the kept pictures", { timeout: 90_000 }, async t => {
|
||||
const runtime = { platform: "android", platforms: ["ios", "android"] };
|
||||
const android = await changedScreensArchive(3, { seed: 1, runtime });
|
||||
|
||||
@@ -453,7 +453,8 @@ test("a fold tried during a find changes nothing: the tree's own folds come back
|
||||
await expect(other).toHaveAttribute("aria-expanded", "true");
|
||||
await field.press("Escape");
|
||||
await field.press("Escape");
|
||||
await expect(field).toHaveCount(0);
|
||||
await expect(field).toHaveValue("");
|
||||
await expect(field).not.toBeFocused();
|
||||
await expect(folder).toHaveAttribute("aria-expanded", "false");
|
||||
await expect(other).toHaveAttribute("aria-expanded", "true");
|
||||
|
||||
|
||||
+384
-12
@@ -1402,6 +1402,325 @@ test("→ steps the Screens cards right after Screens is opened from the toolbar
|
||||
await expect(grid.locator(`.screens-cell[data-screen-id="${expected}"] .screen-screenshot-card`)).toHaveClass(/selected/);
|
||||
});
|
||||
|
||||
test("the Screens sidebar is headed by its find field with fold-all beside it, and Changed / All sits under it only when there are changes", async ({ page }) => {
|
||||
// The fixture server's own report has no baseline, so no changes.
|
||||
await page.goto("/screens");
|
||||
const tree = page.getByRole("main", { name: "Screens" }).locator(".screens-tree");
|
||||
const head = tree.locator(".screens-tree-head");
|
||||
const field = head.getByRole("searchbox", { name: "Find screens" });
|
||||
await expect(field).toBeVisible();
|
||||
await expect(field).toHaveAttribute("placeholder", "Search");
|
||||
await expect(head.getByRole("button", { name: "Collapse all" })).toBeVisible();
|
||||
await expect(tree.locator(".screens-filter")).toHaveCount(0);
|
||||
// Nothing sits above the field.
|
||||
const treeBox = (await tree.boundingBox())!;
|
||||
expect((await head.boundingBox())!.y - treeBox.y).toBeLessThan(16);
|
||||
|
||||
await serveWorkspace(page);
|
||||
await page.goto("/screens");
|
||||
const filter = tree.locator(".screens-filter");
|
||||
await expect(filter).toBeVisible();
|
||||
// Under the head, as wide as it.
|
||||
const headBox = (await head.boundingBox())!;
|
||||
const filterBox = (await filter.boundingBox())!;
|
||||
expect(filterBox.y).toBeGreaterThanOrEqual(headBox.y + headBox.height);
|
||||
expect(Math.abs(filterBox.width - headBox.width)).toBeLessThan(2);
|
||||
});
|
||||
|
||||
test("Screens' filmstrip: switched from the corner switch, stepped with the arrows and clicks, opened by a double-click, left with Esc, and remembered", async ({ page }) => {
|
||||
await serveWorkspace(page);
|
||||
await page.goto("/screens");
|
||||
const view = page.getByRole("main", { name: "Screens" });
|
||||
await view.getByRole("button", { name: /^All/ }).click();
|
||||
const cells = view.locator(".screens-grid .screens-cell");
|
||||
const ids = await cells.evaluateAll(elements => elements.map(element => element.getAttribute("data-screen-id")!));
|
||||
expect(ids.length).toBeGreaterThan(2);
|
||||
const layouts = page.getByRole("group", { name: "Screens layout" });
|
||||
await expect(layouts.getByRole("button", { name: "Grid" })).toHaveAttribute("aria-pressed", "true");
|
||||
|
||||
// The switch at the top right opens the filmstrip at the first screen, with nothing selected yet.
|
||||
await layouts.getByRole("button", { name: "Filmstrip" }).click();
|
||||
await expect(page).toHaveURL(/[?&]layout=filmstrip/);
|
||||
const strip = view.getByRole("region", { name: "Filmstrip" });
|
||||
const middle = strip.locator(".screens-strip-frame.focused");
|
||||
await expect(middle).toHaveAttribute("data-screen-id", ids[0]!);
|
||||
await expect(cells).toHaveCount(0);
|
||||
// The sidebar is folded, and `/` opens it with the find field focused.
|
||||
await expect(view.locator(".screens-tree")).toHaveCount(0);
|
||||
|
||||
// In the find field, ↓ and ↑ step from the screen in the middle too; Esc then hands the keyboard back.
|
||||
await page.keyboard.press("/");
|
||||
const field = view.getByRole("searchbox", { name: "Find screens" });
|
||||
await expect(field).toBeFocused();
|
||||
await page.keyboard.press("ArrowDown");
|
||||
await expect(middle).toHaveAttribute("data-screen-id", ids[1]!);
|
||||
await page.keyboard.press("ArrowUp");
|
||||
await expect(middle).toHaveAttribute("data-screen-id", ids[0]!);
|
||||
await page.keyboard.press("Escape");
|
||||
await expect(field).not.toBeFocused();
|
||||
await expect(strip).toBeVisible();
|
||||
|
||||
// → steps the middle frame through the screens in the grid's order.
|
||||
await page.keyboard.press("ArrowRight");
|
||||
await expect(middle).toHaveAttribute("data-screen-id", ids[1]!);
|
||||
await expect(middle.locator(".screens-strip-target")).toBeFocused();
|
||||
await page.keyboard.press("ArrowRight");
|
||||
await expect(middle).toHaveAttribute("data-screen-id", ids[2]!);
|
||||
await page.keyboard.press("ArrowLeft");
|
||||
await expect(middle).toHaveAttribute("data-screen-id", ids[1]!);
|
||||
// A neighbour comes to the middle when clicked, without opening the Inspector.
|
||||
const inspector = page.getByRole("complementary", { name: "Inspector panel" });
|
||||
await strip.locator(`.screens-strip-frame[data-screen-id="${ids[2]}"] .screens-strip-target`).click();
|
||||
await expect(middle).toHaveAttribute("data-screen-id", ids[2]!);
|
||||
await expect(inspector).toBeHidden();
|
||||
|
||||
// The switch's Grid goes back to the grid, keeping the selection.
|
||||
await layouts.getByRole("button", { name: "Grid" }).click();
|
||||
await expect(page).not.toHaveURL(/layout=/);
|
||||
await expect(view.locator(`.screens-cell[data-screen-id="${ids[2]}"] .screen-screenshot-card`)).toHaveClass(/selected/);
|
||||
|
||||
// A double-click on a card opens it in the filmstrip. Its first click opens the Inspector, which narrows the grid: the
|
||||
// last card of the first row moves before the second click lands, and it is still that card that opens.
|
||||
await page.keyboard.press("Escape");
|
||||
await expect(inspector).toBeHidden();
|
||||
const tops = await cells.evaluateAll(elements => elements.map(element => Math.round(element.getBoundingClientRect().top)));
|
||||
const last = ids[tops.filter(top => top === tops[0]).length - 1]!;
|
||||
const box = (await view.locator(`.screens-cell[data-screen-id="${last}"] .screen-screenshot-target`).boundingBox())!;
|
||||
const at = { x: box.x + box.width / 2, y: box.y + box.height / 2 };
|
||||
await page.mouse.click(at.x, at.y);
|
||||
await expect(inspector).toBeVisible();
|
||||
// The second click of the pair, where the pointer still is.
|
||||
await page.mouse.down({ clickCount: 2 });
|
||||
await page.mouse.up({ clickCount: 2 });
|
||||
await expect(middle).toHaveAttribute("data-screen-id", last);
|
||||
// In the filmstrip the Inspector opens only from a click on the middle screen, so the one the first click opened closes.
|
||||
await expect(inspector).toBeHidden();
|
||||
|
||||
// With the sidebar folded, the middle screen is at the centre of the canvas.
|
||||
await expect(view.getByRole("button", { name: "Show sidebar" })).toBeVisible();
|
||||
const centre = await middle.evaluate(element => { const box = element.getBoundingClientRect(); return box.left + box.width / 2; });
|
||||
expect(Math.abs(centre - page.viewportSize()!.width / 2)).toBeLessThan(2);
|
||||
|
||||
// A sideways trackpad swipe moves the strip with it, and a short one springs back when it ends; a wheel notch steps.
|
||||
const lastAt = ids.indexOf(last);
|
||||
await middle.hover();
|
||||
// Measured in the page two frames after the event: the swipe ends, and the strip settles, 100 ms after the last one.
|
||||
const moved = await middle.evaluate(async element => {
|
||||
element.dispatchEvent(new WheelEvent("wheel", { deltaX: -40, bubbles: true, cancelable: true }));
|
||||
await new Promise(resolve => requestAnimationFrame(() => requestAnimationFrame(resolve)));
|
||||
const box = element.getBoundingClientRect();
|
||||
return { centre: box.left + box.width / 2, swiping: element.parentElement!.classList.contains("swiping") };
|
||||
});
|
||||
expect(moved.swiping).toBe(true);
|
||||
expect(moved.centre - centre).toBeGreaterThan(20);
|
||||
expect(moved.centre - centre).toBeLessThan(60);
|
||||
await expect(strip.locator(".screens-strip-stage")).not.toHaveClass(/swiping/);
|
||||
await expect(middle).toHaveAttribute("data-screen-id", last);
|
||||
await expect.poll(() => middle.evaluate(element => { const box = element.getBoundingClientRect(); return Math.round(box.left + box.width / 2); }))
|
||||
.toBe(Math.round(centre));
|
||||
await page.mouse.wheel(0, -100);
|
||||
await expect(middle).toHaveAttribute("data-screen-id", ids[lastAt - 1]!);
|
||||
await page.waitForTimeout(300);
|
||||
await page.mouse.wheel(100, 0);
|
||||
await expect(middle).toHaveAttribute("data-screen-id", last);
|
||||
|
||||
// A click on the middle screen opens the Inspector; Esc closes it first, then steps back out to the grid.
|
||||
await middle.locator(".screens-strip-target").click();
|
||||
await expect(inspector).toBeVisible();
|
||||
await page.keyboard.press("Escape");
|
||||
await expect(inspector).toBeHidden();
|
||||
await expect(strip).toBeVisible();
|
||||
await page.keyboard.press("Escape");
|
||||
await expect(strip).toHaveCount(0);
|
||||
await expect(view.locator(`.screens-cell[data-screen-id="${last}"] .screen-screenshot-card`)).toHaveClass(/selected/);
|
||||
|
||||
// The layout is remembered for the report: Screens opens in the filmstrip again after a visit to the Map.
|
||||
await layouts.getByRole("button", { name: "Filmstrip" }).click();
|
||||
await chooseCanvasView(page, "Map");
|
||||
await chooseCanvasView(page, "Screens");
|
||||
await expect(page).toHaveURL(/[?&]layout=filmstrip/);
|
||||
await expect(page.getByRole("region", { name: "Filmstrip" })).toBeVisible();
|
||||
});
|
||||
|
||||
test("Screens' filmstrip keeps Changed across a layout switch, opens only from a screenshot, and is remembered through Search and links", async ({ page }) => {
|
||||
await serveWorkspace(page);
|
||||
await page.goto("/screens");
|
||||
const view = page.getByRole("main", { name: "Screens" });
|
||||
const layouts = page.getByRole("group", { name: "Screens layout" });
|
||||
const strip = view.getByRole("region", { name: "Filmstrip" });
|
||||
const cells = view.locator(".screens-grid .screens-cell");
|
||||
const ids = () => cells.evaluateAll(elements => elements.map(element => element.getAttribute("data-screen-id")!));
|
||||
|
||||
// A double-click on a card's route copies a link and selects nothing, so it does not open the filmstrip.
|
||||
await view.getByRole("button", { name: /^All/ }).click();
|
||||
await cells.nth(1).locator(".screen-node-title").dblclick();
|
||||
await expect(strip).toHaveCount(0);
|
||||
// A click on one card and then a quick double-click on another opens the other.
|
||||
const [firstId, secondId] = await ids();
|
||||
await view.locator(`.screens-cell[data-screen-id="${firstId}"] .screen-screenshot-target`).click();
|
||||
await view.locator(`.screens-cell[data-screen-id="${secondId}"] .screen-screenshot-target`).dblclick();
|
||||
await expect(strip.locator(".screens-strip-frame.focused")).toHaveAttribute("data-screen-id", secondId!);
|
||||
await layouts.getByRole("button", { name: "Grid" }).click();
|
||||
await page.keyboard.press("Escape");
|
||||
|
||||
// A pick that Changed hides stays picked across a switch, and Changed stays on.
|
||||
const all = await ids();
|
||||
await view.getByRole("button", { name: /^Changed/ }).click();
|
||||
const changed = await ids();
|
||||
const hidden = all.find(id => !changed.includes(id));
|
||||
test.skip(!hidden, "the fixture has no unchanged screen");
|
||||
await view.getByRole("button", { name: /^All/ }).click();
|
||||
await view.locator(`.screens-cell[data-screen-id="${hidden}"] .screen-screenshot-target`).click();
|
||||
await page.keyboard.press("Escape");
|
||||
await view.getByRole("button", { name: /^Changed/ }).click();
|
||||
await layouts.getByRole("button", { name: "Filmstrip" }).click();
|
||||
// The sidebar folds away with Changed in it; the button left in its place says the screens are narrowed, and Changed
|
||||
// is still on behind it.
|
||||
const show = view.getByRole("button", { name: "Show sidebar, showing changed screens only" });
|
||||
await expect(show).toBeVisible();
|
||||
await show.click();
|
||||
await expect(view.getByRole("button", { name: "Hide sidebar" })).toBeFocused();
|
||||
await expect(view.getByRole("button", { name: /^Changed/ })).toHaveAttribute("aria-pressed", "true");
|
||||
// The middle is the nearest changed screen after the hidden pick in the tree, as the grid's arrows step from it.
|
||||
const at = all.indexOf(hidden!);
|
||||
const nearest = all.slice(at + 1).find(id => changed.includes(id)) ?? all.slice(0, at).reverse().find(id => changed.includes(id));
|
||||
await expect(strip.locator(".screens-strip-frame.focused")).toHaveAttribute("data-screen-id", nearest!);
|
||||
// A click on the page around the strip keeps the screen in the middle.
|
||||
await view.click({ position: { x: 600, y: 4 } });
|
||||
await expect(strip.locator(".screens-strip-frame.focused")).toHaveAttribute("data-screen-id", nearest!);
|
||||
// Folded again by hand, the keyboard moves to the button left in its place.
|
||||
await view.getByRole("button", { name: "Hide sidebar" }).click();
|
||||
await expect(show).toBeFocused();
|
||||
|
||||
// Search opens Screens in the remembered layout, and landing there does not forget it.
|
||||
await chooseCanvasView(page, "Map");
|
||||
await page.getByRole("toolbar", { name: "Canvas tools" }).getByRole("button", { name: "Search", exact: true }).click();
|
||||
const search = page.getByRole("dialog", { name: "Search Explore" });
|
||||
await search.getByRole("combobox").fill("/current-profile");
|
||||
await search.getByRole("option").filter({ hasText: "/current-profile" }).first().click();
|
||||
await expect(page).toHaveURL(/\/screens.*[?&]layout=filmstrip/);
|
||||
await expect(strip.locator(".screens-strip-frame.focused")).toHaveAttribute("data-screen-id", "current-profile");
|
||||
|
||||
// Switched back to the grid, Screens opens in the grid; a link that opens the filmstrip is remembered again.
|
||||
await layouts.getByRole("button", { name: "Grid" }).click();
|
||||
await chooseCanvasView(page, "Map");
|
||||
await chooseCanvasView(page, "Screens");
|
||||
await expect(page).not.toHaveURL(/layout=/);
|
||||
await page.goto("/screens?layout=filmstrip");
|
||||
await expect(strip).toBeVisible();
|
||||
await chooseCanvasView(page, "Map");
|
||||
await chooseCanvasView(page, "Screens");
|
||||
await expect(page).toHaveURL(/[?&]layout=filmstrip/);
|
||||
});
|
||||
|
||||
test("Screens' filmstrip gestures: a short flick lands where it carries the strip, and a step made during a swipe is not undone by it", async ({ page }) => {
|
||||
await serveWorkspace(page);
|
||||
await page.goto("/screens");
|
||||
const view = page.getByRole("main", { name: "Screens" });
|
||||
await view.getByRole("button", { name: /^All/ }).click();
|
||||
const ids = await view.locator(".screens-grid .screens-cell").evaluateAll(elements => elements.map(element => element.getAttribute("data-screen-id")!));
|
||||
await page.getByRole("group", { name: "Screens layout" }).getByRole("button", { name: "Filmstrip" }).click();
|
||||
const strip = view.getByRole("region", { name: "Filmstrip" });
|
||||
const middle = strip.locator(".screens-strip-frame.focused");
|
||||
const stage = strip.locator(".screens-strip-stage");
|
||||
await expect(middle).toHaveAttribute("data-screen-id", ids[0]!);
|
||||
const historyLength = await page.evaluate(() => history.length);
|
||||
|
||||
// A finger drags a quarter of a screen and lifts while still moving: the flick carries the strip past halfway, so it
|
||||
// lands on the next screen though the finger never got there.
|
||||
await stage.evaluate(async element => {
|
||||
const box = element.getBoundingClientRect();
|
||||
const y = box.top + box.height / 2, x = box.left + box.width * 0.6;
|
||||
const pitch = (() => {
|
||||
const [a, b] = [...element.querySelectorAll(".screens-strip-frame")].map(frame => { const r = frame.getBoundingClientRect(); return r.left + r.width / 2; });
|
||||
return Math.abs(b! - a!);
|
||||
})();
|
||||
const fire = (type: string, at: number) => element.dispatchEvent(new PointerEvent(type, { pointerId: 9, pointerType: "touch", isPrimary: true,
|
||||
clientX: at, clientY: y, bubbles: true, cancelable: true }));
|
||||
fire("pointerdown", x);
|
||||
const step = pitch / 16;
|
||||
for (let n = 1; n <= 4; n++) { fire("pointermove", x - n * step); await new Promise(resolve => setTimeout(resolve, 16)); }
|
||||
fire("pointerup", x - 4 * step);
|
||||
});
|
||||
await expect(middle).toHaveAttribute("data-screen-id", ids[1]!);
|
||||
await expect(stage).not.toHaveClass(/swiping/);
|
||||
// However many screens a swipe passes, it is one step back.
|
||||
expect(await page.evaluate(() => history.length)).toBe(historyLength + 1);
|
||||
|
||||
// A short wheel swipe whose momentum is still coming in when ← steps back: the arrow's screen stays in the middle,
|
||||
// neither settled over by the swipe nor dragged off by its momentum.
|
||||
await middle.hover();
|
||||
await page.evaluate(() => {
|
||||
const stage = document.querySelector(".screens-strip-stage")!;
|
||||
stage.dispatchEvent(new WheelEvent("wheel", { deltaX: 100, bubbles: true, cancelable: true }));
|
||||
let left = 30;
|
||||
const momentum = setInterval(() => {
|
||||
stage.dispatchEvent(new WheelEvent("wheel", { deltaX: 1, bubbles: true, cancelable: true }));
|
||||
if (--left === 0) clearInterval(momentum);
|
||||
}, 16);
|
||||
});
|
||||
await page.keyboard.press("ArrowLeft");
|
||||
await expect(middle).toHaveAttribute("data-screen-id", ids[0]!);
|
||||
await page.waitForTimeout(900);
|
||||
await expect(middle).toHaveAttribute("data-screen-id", ids[0]!);
|
||||
await expect(stage).not.toHaveClass(/swiping/);
|
||||
// A pinch (a wheel with Control) zooms; it does not move the strip.
|
||||
await page.evaluate(() => document.querySelector(".screens-strip-stage")!.dispatchEvent(new WheelEvent("wheel", { deltaX: 400, ctrlKey: true, bubbles: true, cancelable: true })));
|
||||
await page.waitForTimeout(300);
|
||||
await expect(middle).toHaveAttribute("data-screen-id", ids[0]!);
|
||||
});
|
||||
|
||||
test("Screens' layouts switch with G and E, and the sidebar folds by its own buttons and on each switch to the filmstrip", async ({ page }) => {
|
||||
await serveWorkspace(page);
|
||||
await page.goto("/screens");
|
||||
const view = page.getByRole("main", { name: "Screens" });
|
||||
const tree = view.locator(".screens-tree");
|
||||
const strip = view.getByRole("region", { name: "Filmstrip" });
|
||||
const show = view.getByRole("button", { name: "Show sidebar" });
|
||||
|
||||
// The grid opens with the sidebar; its head folds it away, and the button left in its place opens it again.
|
||||
await expect(tree).toBeVisible();
|
||||
await tree.getByRole("button", { name: "Hide sidebar" }).click();
|
||||
await expect(tree).toHaveCount(0);
|
||||
await show.click();
|
||||
await expect(tree).toBeVisible();
|
||||
|
||||
// E opens the filmstrip, with the sidebar folded.
|
||||
await page.keyboard.press("e");
|
||||
await expect(page).toHaveURL(/[?&]layout=filmstrip/);
|
||||
await expect(strip).toBeVisible();
|
||||
await expect(tree).toHaveCount(0);
|
||||
// G goes back to the grid, with the sidebar open, even though it was opened in the filmstrip.
|
||||
await show.click();
|
||||
await page.keyboard.press("g");
|
||||
await expect(page).not.toHaveURL(/layout=/);
|
||||
await expect(strip).toHaveCount(0);
|
||||
await expect(tree).toBeVisible();
|
||||
// Each switch to the filmstrip folds the sidebar again.
|
||||
await page.keyboard.press("e");
|
||||
await expect(strip).toBeVisible();
|
||||
await expect(tree).toHaveCount(0);
|
||||
|
||||
// A find keeps the sidebar that shows it open on the switch to the filmstrip; folding the sidebar clears the find.
|
||||
await page.keyboard.press("g");
|
||||
const field = tree.getByRole("searchbox", { name: "Find screens" });
|
||||
const firstTitle = (await view.locator(".screens-grid .screens-cell .screen-node-title").first().textContent())!;
|
||||
await field.fill(firstTitle);
|
||||
await field.blur();
|
||||
await page.keyboard.press("e");
|
||||
await expect(strip).toBeVisible();
|
||||
await expect(tree).toBeVisible();
|
||||
await expect(field).toHaveValue(firstTitle);
|
||||
await tree.getByRole("button", { name: "Hide sidebar" }).click();
|
||||
await show.click();
|
||||
await expect(field).toHaveValue("");
|
||||
|
||||
// Elsewhere G and E do nothing.
|
||||
await chooseCanvasView(page, "Map");
|
||||
await page.keyboard.press("e");
|
||||
await expect(page).not.toHaveURL(/\/screens/);
|
||||
});
|
||||
|
||||
test("reuses the Map screenshot card in Screens, with the route under the screenshot at the card's left edge", async ({ page }) => {
|
||||
await serveWorkspace(page);
|
||||
await page.goto("/screens");
|
||||
@@ -5329,6 +5648,56 @@ test.describe("phone layout", () => {
|
||||
await expect(page.getByRole("navigation", { name: "Views" })).toBeVisible();
|
||||
await expect(page.locator(".map-canvas")).toBeVisible();
|
||||
});
|
||||
test("the filmstrip on a phone: switched beside Changed / All, swiped by a finger, and its middle screen opens the Inspector", async ({ page }) => {
|
||||
await serveWorkspace(page);
|
||||
await page.goto("/screens");
|
||||
const view = page.getByRole("main", { name: "Screens" });
|
||||
await view.getByRole("button", { name: /^All/ }).tap();
|
||||
const layouts = view.getByRole("group", { name: "Screens layout" });
|
||||
await expect(layouts.getByRole("button", { name: "Grid" })).toHaveAttribute("aria-pressed", "true");
|
||||
await layouts.getByRole("button", { name: "Filmstrip" }).tap();
|
||||
await expect(page).toHaveURL(/[?&]layout=filmstrip/);
|
||||
const strip = view.getByRole("region", { name: "Filmstrip" });
|
||||
const middle = strip.locator(".screens-strip-frame.focused");
|
||||
const first = await middle.getAttribute("data-screen-id");
|
||||
// The section chips give way to the path above the strip; the Tree still jumps anywhere.
|
||||
await expect(view.locator(".screens-jump-chip:not(.tree)")).toHaveCount(0);
|
||||
await expect(view.getByRole("button", { name: "Tree" })).toBeVisible();
|
||||
await expectNoHorizontalOverflow(page);
|
||||
|
||||
// A finger dragged left moves the strip under it while it is down, and the strip settles on the next screen.
|
||||
const stage = strip.locator(".screens-strip-stage");
|
||||
const dragged = await stage.evaluate(async element => {
|
||||
const box = element.getBoundingClientRect();
|
||||
const y = box.top + box.height / 2, x = box.left + box.width * 0.7;
|
||||
const fire = (type: string, at: number) => element.dispatchEvent(new PointerEvent(type, { pointerId: 7, pointerType: "touch", isPrimary: true,
|
||||
clientX: at, clientY: y, bubbles: true, cancelable: true }));
|
||||
const centre = () => { const frame = element.querySelector(".screens-strip-frame.focused")!.getBoundingClientRect(); return frame.left + frame.width / 2; };
|
||||
const before = centre();
|
||||
fire("pointerdown", x);
|
||||
for (let step = 1; step <= 3; step++) { fire("pointermove", x - step * 20); await new Promise(resolve => setTimeout(resolve, 16)); }
|
||||
await new Promise(resolve => requestAnimationFrame(() => requestAnimationFrame(resolve)));
|
||||
const during = centre();
|
||||
for (let step = 4; step <= 6; step++) { fire("pointermove", x - step * 20); await new Promise(resolve => setTimeout(resolve, 16)); }
|
||||
fire("pointerup", x - 120);
|
||||
return { moved: before - during, swiping: element.classList.contains("swiping") };
|
||||
});
|
||||
expect(dragged.moved).toBeGreaterThan(50);
|
||||
expect(dragged.moved).toBeLessThan(70);
|
||||
await expect(middle).not.toHaveAttribute("data-screen-id", first!);
|
||||
await expect(stage).not.toHaveClass(/swiping/);
|
||||
|
||||
// A tap on the middle screen opens the Inspector; a tap on a neighbour only brings it to the middle.
|
||||
const inspector = page.getByRole("complementary", { name: "Inspector panel" });
|
||||
// The next screen peeks in at the right edge: a tap on the part that shows.
|
||||
const next = strip.locator(".screens-strip-frame.focused + .screens-strip-frame");
|
||||
const nextId = await next.getAttribute("data-screen-id");
|
||||
await next.locator(".screens-strip-target").tap({ position: { x: 12, y: 60 } });
|
||||
await expect(middle).toHaveAttribute("data-screen-id", nextId!);
|
||||
await expect(inspector).toHaveCount(0);
|
||||
await middle.locator(".screens-strip-target").tap();
|
||||
await expect(inspector).toBeVisible();
|
||||
});
|
||||
});
|
||||
|
||||
test("the theme is Auto until the More menu picks one: it follows the system, and a pick outlives a reload", async ({ page }) => {
|
||||
@@ -5612,7 +5981,7 @@ test("in a window too short for it, the More menu scrolls", async ({ page }) =>
|
||||
await expect(page.getByRole("menu", { name: "More" }).getByRole("menuitem", { name: "Keyboard shortcuts" })).toBeInViewport({ ratio: 1 });
|
||||
});
|
||||
|
||||
test("the top right is the camera's alone: fit, center and zoom on the Map, nothing on Screens or Compare", async ({ page }) => {
|
||||
test("the top right holds the camera on the Map, the layout switch on Screens, and nothing on Compare", async ({ page }) => {
|
||||
await page.setViewportSize({ width: 1440, height: 900 });
|
||||
await serveWorkspace(page);
|
||||
await page.goto("/map");
|
||||
@@ -5631,7 +6000,7 @@ test("the top right is the camera's alone: fit, center and zoom on the Map, noth
|
||||
await expect(page).toHaveURL(/\/screens/);
|
||||
await expect(page.locator(".screens-page .screens-cell").first()).toBeVisible();
|
||||
await expect(page.locator(".canvas-camera-controls")).toHaveCount(0);
|
||||
expect(await topRightButtons(page)).toEqual([]);
|
||||
expect(await topRightButtons(page)).toEqual(["Grid", "Filmstrip"]);
|
||||
|
||||
await page.goto("/compare?screen=current-profile");
|
||||
await expect(page.getByRole("region", { name: /^Compare / })).toBeVisible();
|
||||
@@ -5653,13 +6022,13 @@ test("/ finds screens on the Screens page: the tree and the grid narrow to the q
|
||||
.find(segment => segment && titles.filter(title => title.includes(segment)).length < titles.length)!;
|
||||
expect(query).toBeTruthy();
|
||||
|
||||
// Opening the field does not move the tree under it: the head keeps one height in every state.
|
||||
const heading = grid.locator(".screens-tree h2");
|
||||
const headingTop = (await heading.boundingBox())!.y;
|
||||
// Opening the field does not move the tree under it: the field takes the title's row, which keeps one height.
|
||||
const firstRow = treeRows.first();
|
||||
const rowTop = (await firstRow.boundingBox())!.y;
|
||||
await page.keyboard.press("/");
|
||||
const field = grid.getByRole("searchbox", { name: "Find screens" });
|
||||
await expect(field).toBeFocused();
|
||||
expect((await heading.boundingBox())!.y).toBe(headingTop);
|
||||
expect((await firstRow.boundingBox())!.y).toBe(rowTop);
|
||||
await field.fill(query);
|
||||
const matching = titles.filter(title => title.toLowerCase().includes(query.toLowerCase()));
|
||||
await expect(cells).toHaveCount(matching.length);
|
||||
@@ -5690,9 +6059,10 @@ test("/ finds screens on the Screens page: the tree and the grid narrow to the q
|
||||
await field.press("Escape");
|
||||
await expect(field).toHaveValue("");
|
||||
await expect(cells).toHaveCount(all);
|
||||
// A second Esc hands the keyboard back to the page; the field stays, empty, at the head of the tree.
|
||||
await field.press("Escape");
|
||||
await expect(field).toHaveCount(0);
|
||||
await expect(grid.getByRole("button", { name: "Find a screen" })).toBeVisible();
|
||||
await expect(field).not.toBeFocused();
|
||||
await expect(field).toBeVisible();
|
||||
|
||||
// From the Map, "/" opens Screens with the field focused.
|
||||
await chooseCanvasView(page, "Map");
|
||||
@@ -5769,7 +6139,7 @@ test("⌘K steps through its results in the order it shows them, and a command t
|
||||
await expect(page.locator(".changes-menu-body")).toBeFocused();
|
||||
});
|
||||
|
||||
test("a / from the Map opens the find once: Screens opened again from the toolbar comes up without it", async ({ page }) => {
|
||||
test("a / from the Map focuses the find once: Screens opened again from the toolbar comes up with the field unfocused", async ({ page }) => {
|
||||
await serveWorkspace(page);
|
||||
await page.goto("/map");
|
||||
await page.keyboard.press("/");
|
||||
@@ -5777,13 +6147,14 @@ test("a / from the Map opens the find once: Screens opened again from the toolba
|
||||
const field = grid.getByRole("searchbox", { name: "Find screens" });
|
||||
await expect(field).toBeFocused();
|
||||
await field.press("Escape");
|
||||
await expect(field).toHaveCount(0);
|
||||
await expect(field).not.toBeFocused();
|
||||
|
||||
await chooseCanvasView(page, "Map");
|
||||
await chooseCanvasView(page, "Screens");
|
||||
await expect(grid.locator(".screens-grid .screens-cell").first()).toBeVisible();
|
||||
await expect(grid.getByRole("button", { name: "Find a screen" })).toBeVisible();
|
||||
await expect(field).toHaveCount(0);
|
||||
await expect(field).toBeVisible();
|
||||
await expect(field).not.toBeFocused();
|
||||
await expect(field).toHaveValue("");
|
||||
});
|
||||
|
||||
test("the find's keys stay in its field: Return on the clear button clears, and Return while composing text opens nothing", async ({ page }) => {
|
||||
@@ -5866,4 +6237,5 @@ test.describe("a wide Inspector in a short window", () => {
|
||||
await expect.poll(async () => (await frame.boundingBox())!.height).toBeLessThanOrEqual(421);
|
||||
await expect.poll(async () => (await frame.boundingBox())!.height).toBeGreaterThan(300);
|
||||
});
|
||||
|
||||
});
|
||||
@@ -83,6 +83,89 @@ test('head capture starts while the review waits for the baseline, and the waite
|
||||
assert.equal(waitSignal.aborted, true, 'the wait is told to stop once the review is done');
|
||||
});
|
||||
|
||||
test('while base waits for the baseline, the comment names the step the baseline job is in, and the run records its phases', async t => {
|
||||
const f = await fixture(t, 'expo-router');
|
||||
t.mock.method(globalThis, 'fetch', async input => assert.fail(`Unmocked network request: ${input}`));
|
||||
const baseline = await runBaselineCi({ project: f.baseProject, sha: f.baseSha, output: join(f.root, 'baseline'), config: f.config, environment: f.environment,
|
||||
runner: f.runner, now: f.now, sleep: f.sleep, timingsPath: join(f.root, 'baseline-timings.jsonl') });
|
||||
const finished = deferred();
|
||||
const bodies = [];
|
||||
const timingsPath = join(f.root, 'timings.jsonl');
|
||||
let watching;
|
||||
// While head captures, the baseline job moves on to its capture step, then finishes.
|
||||
const runner = request => {
|
||||
if (request.args[0] === 'simulator:start' && watching) {
|
||||
watching.onUpdate({ state: 'in progress', step: 'Capture complete single-commit baseline', stepSince: 0, waitedMs: 60_000 });
|
||||
setImmediate(() => finished.resolve(baseline.directory));
|
||||
}
|
||||
return f.runner(request);
|
||||
};
|
||||
// The waiting status's write is slow: held until the final comment has landed (or 3 s, since serialized writes send
|
||||
// the final one only after it), it must still land before the final comment, not after it.
|
||||
let reviewRendered = false;
|
||||
const finalLanded = deferred();
|
||||
const transport = async (input, init = {}) => {
|
||||
const waiting = init.method === 'PATCH' && String(init.body).includes('base waits for');
|
||||
if (waiting) await Promise.race([finalLanded.promise, new Promise(resolve => setTimeout(resolve, 3000))]);
|
||||
const response = await f.transport(input, init);
|
||||
if (init.method === 'PATCH' && !waiting && reviewRendered) finalLanded.resolve();
|
||||
return response;
|
||||
};
|
||||
await runPublicCi({ baseProject: f.baseProject, headProject: f.headProject, pullRequestPath: f.pullRequestPath, output: join(f.root, 'review'), config: f.config,
|
||||
environment: f.environment, transport, runner, now: f.now, sleep: f.sleep, timingsPath, progressPostMs: 0,
|
||||
onComment: (state, body) => { bodies.push(body); if (state.review) reviewRendered = true; },
|
||||
awaitBaseline: (_signal, watch) => {
|
||||
watching = watch;
|
||||
watch.onUpdate({ state: 'in progress', step: 'Install the launch recording decoder', stepSince: 0, waitedMs: 0 });
|
||||
return finished.promise;
|
||||
} });
|
||||
const waiting = bodies.filter(body => body.includes("base waits for the default branch's baseline (in “Install the launch recording decoder”)"));
|
||||
assert.ok(waiting.length >= 1, bodies.join('\n---\n'));
|
||||
assert.equal(bodies.at(-1).includes('base waits for'), false, 'the comment stops saying so once the wait is over');
|
||||
assert.equal(f.comments.at(-1).includes('base waits for'), false, 'the slow waiting write did not land after the final comment');
|
||||
const events = (await readFile(timingsPath, 'utf8')).trim().split('\n').map(line => JSON.parse(line));
|
||||
assert.equal(events[0].type, 'run');
|
||||
assert.deepEqual(events.at(-1), { ...events.at(-1), type: 'finish', outcome: 'ok' });
|
||||
const ended = events.filter(event => event.type === 'end');
|
||||
const started = events.filter(event => event.type === 'start');
|
||||
assert.deepEqual(started.map(event => event.id).sort(), ended.map(event => event.id).sort(), 'every span the review opened, it closed');
|
||||
const phases = new Set(ended.map(event => `${event.phase}${event.side ? `:${event.side}` : ''}`));
|
||||
for (const phase of ['plan', 'preflight', 'capture', 'compare', 'report', 'baseline-blocked', 'pass:head', 'configuration:head', 'session-start:head', 'route:head']) {
|
||||
assert.ok(phases.has(phase), `${phase} in ${[...phases].join(', ')}`);
|
||||
}
|
||||
const baselineEvents = (await readFile(join(f.root, 'baseline-timings.jsonl'), 'utf8')).trim().split('\n').map(line => JSON.parse(line));
|
||||
assert.ok(baselineEvents.some(event => event.type === 'end' && event.phase === 'pass' && event.side === 'baseline'));
|
||||
assert.deepEqual(baselineEvents.at(-1), { ...baselineEvents.at(-1), type: 'finish', outcome: 'ok' });
|
||||
});
|
||||
|
||||
test('the waiting status is posted when the wait starts and ends, and a step change in between waits its turn', async t => {
|
||||
const f = await fixture(t, 'expo-router');
|
||||
t.mock.method(globalThis, 'fetch', async input => assert.fail(`Unmocked network request: ${input}`));
|
||||
const baseline = await runBaselineCi({ project: f.baseProject, sha: f.baseSha, output: join(f.root, 'baseline'), config: f.config, environment: f.environment, runner: f.runner, now: f.now, sleep: f.sleep });
|
||||
const finished = deferred();
|
||||
let watching;
|
||||
const runner = request => {
|
||||
if (request.args[0] === 'simulator:start' && watching) {
|
||||
watching.onUpdate({ state: 'in progress', step: 'Capture complete single-commit baseline', stepSince: 0, waitedMs: 60_000 });
|
||||
setImmediate(() => finished.resolve(baseline.directory));
|
||||
}
|
||||
return f.runner(request);
|
||||
};
|
||||
const bodies = [];
|
||||
await runPublicCi({ baseProject: f.baseProject, headProject: f.headProject, pullRequestPath: f.pullRequestPath, output: join(f.root, 'review'), config: f.config,
|
||||
environment: f.environment, transport: f.transport, runner, now: f.now, sleep: f.sleep, onComment: (_state, body) => bodies.push(body),
|
||||
awaitBaseline: (_signal, watch) => {
|
||||
watching = watch;
|
||||
watch.onUpdate({ state: 'in progress', step: 'Install the launch recording decoder', stepSince: 0, waitedMs: 0 });
|
||||
return finished.promise;
|
||||
} });
|
||||
// The step change came moments after the first post, so the wait's end replaced it before its turn: every post
|
||||
// rewrites the whole comment, which the other targets' jobs write too.
|
||||
assert.ok(bodies.some(body => body.includes('Install the launch recording decoder')));
|
||||
assert.equal(bodies.some(body => body.includes('Capture complete single-commit baseline')), false);
|
||||
assert.equal(f.comments.at(-1).includes('base waits for'), false);
|
||||
});
|
||||
|
||||
test('capture:review waits for the baseline run ci:find-baseline named, downloads its artifact, and restores base from it', async t => {
|
||||
const f = await fixture(t, 'expo-router');
|
||||
t.mock.method(globalThis, 'fetch', async input => assert.fail(`Unmocked network request: ${input}`));
|
||||
|
||||
@@ -6,6 +6,7 @@ import test from "node:test";
|
||||
import { Uint8ArrayReader, Uint8ArrayWriter, ZipWriter, configure } from "@zip.js/zip.js";
|
||||
|
||||
const { waitForBaselineArtifact, awaitPendingBaseline } = await import("../../dist/ci/baseline-wait.js");
|
||||
const { createTimings } = await import("../../dist/shared/timings.js");
|
||||
const { findPendingBaselineRun, findOptionalBaseline } = await import("../../dist/ci/workflow-steps.js");
|
||||
|
||||
const sha = "a".repeat(40);
|
||||
@@ -88,6 +89,7 @@ test("a baseline job in progress, then finished: the review reuses its artifact,
|
||||
assert.equal(await readFile(join(directory, "screenshots/home.png"), "utf8"), "png");
|
||||
assert.equal(github.polls(), 5);
|
||||
assert.deepEqual(lines, [
|
||||
"waiting for main's baseline run 20 of aaaaaaaa: https://github.com/acme/app/actions/runs/20",
|
||||
"waiting for main's baseline run 20 of aaaaaaaa (iphone: not started, 0 min)",
|
||||
"waiting for main's baseline run 20 of aaaaaaaa (iphone: queued, 0 min)",
|
||||
"waiting for main's baseline run 20 of aaaaaaaa (iphone: in progress, 0 min)",
|
||||
@@ -99,6 +101,44 @@ test("a baseline job in progress, then finished: the review reuses its artifact,
|
||||
assert.deepEqual((await readdir(join(root, "review"))).sort(), ["baseline-download"], "the downloaded zip is removed once unpacked");
|
||||
});
|
||||
|
||||
test("the wait names the step the baseline job is in, tells the review when it changes, and records the steps it took", async t => {
|
||||
const root = await mkdtemp(join(tmpdir(), "explore-baseline-steps-"));
|
||||
t.after(() => rm(root, { recursive: true, force: true }));
|
||||
// The clock starts at a real date so GitHub's step timestamps and the wait's clock agree, as they do on a runner.
|
||||
let milliseconds = Date.parse("2026-10-23T21:53:00Z");
|
||||
const time = { now: () => milliseconds, sleep: async pause => { milliseconds += pause; } };
|
||||
const at = minutes => new Date(Date.parse("2026-10-23T21:53:00Z") + minutes * 60_000).toISOString();
|
||||
const steps = (current) => [
|
||||
{ number: 1, name: "Set up job", status: "completed", conclusion: "success", started_at: at(0), completed_at: at(0.5) },
|
||||
{ number: 2, name: "Install the launch recording decoder https://mirror.example/?sig=SIG-CANARY", status: current === 2 ? "in_progress" : "completed",
|
||||
conclusion: current === 2 ? null : "success", started_at: at(0.5), completed_at: current === 2 ? null : at(19) },
|
||||
...(current === 3 ? [{ number: 3, name: "Capture complete single-commit baseline", status: "in_progress", conclusion: null, started_at: at(19), completed_at: null }] : []),
|
||||
];
|
||||
const states = [...Array(57).fill({ jobs: [{ ...job("in_progress"), steps: steps(2) }] }), { jobs: [{ ...job("in_progress"), steps: steps(3) }] }];
|
||||
const github = fakeGitHub({ states });
|
||||
const updates = []; const lines = [];
|
||||
const path = join(root, "timings.jsonl");
|
||||
const outcome = await waitForBaselineArtifact(waitOptions(github, time, { timeoutMs: 20 * 60_000, progress: line => lines.push(line),
|
||||
onUpdate: update => updates.push(update), timings: createTimings({ path, now: time.now }) }));
|
||||
assert.deepEqual(outcome, { reason: "its iphone job is still in progress after 20 min" });
|
||||
assert.deepEqual(updates.map(update => [update.state, update.step]), [
|
||||
["in progress", "Install the launch recording decoder [link]"],
|
||||
["in progress", "Capture complete single-commit baseline"],
|
||||
]);
|
||||
assert.equal(updates[0].stepSince, Date.parse(at(0.5)));
|
||||
assert.ok(lines.includes("waiting for main's baseline run 20 of aaaaaaaa (iphone: in progress, in \"Install the launch recording decoder [link]\" for 9 min, 9 min)"), lines.join("\n"));
|
||||
const events = (await readFile(path, "utf8")).trim().split("\n").map(line => JSON.parse(line));
|
||||
assert.deepEqual(events.filter(event => event.type === "baseline-step").map(event => [event.name, Math.round(event.ms / 1000), event.conclusion]), [
|
||||
["Set up job", 30, "success"],
|
||||
["Install the launch recording decoder [link]", 1110, "success"],
|
||||
["Capture complete single-commit baseline", 60, "still running"],
|
||||
]);
|
||||
const wait = events.find(event => event.type === "end" && event.phase === "baseline-wait");
|
||||
assert.equal(wait.outcome, "skipped");
|
||||
assert.equal(wait.attributes.reason, "its iphone job is still in progress after 20 min");
|
||||
assert.equal(JSON.stringify(events).includes("SIG-CANARY"), false);
|
||||
});
|
||||
|
||||
test("this target's artifact is reused although another target's baseline job failed (#48)", async () => {
|
||||
const github = fakeGitHub({ states: [{ jobs: [job("completed", "failure", "duo-open"), job("in_progress")] },
|
||||
{ runStatus: "completed", conclusion: "failure", jobs: [job("completed", "failure", "duo-open"), job("completed", "success")], artifact: true }] });
|
||||
@@ -135,7 +175,7 @@ test("the wait gives up at its time limit, polling every 20 s", async () => {
|
||||
assert.deepEqual(await waitForBaselineArtifact(waitOptions(github, time, { progress: line => lines.push(line) })), { reason: "its iphone job is still in progress after 15 min" });
|
||||
assert.equal(time.elapsed(), 15 * 60_000);
|
||||
assert.equal(github.polls(), 15 * 3 + 1);
|
||||
assert.equal(lines.length, 15, "one line a minute, not one a poll");
|
||||
assert.equal(lines.length, 1 + 15, "the run's link once, then one line a minute, not one a poll");
|
||||
assert.deepEqual(await waitForBaselineArtifact(waitOptions(fakeGitHub({ states: [{ jobs: [job("in_progress")] }] }), clock(), { timeoutMs: 50_000, pollMs: 30_000 })),
|
||||
{ reason: "its iphone job is still in progress after 1 min" }, "the last pause ends at the limit");
|
||||
});
|
||||
|
||||
@@ -0,0 +1,44 @@
|
||||
import assert from "node:assert/strict";
|
||||
import test from "node:test";
|
||||
import { Worker } from "node:worker_threads";
|
||||
|
||||
const { settleCaptureWorker } = await import("../../dist/ci/capture-worker.js");
|
||||
|
||||
// A worker that names a blocking call, then really blocks its thread in a synchronous subprocess, as a capture's
|
||||
// install or native build does, and reports its result a little after the call returns.
|
||||
const blockingWorker = `
|
||||
const { parentPort } = require("node:worker_threads");
|
||||
const { spawnSync } = require("node:child_process");
|
||||
parentPort.postMessage({ type: "progress", message: "installing the app" });
|
||||
parentPort.postMessage({ type: "blocking", phase: "install", boundMs: 15 * 60000 });
|
||||
spawnSync("sleep", ["0.8"]);
|
||||
parentPort.postMessage({ type: "unblocked" });
|
||||
setTimeout(() => parentPort.postMessage({ type: "done", result: { outputDirectory: "/out" } }), 400);
|
||||
`;
|
||||
|
||||
test("while a capture worker is blocked in a call it named, the parent prints a line on its own, and stops when the call returns", async () => {
|
||||
const lines = [];
|
||||
const started = Date.now();
|
||||
const result = await settleCaptureWorker(new Worker(blockingWorker, { eval: true }), { side: "head", appearancePass: { all: ["light", "dark"], capture: ["dark"] } },
|
||||
line => lines.push({ line, at: Date.now() - started }), undefined, 100);
|
||||
assert.deepEqual(result, { outputDirectory: "/out" });
|
||||
assert.equal(lines[0].line, "installing the app");
|
||||
const beats = lines.slice(1);
|
||||
assert.ok(beats.length >= 4, `heartbeats while blocked: ${JSON.stringify(lines)}`);
|
||||
assert.match(beats[0].line, /^head dark: still in install \(\d+ ms of at most 15 min\)$/);
|
||||
// None after the call returned: the last 400 ms before the result are quiet.
|
||||
assert.ok(beats.at(-1).at < Date.now() - started - 250, JSON.stringify(lines));
|
||||
});
|
||||
|
||||
test("a baseline's worker is named as its timings are, not by the head side it captures as", async () => {
|
||||
const lines = [];
|
||||
await settleCaptureWorker(new Worker(blockingWorker, { eval: true }), { side: "head", timingsSide: "baseline" }, line => lines.push(line), undefined, 100);
|
||||
assert.match(lines[1], /^baseline: still in install /);
|
||||
});
|
||||
|
||||
test("a worker that names no blocking call gets no heartbeat, and its failure still settles the capture", async () => {
|
||||
const lines = [];
|
||||
const worker = new Worker(`require("node:worker_threads").parentPort.postMessage({ type: "error", error: { code: "CAPTURE_INSTALL_FAILED", stage: "session", message: "m", nextAction: "n", retryable: false } });`, { eval: true });
|
||||
await assert.rejects(settleCaptureWorker(worker, { side: "base" }, line => lines.push(line), undefined, 50), error => error.code === "CAPTURE_INSTALL_FAILED");
|
||||
assert.deepEqual(lines, []);
|
||||
});
|
||||
@@ -6,7 +6,7 @@ import { spawnSync } from "node:child_process";
|
||||
import test from "node:test";
|
||||
import { tsImport } from "tsx/esm/api";
|
||||
|
||||
const { CiError, toCiError, ciErrorForCommand, serializeCiError, renderCiErrorAnnotation, renderCiErrorSummary, reportCiError } =
|
||||
const { CiError, toCiError, ciErrorForCommand, serializeCiError, renderCiErrorAnnotation, renderCiErrorSummary, reportCiError, redactSecrets } =
|
||||
await tsImport("../../src/shared/ci-errors.ts", import.meta.url);
|
||||
const { executeCaptureSetup } = await tsImport("../../src/capture/setup-actions.ts", import.meta.url);
|
||||
const { createExplorationInputs } = await tsImport("../../src/config/exploration-inputs.ts", import.meta.url);
|
||||
@@ -65,6 +65,20 @@ test("diagnostics redact explicit secrets, credential fields, bearer tokens, sig
|
||||
assert.equal("stack" in serializeCiError(error), false);
|
||||
});
|
||||
|
||||
test("the redactor removes a session's fragment token and object-store signatures and credentials", () => {
|
||||
const text = [
|
||||
"https://expo.dev/accounts/a/projects/b/simulator-sessions/1#token=FRAGMENT-CANARY&x=1",
|
||||
"https://bucket.s3.amazonaws.com/a?X-Amz-Credential=CREDENTIAL-CANARY&X-Amz-Signature=SIGNATURE-CANARY&X-Amz-Security-Token=SESSION-CANARY",
|
||||
"https://storage.googleapis.com/a?X-Goog-Signature=GOOG-CANARY",
|
||||
"https://blob.core.windows.net/a?sv=2024&se=EXPIRY-CANARY&sig=SIG-CANARY",
|
||||
].join(" ");
|
||||
const redacted = redactSecrets(text, []);
|
||||
for (const canary of ["FRAGMENT-CANARY", "CREDENTIAL-CANARY", "SIGNATURE-CANARY", "SESSION-CANARY", "GOOG-CANARY", "EXPIRY-CANARY", "SIG-CANARY"]) {
|
||||
assert.equal(redacted.includes(canary), false, canary);
|
||||
}
|
||||
assert.match(redacted, /simulator-sessions\/1#token=\[REDACTED\]&x=1/);
|
||||
});
|
||||
|
||||
test("diagnostics redact raw, JSON-escaped, and URL-encoded secret values throughout structured errors", () => {
|
||||
const secret = 'review"P\\ass/word+9';
|
||||
const variants = [secret, JSON.stringify(secret).slice(1, -1), encodeURIComponent(secret)];
|
||||
|
||||
@@ -0,0 +1,51 @@
|
||||
import assert from "node:assert/strict";
|
||||
import { readFile, readdir } from "node:fs/promises";
|
||||
import { createRequire } from "node:module";
|
||||
import { join, relative } from "node:path";
|
||||
import test from "node:test";
|
||||
import { fileURLToPath } from "node:url";
|
||||
|
||||
// A fake EAS accepts any flag, so a flag the pinned eas-cli does not have passes every other test and fails only on a
|
||||
// real runner: 0.20.6 sent `env:list --non-interactive`, which eas-cli 25.2.0 refuses, so every capture logged "EAS did
|
||||
// not list the development environment's variables" and never shared a repack (brentvatne/euxy review run 39517635857).
|
||||
// Every literal `eas` command in src is checked against the command manifest of the eas-cli package.json pins.
|
||||
const root = fileURLToPath(new URL("../..", import.meta.url));
|
||||
const manifest = JSON.parse(await readFile(createRequire(join(root, "package.json")).resolve("eas-cli/oclif.manifest.json"), "utf8")).commands;
|
||||
const commands = new Map();
|
||||
for (const [id, command] of Object.entries(manifest)) {
|
||||
commands.set(id, command);
|
||||
for (const alias of command.aliases ?? []) commands.set(alias, command);
|
||||
}
|
||||
|
||||
async function sources(directory) {
|
||||
const files = [];
|
||||
for (const entry of await readdir(directory, { withFileTypes: true })) {
|
||||
const path = join(directory, entry.name);
|
||||
if (entry.isDirectory()) files.push(...await sources(path));
|
||||
else if (entry.name.endsWith(".ts")) files.push(path);
|
||||
}
|
||||
return files;
|
||||
}
|
||||
|
||||
test("every literal eas command in src names a flag the pinned eas-cli has", async () => {
|
||||
const checked = new Set();
|
||||
const unknown = [];
|
||||
for (const file of await sources(join(root, "src"))) {
|
||||
const text = await readFile(file, "utf8");
|
||||
// An argument list that starts with a command id, up to its closing bracket.
|
||||
for (const match of text.matchAll(/\[\s*"([a-z]+(?::[a-z-]+)+)"([^\]]*)\]/g)) {
|
||||
const command = commands.get(match[1]);
|
||||
if (!command) continue; // Explore's own commands (source:verify, explore:binary, …) share the shape.
|
||||
checked.add(match[1]);
|
||||
const flags = command.flags ?? {};
|
||||
for (const flag of match[2].matchAll(/"--([a-z0-9-]+)(?:=[^"]*)?"/g)) {
|
||||
if (!(flag[1] in flags)) unknown.push(`${relative(root, file)}: eas ${match[1]} --${flag[1]}`);
|
||||
}
|
||||
}
|
||||
}
|
||||
assert.deepEqual(unknown, []);
|
||||
// The scan finds the commands capture depends on, so it cannot pass by matching nothing.
|
||||
for (const id of ["env:list", "build:list", "build:view", "workflow:run", "workflow:view", "workflow:cancel", "simulator:start", "simulator:stop", "simulator:control"]) {
|
||||
assert.ok(checked.has(id), `eas ${id} was not found in src`);
|
||||
}
|
||||
});
|
||||
@@ -107,6 +107,12 @@ test('a started run is known by its JSON or by the link it printed, and a start
|
||||
assert.throws(() => hostedRepackRunStart('', 'Failed to upload project sources.\nError: socket hang up\n', 'ios'),
|
||||
error => error.code === 'EAS_REPACK_FAILED' && hostedRepackRetries(error) === 2 && /did not start the hosted ios repack/.test(error.message));
|
||||
assert.throws(() => hostedRepackRunStart('', 'Error: Not logged in\n', 'ios'), error => hostedRepackRetries(error) === 0);
|
||||
// The link is written to logs and errors: only the page, never a query or fragment eas-cli appended to it.
|
||||
assert.deepEqual(hostedRepackRunStart(JSON.stringify({ id: '01a15b61-c4a2-7c7b-b950-9f280edea954', url: `${url}?token=SECRET#frag` }), '', 'ios'),
|
||||
{ id: '01a15b61-c4a2-7c7b-b950-9f280edea954', url });
|
||||
const failed = (() => { try { hostedRepackBuildId(JSON.stringify({ status: 'FAILURE', logURL: `${url}?sig=SECRET`, jobs: [{ key: 'repack', status: 'FAILURE' }] }), '', 'ios'); } catch (error) { return error; } })();
|
||||
assert.equal(failed.details.logs, url);
|
||||
assert.equal(JSON.stringify(failed).includes('SECRET') || failed.nextAction.includes('SECRET'), false);
|
||||
});
|
||||
|
||||
test('the staged digest changes with any file, mode or link, and the share key with every input', async t => {
|
||||
|
||||
@@ -257,6 +257,20 @@ test("semantic Map scope is discarded by non-Map canvases", () => {
|
||||
}
|
||||
});
|
||||
|
||||
test("Screens' filmstrip layout round-trips, and other canvases and unknown layouts drop it", () => {
|
||||
const route = { ...base, canvas: "screens", screen: "accessibility", layout: "filmstrip" };
|
||||
assert.equal(nav.formatRoute(route, ctx), "/screens?screen=accessibility&layout=filmstrip");
|
||||
assert.deepEqual(parse("/screens?screen=accessibility&layout=filmstrip"), route);
|
||||
// The grid is the default, so it is never written.
|
||||
assert.equal(nav.formatRoute({ ...base, canvas: "screens", layout: "grid" }, ctx), "/screens");
|
||||
assert.deepEqual(parse("/screens?layout=grid"), { ...base, canvas: "screens" });
|
||||
assert.deepEqual(parse("/screens?layout=nope"), { ...base, canvas: "screens" });
|
||||
for (const canvas of ["map", "compare"]) {
|
||||
assert.equal(nav.formatRoute({ ...base, canvas, layout: "filmstrip" }, ctx), `/${canvas}`);
|
||||
assert.deepEqual(parse(`/${canvas}?layout=filmstrip`), { ...base, canvas });
|
||||
}
|
||||
});
|
||||
|
||||
test("ids with reserved characters survive the query", () => {
|
||||
const route = { ...base, screen: "removed:a+b%c" };
|
||||
assert.deepEqual(parse(nav.formatRoute(route, ctx)), route);
|
||||
@@ -274,6 +288,7 @@ test("another target's report opens at the same canvas and route, keeping only w
|
||||
"#/compare/settings/profile?inspect=diff&dir=in&focus=modified,added");
|
||||
assert.equal(nav.placeForAnotherTarget("#/map/home"), "#/map/home");
|
||||
assert.equal(nav.placeForAnotherTarget("#/screens?screen=s-3"), "#/screens");
|
||||
assert.equal(nav.placeForAnotherTarget("#/screens?screen=s-3&layout=filmstrip"), "#/screens?layout=filmstrip");
|
||||
// No place, or a hash from before routes: the other report opens where a link to it would.
|
||||
assert.equal(nav.placeForAnotherTarget(""), "");
|
||||
assert.equal(nav.placeForAnotherTarget("#map"), "");
|
||||
|
||||
@@ -192,6 +192,20 @@ test('pending and capturing runs say what they are doing in the heading and a li
|
||||
assert.equal(progress('head', false), `iOS · capturing head 1/3 · ${runLink}`);
|
||||
assert.equal(progress('head', true), `iOS · capturing head 1/3 · base reused · ${runLink}`);
|
||||
assert.equal(progress(undefined, false), `iOS · capturing head 1/3 · ${runLink}`);
|
||||
// Base waiting for the default branch's baseline says so, with the step that baseline job is in, until the wait ends.
|
||||
const waitingState = step => state({ phase: 'capturing', links, review: undefined, evidence: undefined,
|
||||
capture: { planned: { base: 3, head: 3 }, done: { base: 0, head: 3 }, baseFromCache: false, current: 'head', waiting: { on: 'baseline', ...(step ? { step } : {}) } } });
|
||||
assert.equal(statusOf(renderPublicComment(waitingState('Install the launch recording decoder')), 'iOS'),
|
||||
`iOS · head 3/3 · base waits for the default branch's baseline (in “Install the launch recording decoder”) · ${runLink}`);
|
||||
assert.equal(statusOf(renderPublicComment(waitingState()), 'iOS'), `iOS · head 3/3 · base waits for the default branch's baseline · ${runLink}`);
|
||||
assert.equal(statusOf(renderPublicComment(waitingState('a *bold* [link](x)')), 'iOS'),
|
||||
`iOS · head 3/3 · base waits for the default branch's baseline (in “a \\*bold\\* \\[link\\]\\(x\\)”) · ${runLink}`, 'a step name is text, not Markdown');
|
||||
// Another target's writer re-renders this record from the comment it read: the wait survives, and a record from
|
||||
// before it existed still parses.
|
||||
const record = parsePlatformRecord(JSON.parse(JSON.stringify(platformRecordOf(waitingState('Install the launch recording decoder')))));
|
||||
assert.deepEqual(record.capture.waiting, { on: 'baseline', step: 'Install the launch recording decoder' });
|
||||
const older = platformRecordOf(waitingState()); delete older.capture.waiting;
|
||||
assert.equal(parsePlatformRecord(JSON.parse(JSON.stringify(older))).capture.waiting, undefined);
|
||||
assert.equal(titleOf(renderPublicComment(state({ phase: 'capturing', links, review: undefined, evidence: undefined }))), '### Explore review · capturing');
|
||||
const none = renderPublicComment(state({ review: review([surface('cats', 'modified', { extra: { review: { status: 'unchanged', description: 'No visible change' } } })]) }));
|
||||
assert.equal(titleOf(none), `### No screens changed · [Review in Explore](<${reportUrl}>)`, 'unchanged surfaces are no change');
|
||||
|
||||
@@ -0,0 +1,120 @@
|
||||
import assert from "node:assert/strict";
|
||||
import { mkdtemp, readFile, rm } from "node:fs/promises";
|
||||
import { tmpdir } from "node:os";
|
||||
import { join } from "node:path";
|
||||
import test from "node:test";
|
||||
import { tsImport } from "tsx/esm/api";
|
||||
|
||||
const { createTimings, silentTimings, blockingCall, throttledProgress, githubRunLink, easPageLink, safeText, renderTimingsSummary, formatDuration } =
|
||||
await tsImport("../../src/shared/timings.ts", import.meta.url);
|
||||
const { CiError } = await tsImport("../../src/shared/ci-errors.ts", import.meta.url);
|
||||
|
||||
async function withFile(run) {
|
||||
const directory = await mkdtemp(join(tmpdir(), "explore-timings-"));
|
||||
try { return await run(join(directory, "explore-diagnostics", "timings.jsonl")); }
|
||||
finally { await rm(directory, { recursive: true, force: true }); }
|
||||
}
|
||||
const events = async path => (await readFile(path, "utf8")).trim().split("\n").map(line => JSON.parse(line));
|
||||
|
||||
test("a span is written when it opens and when it closes, with its labels, duration and outcome", () => withFile(async path => {
|
||||
let clock = 1_000;
|
||||
const timings = createTimings({ path, now: () => clock }).labelled({ side: "head", pass: "dark" });
|
||||
const end = timings.span("repack", { attempt: 1 });
|
||||
clock += 2_500;
|
||||
end("ok", { build: "abc" });
|
||||
end("failed");
|
||||
const [start, finish, ...rest] = await events(path);
|
||||
assert.deepEqual(start, { type: "start", id: start.id, phase: "repack", at: 1_000, side: "head", pass: "dark", attributes: { attempt: 1 } });
|
||||
assert.deepEqual(finish, { type: "end", id: start.id, phase: "repack", at: 3_500, ms: 2_500, outcome: "ok", side: "head", pass: "dark", attributes: { attempt: 1, build: "abc" } });
|
||||
assert.equal(rest.length, 0, "a span closes once");
|
||||
}));
|
||||
|
||||
test("measure ends a span ok, failed with the error's code, or cancelled, for sync and async work", () => withFile(async path => {
|
||||
const timings = createTimings({ path });
|
||||
assert.equal(timings.measure("plan", () => 4), 4);
|
||||
assert.equal(await timings.measure("compare", async () => 5), 5);
|
||||
assert.throws(() => timings.measure("install", () => { throw new CiError({ code: "INSTALL_FAILED", stage: "s", message: "m", nextAction: "n" }); }));
|
||||
await assert.rejects(timings.measure("session-start", async () => { throw new CiError({ code: "CAPTURE_CANCELLED", stage: "s", message: "m", nextAction: "n" }); }));
|
||||
const ends = (await events(path)).filter(event => event.type === "end");
|
||||
assert.deepEqual(ends.map(event => [event.phase, event.outcome, event.attributes?.code]),
|
||||
[["plan", "ok", undefined], ["compare", "ok", undefined], ["install", "failed", "INSTALL_FAILED"], ["session-start", "cancelled", "CAPTURE_CANCELLED"]]);
|
||||
}));
|
||||
|
||||
test("a recorder that cannot write never fails the capture it times", () => {
|
||||
const timings = createTimings({ path: "/dev/null/not-a-directory/timings.jsonl" });
|
||||
assert.equal(timings.measure("plan", () => "done"), "done");
|
||||
timings.record({ type: "finish", outcome: "ok" });
|
||||
assert.equal(silentTimings.measure("plan", () => 1), 1);
|
||||
});
|
||||
|
||||
test("nothing a recorder writes carries a secret, a signed link or a session's fragment token", () => withFile(async path => {
|
||||
const secret = "expo-token-CANARY-1234567890";
|
||||
const timings = createTimings({ path, secrets: [secret] });
|
||||
timings.record({ type: "baseline-step", name: `Install ${secret} https://x.example/a#token=FRAGMENT-CANARY`, ms: 1, conclusion: "success" });
|
||||
timings.span("repack", { note: "https://bucket.s3.amazonaws.com/a?X-Amz-Signature=SIGNATURE-CANARY", other: `?sig=SIG-CANARY ${secret}` })();
|
||||
const text = await readFile(path, "utf8");
|
||||
for (const canary of ["CANARY-1234567890", "FRAGMENT-CANARY", "SIGNATURE-CANARY", "SIG-CANARY"]) assert.equal(text.includes(canary), false, canary);
|
||||
const summary = renderTimingsSummary(text);
|
||||
for (const canary of ["CANARY-1234567890", "FRAGMENT-CANARY"]) assert.equal(summary.includes(canary), false, canary);
|
||||
}));
|
||||
|
||||
test("safe text has no links, one line and a bounded length", () => {
|
||||
assert.equal(safeText("Install the launch\nrecording decoder"), "Install the launch recording decoder");
|
||||
assert.equal(safeText("see https://expo.dev/a?b=c for logs"), "see [link] for logs");
|
||||
assert.equal(safeText("x".repeat(200)).length, 80);
|
||||
});
|
||||
|
||||
test("a wait's heartbeat prints at once, then at most once a minute", () => {
|
||||
let clock = 0;
|
||||
const lines = [];
|
||||
const tick = throttledProgress(line => lines.push(`${clock}:${line}`), { now: () => clock });
|
||||
for (clock of [0, 20_000, 40_000, 59_999, 60_000, 80_000, 119_999, 120_000]) tick("waiting");
|
||||
assert.deepEqual(lines, ["0:waiting", "60000:waiting", "120000:waiting"]);
|
||||
});
|
||||
|
||||
test("a blocking call is timed with its bound and tells the notice when it starts and ends", () => withFile(async path => {
|
||||
const told = [];
|
||||
const notice = (phase, boundMs) => { told.push(["start", phase, boundMs]); return () => told.push(["end"]); };
|
||||
assert.equal(blockingCall(createTimings({ path }), notice, "native-build", 45 * 60_000, () => "built"), "built");
|
||||
assert.throws(() => blockingCall(createTimings({ path }), notice, "install", 1000, () => { throw new Error("failed"); }));
|
||||
assert.deepEqual(told, [["start", "native-build", 2_700_000], ["end"], ["start", "install", 1000], ["end"]]);
|
||||
const ends = (await events(path)).filter(event => event.type === "end");
|
||||
assert.deepEqual(ends.map(event => [event.phase, event.outcome]), [["native-build", "ok"], ["install", "failed"]]);
|
||||
}));
|
||||
|
||||
test("links are rebuilt from their validated parts, never copied", () => {
|
||||
const environment = { GITHUB_SERVER_URL: "https://github.com", GITHUB_REPOSITORY: "brentvatne/euxy" };
|
||||
assert.equal(githubRunLink(environment, 40029888046), "https://github.com/brentvatne/euxy/actions/runs/40029888046");
|
||||
assert.equal(githubRunLink(environment, "1?x=y"), undefined);
|
||||
assert.equal(githubRunLink({ ...environment, GITHUB_REPOSITORY: "a/b/../c?d" }, 1), undefined);
|
||||
assert.equal(easPageLink("https://expo.dev/accounts/brent/projects/euxy/workflows/01ABC-def?token=x#y", "workflows"),
|
||||
"https://expo.dev/accounts/brent/projects/euxy/workflows/01ABC-def");
|
||||
// eas-cli's "See logs: <link>." brings the full stop along.
|
||||
assert.equal(easPageLink("https://expo.dev/accounts/brent/projects/euxy/workflows/01ABC-def.", "workflows"),
|
||||
"https://expo.dev/accounts/brent/projects/euxy/workflows/01ABC-def");
|
||||
for (const value of ["https://evil.dev/accounts/a/projects/b/workflows/c", "https://user:[email protected]/accounts/a/projects/b/workflows/c",
|
||||
"https://expo.dev/accounts/a/projects/b/builds/c", "https://expo.dev/accounts/a/projects/b/simulator-sessions/c", "http://expo.dev/accounts/a/projects/b/workflows/c", "not a url", undefined]) {
|
||||
assert.equal(easPageLink(value, "workflows"), undefined, String(value));
|
||||
}
|
||||
});
|
||||
|
||||
test("the summary totals phases per side, describes the routes, and names spans the job never finished", () => withFile(async path => {
|
||||
let clock = 0;
|
||||
const timings = createTimings({ path, now: () => clock });
|
||||
timings.record({ type: "run", target: "iphone" });
|
||||
const head = timings.labelled({ side: "head" });
|
||||
for (const [route, ms] of [["/a", 1_000], ["/b", 2_000], ["/c", 3_000], ["/d", 10_000]]) { const end = head.span("route", { route }); clock += ms; end(); }
|
||||
const repack = head.span("repack"); clock += 90_000; repack();
|
||||
timings.labelled({ side: "base" }).span("session-start");
|
||||
clock += 5_000;
|
||||
timings.record({ type: "baseline-step", name: "Install the launch recording decoder", ms: 19 * 60_000, conclusion: "cancelled" });
|
||||
const summary = renderTimingsSummary(await readFile(path, "utf8"));
|
||||
assert.match(summary, /### Explore capture timings · iphone/);
|
||||
assert.match(summary, /\| repack \| head \| 1 \| 1 min 30 s \| 1 min 30 s \|/);
|
||||
assert.match(summary, /\*\*Routes:\*\* 4, median 2 s, p90 10 s; slowest \/d 10 s, \/c 3 s, \/b 2 s\./);
|
||||
assert.match(summary, /- Install the launch recording decoder: 19 min \(cancelled\)/);
|
||||
assert.match(summary, /\*\*Never finished\*\* \(the job ended first\): session-start \(base\), 5 s\+/);
|
||||
assert.match(summary, /no finish recorded/);
|
||||
assert.equal(renderTimingsSummary(""), "");
|
||||
assert.equal(formatDuration(850), "850 ms");
|
||||
}));
|
||||
+44
-6
@@ -47,8 +47,10 @@ import {
|
||||
type MapDirection,
|
||||
type Route,
|
||||
type RouteContext,
|
||||
type ScreensLayout,
|
||||
type ThemePreference,
|
||||
} from "./utils/navigation";
|
||||
import { readScreensLayout, writeScreensLayout } from "./utils/screens-layout";
|
||||
import {
|
||||
CANVAS_NUMBER_KEYS,
|
||||
matchesShortcut,
|
||||
@@ -886,6 +888,8 @@ const ViewerApp = memo(function ViewerApp({ reportKey }: { reportKey: number })
|
||||
if (!rightCollapsedRef.current) inspectorDismissedRef.current = true;
|
||||
setRightCollapsed((current) => !current);
|
||||
}, []);
|
||||
// A double-click that opens the filmstrip closes the Inspector its first click opened; it is not the reader dismissing it.
|
||||
const closeInspector = useCallback(() => setRightCollapsed(true), []);
|
||||
|
||||
// Every canvas opens with the panel showing and the Inspector out of the way.
|
||||
// The sidebar keeps whatever state the reader gave it; only the Inspector closes, because a
|
||||
@@ -897,6 +901,12 @@ const ViewerApp = memo(function ViewerApp({ reportKey }: { reportKey: number })
|
||||
// Every canvas starts with the Inspector closed; selecting a screenshot opens the Inspector on
|
||||
// demand. A peer canvas is a fresh inventory, so a screen selection never travels with the reader
|
||||
// into the destination view.
|
||||
// The report Screens' layout is remembered for: the loaded one, however it was loaded.
|
||||
const runId = payload?.map.run.id;
|
||||
/** Screens opens in the layout the reader last left it in for this report. */
|
||||
const rememberedScreensLayout = useCallback((canvas: CanvasView): Partial<Route> => (
|
||||
canvas === "screens" && routeRef.current.canvas !== "screens" ? { layout: readScreensLayout(runId) } : {}
|
||||
), [runId]);
|
||||
const commitCanvasSelection = useCallback((canvas: CanvasView) => {
|
||||
const current = routeRef.current;
|
||||
if (canvas === "compare") {
|
||||
@@ -928,9 +938,22 @@ const ViewerApp = memo(function ViewerApp({ reportKey }: { reportKey: number })
|
||||
} : {
|
||||
canvas,
|
||||
...clearedCanvasSelection,
|
||||
...rememberedScreensLayout(canvas),
|
||||
},
|
||||
);
|
||||
}, [applyCanvasPanelDefaults, navigate]);
|
||||
}, [applyCanvasPanelDefaults, navigate, rememberedScreensLayout]);
|
||||
// Only a switch the reader makes is remembered as the grid: landing on Screens in the grid (from Search, Back or a
|
||||
// link) leaves a remembered filmstrip alone. The selection and its focus request carry over, so the Screens page
|
||||
// does not read the switch as a new pick that Changed or a find hides.
|
||||
const changeScreensLayout = useCallback((layout: ScreensLayout) => {
|
||||
writeScreensLayout(runId, layout);
|
||||
// A change of view, not a move: Back leaves Screens rather than undoing it, as the change filter's does.
|
||||
navigate({ layout: layout === "filmstrip" ? "filmstrip" : undefined }, { replace: true, preserveFocus: true });
|
||||
}, [navigate, runId]);
|
||||
// A link that opens the filmstrip is remembered as a switch to it is.
|
||||
useEffect(() => {
|
||||
if (route.canvas === "screens" && route.layout === "filmstrip") writeScreensLayout(runId, "filmstrip");
|
||||
}, [route.canvas, route.layout, runId]);
|
||||
|
||||
// The logo returns to the Map root, the equivalent of the "/map" URL.
|
||||
const openMapHome = useCallback(() => {
|
||||
@@ -1010,6 +1033,13 @@ const ViewerApp = memo(function ViewerApp({ reportKey }: { reportKey: number })
|
||||
if (event.key === "Escape") {
|
||||
if (routeRef.current.canvas === "compare") return;
|
||||
if (rightCollapsedRef.current) {
|
||||
// The filmstrip is a screen opened from the grid: Esc steps back out to the grid, keeping the selection.
|
||||
if (routeRef.current.canvas === "screens" && routeRef.current.layout === "filmstrip" && !phoneRef.current) {
|
||||
setTimeout(() => {
|
||||
if (!event.defaultPrevented) changeScreensLayout("grid");
|
||||
}, 0);
|
||||
return;
|
||||
}
|
||||
if (!resolveScreenId(routeRef.current, contextRef.current)) return;
|
||||
setTimeout(() => {
|
||||
if (!event.defaultPrevented) clearSelectedScreen();
|
||||
@@ -1056,6 +1086,9 @@ const ViewerApp = memo(function ViewerApp({ reportKey }: { reportKey: number })
|
||||
setChangesOpen((open) => !open);
|
||||
} else if (matchesShortcut(event, SHORTCUTS.panel.right)) {
|
||||
toggleRightPanel();
|
||||
} else if (matchesShortcut(event, SHORTCUTS.screens.grid) || matchesShortcut(event, SHORTCUTS.screens.filmstrip)) {
|
||||
if (routeRef.current.canvas !== "screens" || phoneRef.current) return;
|
||||
changeScreensLayout(matchesShortcut(event, SHORTCUTS.screens.grid) ? "grid" : "filmstrip");
|
||||
} else {
|
||||
const canvas = CANVAS_KEYS.find(([, shortcut]) => matchesShortcut(event, shortcut));
|
||||
if (!canvas) return;
|
||||
@@ -1067,7 +1100,7 @@ const ViewerApp = memo(function ViewerApp({ reportKey }: { reportKey: number })
|
||||
return () => {
|
||||
window.removeEventListener("keydown", onKeyDown);
|
||||
};
|
||||
}, [chooseAppearance, clearSelectedScreen, flipTheme, navigate, searchOpen, selectCanvas, toggleFullscreen, toggleRightPanel]);
|
||||
}, [changeScreensLayout, chooseAppearance, clearSelectedScreen, flipTheme, navigate, searchOpen, selectCanvas, toggleFullscreen, toggleRightPanel]);
|
||||
|
||||
// A side-panel row or a deep link is a "go to": the camera fits that screen and the step is
|
||||
// kept. Screens inventory clicks only select in place; Map clicks also focus the chosen screen. Repeating a selected target refits it without adding history.
|
||||
@@ -1097,10 +1130,11 @@ const ViewerApp = memo(function ViewerApp({ reportKey }: { reportKey: number })
|
||||
const pickedInPlaceRef = useRef<string | undefined>(undefined);
|
||||
// The Screens tree and jump bar pick a screen in place: it is selected and scrolled to, and the
|
||||
// Inspector stays as it was. A click on the screenshot, or I, opens it.
|
||||
const pickScreenInPlace = useCallback((id: string) => {
|
||||
const pickScreenInPlace = useCallback((id: string, options?: { replace?: boolean }) => {
|
||||
const sameSelection = resolveScreenId(routeRef.current, contextRef.current) === id;
|
||||
if (!sameSelection) pickedInPlaceRef.current = id;
|
||||
navigate(screenPatch(id), { replace: sameSelection, focus: { target: "screen", id } });
|
||||
// A swipe through the filmstrip is one step back, however many screens it passed.
|
||||
navigate(screenPatch(id), { replace: sameSelection || options?.replace === true, focus: { target: "screen", id } });
|
||||
}, [navigate, screenPatch]);
|
||||
// On a phone the Inspector covers the map, so a tap selects the screen first (its ring, its
|
||||
// connections, the Open hint) and only a second tap on the selected screen opens it.
|
||||
@@ -1134,10 +1168,11 @@ const ViewerApp = memo(function ViewerApp({ reportKey }: { reportKey: number })
|
||||
canvas: "screens",
|
||||
...screenPatch(screenId),
|
||||
expandedGroups: [],
|
||||
...rememberedScreensLayout("screens"),
|
||||
}, {
|
||||
resetCamera: true,
|
||||
});
|
||||
}, [applyCanvasPanelDefaults, navigate, screenPatch]);
|
||||
}, [applyCanvasPanelDefaults, navigate, rememberedScreensLayout, screenPatch]);
|
||||
// Following a row inside the inspector is the exception: a transition or changed screen is
|
||||
// read from a view the reader chose, and landing somewhere new is no
|
||||
// reason to close it. The panel stays where it was and only its subject changes.
|
||||
@@ -1656,6 +1691,9 @@ const ViewerApp = memo(function ViewerApp({ reportKey }: { reportKey: number })
|
||||
onSelectScreen={selectScreenOnCanvas}
|
||||
onPickScreen={pickScreenInPlace}
|
||||
onClearSelection={clearSelectedScreen}
|
||||
layout={route.layout ?? "grid"}
|
||||
onChangeLayout={changeScreensLayout}
|
||||
onCloseInspector={closeInspector}
|
||||
/>
|
||||
) : null}
|
||||
{comparing && phone && diff && selectedScreenId && comparePicker ? (
|
||||
@@ -1707,7 +1745,7 @@ const ViewerApp = memo(function ViewerApp({ reportKey }: { reportKey: number })
|
||||
/>
|
||||
)}
|
||||
</div>
|
||||
{/* Top right holds the camera only, so only the Map has anything there. */}
|
||||
{/* Top right holds the Map's camera; Screens puts its layout switch there itself. */}
|
||||
{phone || route.canvas !== "map" ? null : <CanvasCameraControls />}
|
||||
{phone ? (
|
||||
<PhoneTabBar
|
||||
|
||||
@@ -112,7 +112,8 @@ export function shortcutGroups(context: ShortcutContext): Group[][] {
|
||||
title: "Screens",
|
||||
rows: [
|
||||
{ label: "Move through the screens", keys: ["←", "→", "↑", "↓"] },
|
||||
{ label: "Close the inspector, then deselect", keys: ["Esc"] },
|
||||
{ label: "Grid or filmstrip", keys: [SHORTCUTS.screens.grid, SHORTCUTS.screens.filmstrip] },
|
||||
{ label: "Close the inspector, then leave the filmstrip or deselect", keys: ["Esc"] },
|
||||
],
|
||||
};
|
||||
const here: Group[] = context.canvas === "compare"
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
import { useRef } from "react";
|
||||
import { useRef, type ReactNode } from "react";
|
||||
import { Search, X } from "lucide-react";
|
||||
import "./panel-search.css";
|
||||
|
||||
@@ -9,6 +9,8 @@ type PanelSearchProps = {
|
||||
clearLabel: string;
|
||||
name?: string;
|
||||
autoFocus?: boolean;
|
||||
/** Shown at the field's end while it is empty, such as the key that focuses it. */
|
||||
hint?: ReactNode;
|
||||
onEscape?: () => void;
|
||||
onChange: (value: string) => void;
|
||||
};
|
||||
@@ -36,6 +38,7 @@ export function PanelSearch(props: PanelSearchProps) {
|
||||
}}
|
||||
onChange={(event) => props.onChange(event.target.value)}
|
||||
/>
|
||||
{props.value ? null : props.hint}
|
||||
{props.value && (
|
||||
<button
|
||||
type="button"
|
||||
|
||||
@@ -0,0 +1,334 @@
|
||||
import { useEffect, useLayoutEffect, useMemo, useRef, useState, type CSSProperties, type PointerEvent, type WheelEvent } from "react";
|
||||
import { ChevronRight } from "lucide-react";
|
||||
import { artifactUrl, isLaunchScreen, type MapIndex, type Screen } from "../../utils/model";
|
||||
import { primaryScreenshotForScreen, screenshotSize, type ScreenshotSize } from "../../utils/screen-images";
|
||||
import { diffClass, type BuildDiff } from "../../utils/build-diff";
|
||||
import { screenLabel } from "../../utils/screen-path";
|
||||
import { treeNodeKey, type ScreenTree, type ScreenTreeIndex, type ScreenTreeNode } from "../../utils/screen-tree";
|
||||
import { ScreenshotImage } from "../shared/screenshot-image";
|
||||
|
||||
/**
|
||||
* A neighbour's size and opacity by its distance from the screen in the middle. The last, invisible, place is where a
|
||||
* screen waits to come in, so a swipe or a step fades it in rather than popping it.
|
||||
*/
|
||||
const SCALES = [1, 0.74, 0.54, 0.4, 0.3];
|
||||
const OPACITIES = [1, 0.9, 0.6, 0.3, 0];
|
||||
const GAP = 32;
|
||||
/** A swipe has ended once its wheel events (and the trackpad's momentum after it) stop for this long. */
|
||||
const SWIPE_END_MS = 100;
|
||||
/**
|
||||
* At the end of a swipe the strip settles on the next screen in its direction once it has moved this far towards it,
|
||||
* so one wheel notch steps a screen and a twitch springs back.
|
||||
*/
|
||||
const SWIPE_COMMIT = 0.2;
|
||||
/** How far a finger moves before a touch is a swipe rather than a tap. */
|
||||
const TAP_SLOP_PX = 8;
|
||||
/** How far ahead a flick's speed carries the strip when the finger lifts: its velocity times this. */
|
||||
const FLICK_MS = 160;
|
||||
/**
|
||||
* How long the strip takes to settle after a gesture: longer the further it has left to go, so that a short way home
|
||||
* is not crossed at the speed of a whole step and a long one does not snap.
|
||||
*/
|
||||
const settleMs = (distance: number) => Math.round(260 + 260 * Math.min(1, distance));
|
||||
/** An iPhone's portrait shape, for a run with no screenshot sizes at all. */
|
||||
const FALLBACK_SIZE: ScreenshotSize = { imageWidth: 390, imageHeight: 844 };
|
||||
|
||||
export type ScreensFilmstripProps = {
|
||||
/** The screens shown, in the tree's order. */
|
||||
order: readonly string[];
|
||||
/** The screen in the middle. */
|
||||
focusedId: string;
|
||||
selectedId?: string | undefined;
|
||||
index: MapIndex;
|
||||
diff?: BuildDiff | undefined;
|
||||
tree: ScreenTree;
|
||||
shape: ScreenTreeIndex;
|
||||
typicalSize?: ScreenshotSize | undefined;
|
||||
/** The element id a screen's frame takes, which the page's arrow keys focus by. */
|
||||
frameId: (id: string) => string;
|
||||
/** The tree's dot class for a screen: its status, shown beside its name as the grid and the tree show it. */
|
||||
dot: (id: string) => string | undefined;
|
||||
dimmed: (id: string) => boolean;
|
||||
/** Brings a screen to the middle without opening the Inspector; `replace` keeps it out of the history. */
|
||||
onPick: (id: string, options?: { replace?: boolean }) => void;
|
||||
/** Selects a screen and opens it in the Inspector, as a click on its card does. */
|
||||
onOpen: (id: string) => void;
|
||||
/** The phone layout: the middle screen takes most of the width, and a finger swipes the strip. */
|
||||
phone?: boolean | undefined;
|
||||
};
|
||||
|
||||
function labelOf(screen: Screen, index: MapIndex): string {
|
||||
return isLaunchScreen(screen) ? "Cold start" : screenLabel(screen, index);
|
||||
}
|
||||
|
||||
/** The stage's size, which the frames are fitted to. */
|
||||
function useSize(): [(element: HTMLDivElement | null) => void, { width: number; height: number }] {
|
||||
const [element, setElement] = useState<HTMLDivElement | null>(null);
|
||||
const [size, setSize] = useState({ width: 0, height: 0 });
|
||||
useLayoutEffect(() => {
|
||||
if (!element) return;
|
||||
const measure = () => setSize({ width: element.clientWidth, height: element.clientHeight });
|
||||
measure();
|
||||
if (typeof ResizeObserver === "undefined") return;
|
||||
const observer = new ResizeObserver(measure);
|
||||
observer.observe(element);
|
||||
return () => observer.disconnect();
|
||||
}, [element]);
|
||||
return [setElement, size];
|
||||
}
|
||||
|
||||
/**
|
||||
* Screens one at a time: the focused screen large in the middle, the screens before and after it smaller and fainter
|
||||
* the further they are, in the tree's order. Above it, the rows of the tree it was opened from, ending in its name with
|
||||
* its status dot. The neighbours, whose names are not shown, are outlined in their status colour instead.
|
||||
*/
|
||||
export function ScreensFilmstrip(props: ScreensFilmstripProps) {
|
||||
const [stageRef, stage] = useSize();
|
||||
const at = props.order.indexOf(props.focusedId);
|
||||
// While a swipe lasts, the strip sits at a fractional position in `order`, following the gesture.
|
||||
const [swipe, setSwipe] = useState<{ position: number; direction: number } | null>(null);
|
||||
// Once the gesture lets go, the strip eases the rest of the way on a timing of its own (settleMs).
|
||||
const [settling, setSettling] = useState<number | null>(null);
|
||||
const settled = useRef<ReturnType<typeof setTimeout>>(undefined);
|
||||
// The swipe's position as of the last wheel event, which can arrive before the render that shows the one before it.
|
||||
const live = useRef<number | null>(null);
|
||||
// A finger on the strip: where it went down, the strip's position then, and its latest speed in px/ms.
|
||||
const touch = useRef<{ id: number; x: number; from: number; lastX: number; lastAt: number; velocity: number; moved: boolean } | null>(null);
|
||||
// A swipe ends with the finger lifting over a screen; the click that follows is not a tap on it.
|
||||
const swallowClick = useRef(false);
|
||||
const swipeEnd = useRef<ReturnType<typeof setTimeout>>(undefined);
|
||||
useEffect(() => () => { clearTimeout(swipeEnd.current); clearTimeout(settled.current); }, []);
|
||||
// The gesture under way: the screens it has put in the middle, the last of them, and whether it has added its one
|
||||
// history entry. A screen put in the middle by anything else (an arrow key, the tree, a click) ends it.
|
||||
const gesture = useRef<{ shown: string; ids: Set<string>; pushed: boolean; start: number } | null>(null);
|
||||
const focusedNow = useRef(props.focusedId);
|
||||
useEffect(() => { focusedNow.current = props.focusedId; });
|
||||
const focused = props.index.screens.get(props.focusedId);
|
||||
|
||||
// A row of the tree by its fold key, as the path above the frame names it.
|
||||
const rowLabels = useMemo(() => {
|
||||
const labels = new Map<string, string>();
|
||||
const walk = (nodes: readonly ScreenTreeNode[]) => {
|
||||
for (const node of nodes) {
|
||||
if (node.kind === "folder") labels.set(node.id, node.label);
|
||||
else {
|
||||
const screen = props.index.screens.get(node.screenId);
|
||||
if (screen) labels.set(treeNodeKey(node), labelOf(screen, props.index));
|
||||
}
|
||||
walk(node.children);
|
||||
}
|
||||
};
|
||||
walk(props.tree.tree);
|
||||
return labels;
|
||||
}, [props.index, props.tree]);
|
||||
|
||||
if (!focused || at < 0) return null;
|
||||
|
||||
const sizeOf = (screen: Screen) => screenshotSize(primaryScreenshotForScreen(screen, props.index)) ?? props.typicalSize ?? FALLBACK_SIZE;
|
||||
const aspect = (screen: Screen) => {
|
||||
const size = sizeOf(screen);
|
||||
return size.imageWidth / size.imageHeight;
|
||||
};
|
||||
// Every frame is laid out as the middle one would be, filling the stage's height short of growing wider than half
|
||||
// the stage (on a phone, most of it, with the neighbours peeking in at the sides), so a landscape capture beside portrait ones is as wide as it may be rather than as tall; then it is scaled
|
||||
// down around its centre, and the centres are spaced so the scaled frames sit a gap apart, the gap shrinking with them.
|
||||
const frameSize = (screen: Screen) => {
|
||||
const height = Math.max(0, Math.min(stage.height - 16, (stage.width * (props.phone ? 0.7 : 0.5)) / aspect(screen)));
|
||||
return { width: height * aspect(screen), height };
|
||||
};
|
||||
// Where each screen sits with the screen at `centre` in the middle: its distance and its centre's offset.
|
||||
const layout = (centre: number) => {
|
||||
const placed = new Map<string, { distance: number; x: number }>();
|
||||
const middle = props.index.screens.get(props.order[centre] ?? "");
|
||||
if (!middle) return placed;
|
||||
placed.set(props.order[centre]!, { distance: 0, x: 0 });
|
||||
for (const direction of [-1, 1]) {
|
||||
let edge = frameSize(middle).width / 2;
|
||||
for (let distance = 1; distance < SCALES.length; distance++) {
|
||||
const id = props.order[centre + direction * distance];
|
||||
const screen = id ? props.index.screens.get(id) : undefined;
|
||||
if (!id || !screen) break;
|
||||
const scaled = frameSize(screen).width * SCALES[distance]!;
|
||||
const x = edge + GAP * SCALES[distance]! + scaled / 2;
|
||||
placed.set(id, { distance, x: direction * x });
|
||||
edge = x + scaled / 2;
|
||||
}
|
||||
}
|
||||
return placed;
|
||||
};
|
||||
// A swipe someone else's step overtook (an arrow key, a click) no longer places the strip.
|
||||
const swiping = swipe !== null && Math.round(swipe.position) === at;
|
||||
const position = swiping ? swipe.position : at;
|
||||
const base = Math.floor(position), fraction = position - base;
|
||||
const from = layout(base), to = fraction > 0 ? layout(base + 1) : from;
|
||||
const lerp = (a: number, b: number) => a + (b - a) * fraction;
|
||||
const last = SCALES.length - 1;
|
||||
// In the strip's order, so the frames' elements keep their order in the page as the middle changes: React moves an
|
||||
// element that changes place among its siblings, and a moved element jumps instead of easing to where it goes.
|
||||
const placeOf = new Map(props.order.map((id, place) => [id, place]));
|
||||
const frames = [...new Set([...from.keys(), ...to.keys()])].sort((a, b) => placeOf.get(a)! - placeOf.get(b)!).flatMap(id => {
|
||||
const screen = props.index.screens.get(id);
|
||||
if (!screen) return [];
|
||||
const a = from.get(id), b = to.get(id);
|
||||
// A screen in only one of the two places is coming in or going out at the invisible end.
|
||||
const distance = lerp(a?.distance ?? last, b?.distance ?? last);
|
||||
const x = lerp(a?.x ?? b!.x, b?.x ?? a!.x);
|
||||
const scale = lerp(SCALES[a?.distance ?? last]!, SCALES[b?.distance ?? last]!);
|
||||
const opacity = lerp(OPACITIES[a?.distance ?? last]!, OPACITIES[b?.distance ?? last]!);
|
||||
return [{ id, screen, distance, x, scale, opacity, ...frameSize(screen) }];
|
||||
});
|
||||
// The frames' gap at rest, which one screen of swipe travels.
|
||||
const pitch = Math.abs(layout(at).get(props.order[at + 1] ?? props.order[at - 1] ?? "")?.x ?? frameSize(focused).width) || 1;
|
||||
|
||||
const clamp = (value: number) => Math.max(0, Math.min(props.order.length - 1, value));
|
||||
const abandon = () => { clearTimeout(swipeEnd.current); gesture.current = null; live.current = null; };
|
||||
const overtaken = () => !gesture.current || !gesture.current.ids.has(focusedNow.current);
|
||||
// Where a gesture starts: where the one under way has the strip, or the screen in the middle for a new one.
|
||||
const begin = (): number => {
|
||||
if (!overtaken() && live.current !== null) return live.current;
|
||||
abandon();
|
||||
const index = props.order.indexOf(focusedNow.current);
|
||||
const start = index < 0 ? at : index;
|
||||
gesture.current = { shown: focusedNow.current, ids: new Set([focusedNow.current]), pushed: false, start };
|
||||
return start;
|
||||
};
|
||||
// Puts a screen in the middle for the gesture: its first pick is one step back in the history, the rest replace it.
|
||||
const show = (id: string) => {
|
||||
const current = gesture.current;
|
||||
if (!current || id === current.shown) return;
|
||||
current.shown = id; current.ids.add(id);
|
||||
props.onPick(id, current.pushed ? { replace: true } : undefined);
|
||||
current.pushed = true;
|
||||
};
|
||||
// Puts the strip at `next` while a gesture lasts; the middle screen, and with it the path above, follows the swipe as
|
||||
// it passes halfway.
|
||||
const moveTo = (next: number, direction: number) => {
|
||||
live.current = next;
|
||||
setSwipe({ position: next, direction });
|
||||
show(props.order[Math.round(next)]!);
|
||||
};
|
||||
// When the gesture ends, the strip settles on the next screen in its direction once it is SWIPE_COMMIT of the way
|
||||
// there; `next` may be ahead of where the strip is, carried on by a flick.
|
||||
const settle = (next: number, direction: number) => {
|
||||
if (overtaken()) { abandon(); setSwipe(null); return; }
|
||||
const index = clamp(direction > 0 ? Math.floor(next + 1 - SWIPE_COMMIT) : direction < 0 ? Math.ceil(next - 1 + SWIPE_COMMIT) : Math.round(next));
|
||||
show(props.order[index]!);
|
||||
gesture.current = null;
|
||||
const ms = settleMs(Math.abs(index - (live.current ?? next)));
|
||||
clearTimeout(settled.current);
|
||||
setSettling(ms);
|
||||
settled.current = setTimeout(() => setSettling(null), ms);
|
||||
live.current = null;
|
||||
setSwipe(null);
|
||||
};
|
||||
|
||||
// A swipe along either axis moves the strip with it, so a mouse wheel works as well as a trackpad; it has ended when
|
||||
// its events stop.
|
||||
const onWheel = (event: WheelEvent) => {
|
||||
// A pinch arrives as a wheel with Control held; it zooms the page, not the strip.
|
||||
if (event.ctrlKey) return;
|
||||
const delta = Math.abs(event.deltaX) > Math.abs(event.deltaY) ? event.deltaX : event.deltaY;
|
||||
const pixels = event.deltaMode === 1 ? delta * 16 : event.deltaMode === 2 ? delta * stage.width : delta;
|
||||
if (!pixels) return;
|
||||
const next = clamp(begin() + pixels / pitch);
|
||||
// The way the whole swipe went, not its last event: momentum's last 1px back must not turn a swipe around.
|
||||
const direction = Math.sign(next - gesture.current!.start) || Math.sign(pixels);
|
||||
moveTo(next, direction);
|
||||
clearTimeout(swipeEnd.current);
|
||||
swipeEnd.current = setTimeout(() => settle(next, direction), SWIPE_END_MS);
|
||||
};
|
||||
|
||||
// A finger drags the strip under it; on lifting, a flick carries it on by its speed before it settles. A mouse
|
||||
// keeps its clicks and wheel.
|
||||
const onPointerDown = (event: PointerEvent) => {
|
||||
// A browser that sent no click after the last swipe must not have this press's click swallowed, by finger or mouse.
|
||||
swallowClick.current = false;
|
||||
// A touch whose end never reached the strip (it slid off before it moved enough to be held) gives way to this one.
|
||||
if (event.pointerType === "mouse" || touch.current?.id === event.pointerId) return;
|
||||
touch.current = { id: event.pointerId, x: event.clientX, from: begin(), lastX: event.clientX, lastAt: event.timeStamp, velocity: 0, moved: false };
|
||||
};
|
||||
const onPointerMove = (event: PointerEvent) => {
|
||||
const current = touch.current;
|
||||
if (!current || current.id !== event.pointerId) return;
|
||||
const dx = event.clientX - current.x;
|
||||
if (!current.moved && Math.abs(dx) < TAP_SLOP_PX) return;
|
||||
// A wheel swipe's settle waits until the finger takes over; a tap leaves it to settle.
|
||||
if (!current.moved) { current.moved = true; clearTimeout(swipeEnd.current); event.currentTarget.setPointerCapture(event.pointerId); }
|
||||
const elapsed = event.timeStamp - current.lastAt;
|
||||
if (elapsed > 0) current.velocity = (event.clientX - current.lastX) / elapsed;
|
||||
current.lastX = event.clientX; current.lastAt = event.timeStamp;
|
||||
moveTo(clamp(current.from - dx / pitch), -Math.sign(dx));
|
||||
};
|
||||
const onPointerEnd = (event: PointerEvent) => {
|
||||
const current = touch.current;
|
||||
if (!current || current.id !== event.pointerId) return;
|
||||
touch.current = null;
|
||||
if (!current.moved) return;
|
||||
swallowClick.current = true;
|
||||
// A finger that stopped before lifting carries nothing on.
|
||||
const velocity = event.timeStamp - current.lastAt > 80 ? 0 : current.velocity;
|
||||
const next = clamp((live.current ?? position) - (velocity * FLICK_MS) / pitch);
|
||||
settle(next, velocity ? -Math.sign(velocity) : -Math.sign(event.clientX - current.x));
|
||||
};
|
||||
|
||||
const path = (props.shape.ancestors.get(props.focusedId) ?? []).flatMap(key => rowLabels.get(key) ?? []);
|
||||
const plain = props.index.plainTitles || isLaunchScreen(focused);
|
||||
const dot = props.dot(props.focusedId);
|
||||
|
||||
return (
|
||||
<section className={`screens-strip${props.phone ? " phone" : ""}`} aria-label="Filmstrip" onWheel={onWheel}
|
||||
onPointerDown={onPointerDown} onPointerMove={onPointerMove} onPointerUp={onPointerEnd} onPointerCancel={onPointerEnd}
|
||||
onClickCapture={(event) => { if (swallowClick.current) { swallowClick.current = false; event.preventDefault(); event.stopPropagation(); } }}>
|
||||
<div className="screens-strip-path">
|
||||
{path.map((label, position) => (
|
||||
<span key={position} className="screens-strip-crumb" title={label}>
|
||||
<span className={`screens-strip-crumb-label${plain ? "" : " path"}`}>{label}</span>
|
||||
<ChevronRight aria-hidden="true" />
|
||||
</span>
|
||||
))}
|
||||
<span className="screens-strip-crumb current" title={labelOf(focused, props.index)}>
|
||||
{dot ? <span className={`screens-tree-dot ${dot}`} aria-hidden="true" /> : null}
|
||||
<span className={`screens-strip-crumb-label${plain ? "" : " path"}`}>{labelOf(focused, props.index)}</span>
|
||||
</span>
|
||||
</div>
|
||||
|
||||
<div ref={stageRef} className={`screens-strip-stage${swiping ? " swiping" : settling ? " settling" : ""}`}
|
||||
style={settling ? ({ "--strip-settle-ms": `${settling}ms` } as CSSProperties) : undefined}>
|
||||
{stage.width > 0 ? frames.map(({ id, screen, distance, x, scale, opacity, width, height }) => {
|
||||
const artifact = primaryScreenshotForScreen(screen, props.index);
|
||||
const url = artifactUrl(artifact);
|
||||
const size = screenshotSize(artifact);
|
||||
const placeholder = <span className="screens-strip-placeholder" aria-hidden="true" />;
|
||||
const frameDiff = props.diff?.screens.get(id);
|
||||
const label = labelOf(screen, props.index);
|
||||
const middle = id === props.focusedId;
|
||||
const hidden = opacity === 0;
|
||||
return (
|
||||
<div key={id} id={props.frameId(id)} data-screen-id={id}
|
||||
className={`screens-strip-frame${middle ? " focused" : ""}${frameDiff ? ` ${diffClass(frameDiff)}` : ""}${props.dimmed(id) ? " dimmed" : ""}`}
|
||||
style={{
|
||||
width,
|
||||
height,
|
||||
opacity,
|
||||
zIndex: Math.round((SCALES.length - distance) * 10),
|
||||
transform: `translate(-50%, -50%) translateX(${x}px) scale(${scale})`,
|
||||
}}>
|
||||
{/* Only the middle frame is in the tab order: the arrows step the strip, and focus on a neighbour the stage
|
||||
clips would scroll it off its centre. */}
|
||||
<button type="button" className="screens-strip-target" aria-label={label} title={middle ? undefined : label}
|
||||
tabIndex={middle ? undefined : -1} aria-hidden={hidden || undefined} disabled={hidden}
|
||||
aria-pressed={props.selectedId === id} aria-current={middle ? "true" : undefined}
|
||||
onClick={() => (middle ? props.onOpen(id) : props.onPick(id))}>
|
||||
{/* A downloaded report's screenshot is a reference that ScreenshotImage resolves. */}
|
||||
{url ? (
|
||||
<ScreenshotImage src={url} alt="" draggable={false} decoding="async" loading={distance <= 1.5 ? "eager" : "lazy"}
|
||||
{...(size ? { width: size.imageWidth, height: size.imageHeight } : {})} fallback={placeholder} />
|
||||
) : placeholder}
|
||||
</button>
|
||||
</div>
|
||||
);
|
||||
}) : null}
|
||||
</div>
|
||||
</section>
|
||||
);
|
||||
}
|
||||
@@ -55,48 +55,65 @@
|
||||
border-radius: 14px;
|
||||
background: var(--side-panel-surface);
|
||||
}
|
||||
.screens-tree > h2 {
|
||||
margin: 0;
|
||||
padding: 4px 8px 10px;
|
||||
color: var(--tertiary);
|
||||
font-family: "JetBrains Mono", ui-monospace, SFMono-Regular, Menlo, monospace;
|
||||
font-size: 11px;
|
||||
font-weight: 600;
|
||||
letter-spacing: 0.04em;
|
||||
}
|
||||
.screens-tree ul { margin: 0; padding: 0; list-style: none; }
|
||||
/* Changed / All filter the tree and the grid alike, so they sit in the tree's head as one segmented control,
|
||||
beside the button that folds or unfolds every folder. */
|
||||
/* One height in every state (chips, the find field, or only the icons), so opening the find does not move the tree. */
|
||||
.screens-tree-head { display: flex; height: 34px; flex: none; align-items: center; gap: 6px; margin: 0 0 10px; }
|
||||
.screens-tree-head > .screens-filter {
|
||||
flex: 1;
|
||||
/* The tree's head: the find field, with fold-all beside it. */
|
||||
.screens-tree-head { display: flex; height: 34px; flex: none; align-items: center; gap: 4px; margin: 0 0 8px; }
|
||||
/* Changed / All filter the tree and the grid alike: one segmented control under the head, the tree's width. */
|
||||
.screens-tree > .screens-filter {
|
||||
flex: none;
|
||||
gap: 2px;
|
||||
margin: 0 0 10px;
|
||||
padding: 3px;
|
||||
border-radius: 9px;
|
||||
background: var(--element);
|
||||
}
|
||||
.screens-tree-fold-all {
|
||||
.screens-tree-fold-all,
|
||||
.screens-side-toggle {
|
||||
display: grid;
|
||||
width: 32px;
|
||||
height: 32px;
|
||||
flex: none;
|
||||
margin-left: auto;
|
||||
place-items: center;
|
||||
border-radius: 8px;
|
||||
color: var(--secondary);
|
||||
background: transparent;
|
||||
}
|
||||
.screens-tree-fold-all:hover { color: var(--text); background: var(--panel-hover); }
|
||||
.screens-tree-fold-all > svg { width: 16px; height: 16px; }
|
||||
.screens-tree-head > .screens-filter .screens-chip {
|
||||
.screens-tree-fold-all { margin-left: auto; }
|
||||
.screens-tree-fold-all:hover,
|
||||
.screens-side-toggle:hover { color: var(--text); background: var(--panel-hover); }
|
||||
.screens-tree-fold-all > svg,
|
||||
.screens-side-toggle > svg { width: 16px; height: 16px; }
|
||||
/* Folded, the sidebar is only the button that opens it, on the tree's surface at the tree's top. */
|
||||
.screens-side.collapsed { width: auto; }
|
||||
.screens-side.collapsed > .screens-side-toggle {
|
||||
width: 36px;
|
||||
height: 36px;
|
||||
border: 1px solid var(--border-subtle);
|
||||
border-radius: 10px;
|
||||
background: var(--side-panel-surface);
|
||||
}
|
||||
.screens-side.collapsed > .screens-side-toggle:hover { background: var(--panel-hover); }
|
||||
/* Folded under Changed: a dot on the button, in the changed colour, says the screens are narrowed. */
|
||||
.screens-side-toggle.narrowed { position: relative; }
|
||||
.screens-side-toggle.narrowed::after {
|
||||
content: "";
|
||||
position: absolute;
|
||||
top: 6px;
|
||||
right: 6px;
|
||||
width: 7px;
|
||||
height: 7px;
|
||||
border: 1.5px solid var(--side-panel-surface);
|
||||
border-radius: 50%;
|
||||
background: var(--modified);
|
||||
}
|
||||
.screens-tree > .screens-filter .screens-chip {
|
||||
height: 28px;
|
||||
flex: 1;
|
||||
justify-content: center;
|
||||
border-radius: 7px;
|
||||
background: transparent;
|
||||
}
|
||||
.screens-tree-head > .screens-filter .screens-chip[aria-pressed="true"] { background: var(--selected); }
|
||||
.screens-tree > .screens-filter .screens-chip[aria-pressed="true"] { background: var(--selected); }
|
||||
.screens-tree-row {
|
||||
display: flex;
|
||||
width: 100%;
|
||||
@@ -318,6 +335,21 @@ button.screens-tree-row:hover { color: var(--text); background: var(--panel-hove
|
||||
.screens-jump-chip > svg { width: 14px; height: 14px; }
|
||||
.screens-jump-chip .path { font-family: var(--screens-mono); }
|
||||
.screens-page.phone .screens-body { display: block; margin: 0; }
|
||||
/* Grid or Filmstrip as two icons at the end of the Changed / All row. */
|
||||
.screens-page.phone .screens-head { display: flex; align-items: center; gap: 8px; }
|
||||
.screens-layout-toggle { display: inline-flex; flex: none; gap: 2px; margin-left: auto; padding: 3px; border-radius: 999px; background: var(--element); }
|
||||
.screens-layout-toggle > button { display: grid; width: 40px; height: 28px; place-items: center; border-radius: 999px; color: var(--secondary); }
|
||||
.screens-layout-toggle > button[aria-pressed="true"] { color: var(--text); background: var(--selected); }
|
||||
.screens-layout-toggle svg { width: 16px; height: 16px; }
|
||||
/* The phone's filmstrip fills what the bars leave: the head and the Tree button above it, the tab bar below. */
|
||||
.screens-page.phone.filmstrip { display: flex; flex-direction: column; overflow: hidden; }
|
||||
.screens-page.phone.filmstrip::before,
|
||||
.screens-page.phone.filmstrip :is(.screens-head, .screens-jump) { flex: none; }
|
||||
.screens-page.phone.filmstrip .screens-body { display: flex; min-height: 0; flex: 1; height: auto; }
|
||||
.screens-page.phone.filmstrip .screens-sections { padding: 4px 0 0; }
|
||||
.screens-strip.phone .screens-strip-path { padding: 0 16px; }
|
||||
/* On a phone the fade is narrower, so the neighbours peeking in at the sides stay legible. */
|
||||
.screens-strip.phone .screens-strip-stage { mask-image: linear-gradient(to right, transparent, #000 6%, #000 94%, transparent); }
|
||||
/* Sections flow side by side, as on desktop, so a section of one screen leaves no empty row. Every
|
||||
card takes a fraction of the page width, so cards from neighbouring sections share columns. */
|
||||
.screens-page.phone .screens-sections { container-type: inline-size; gap: 32px 12px; padding: 20px 16px 0; }
|
||||
@@ -339,25 +371,155 @@ button.screens-tree-row:hover { color: var(--text); background: var(--panel-hove
|
||||
.screens-tree.phone .screens-tree-label.path { font-size: var(--phone-body-mono-size); }
|
||||
.screens-tree.phone .screens-tree-kind { font-size: var(--phone-micro-size); }
|
||||
|
||||
/* ── Find: `/` or the magnifier turns the tree's head into a field; the tree and the grid narrow to its matches ── */
|
||||
.screens-tree-head > .tooltip-anchor { display: flex; flex: none; margin-left: auto; }
|
||||
.screens-tree-head > .tooltip-anchor + .screens-tree-fold-all { margin-left: 0; }
|
||||
.screens-tree-find {
|
||||
/* ── Find: the field heading the tree, focused by `/`; the tree and the grid narrow to its matches ── */
|
||||
.screens-find { display: flex; min-width: 0; flex: 1; }
|
||||
.screens-find .panel-search { height: 34px; flex: 1; border-radius: 9px; }
|
||||
/* The key that focuses the field, at its end while it is empty and unfocused. */
|
||||
.screens-find-key {
|
||||
display: grid;
|
||||
width: 32px;
|
||||
height: 32px;
|
||||
min-width: 18px;
|
||||
height: 18px;
|
||||
flex: none;
|
||||
place-items: center;
|
||||
border-radius: 8px;
|
||||
color: var(--secondary);
|
||||
background: transparent;
|
||||
margin-right: 2px;
|
||||
padding: 0 4px;
|
||||
border: 1px solid var(--border-subtle);
|
||||
border-radius: 5px;
|
||||
color: var(--tertiary);
|
||||
background: var(--surface);
|
||||
font: 600 11px/1 var(--screens-mono);
|
||||
}
|
||||
.screens-tree-find:hover { color: var(--text); background: var(--panel-hover); }
|
||||
.screens-tree-find > svg { width: 16px; height: 16px; }
|
||||
.screens-tree-head.searching { gap: 4px; }
|
||||
.screens-find { display: flex; min-width: 0; flex: 1; }
|
||||
.screens-find .panel-search { height: 34px; border-radius: 9px; }
|
||||
.screens-find .panel-search:focus-within .screens-find-key { display: none; }
|
||||
.screens-find-empty { margin: 0; padding: 4px 8px; color: var(--tertiary); font-size: 12px; }
|
||||
.screens-empty { min-height: 240px; flex: 1; }
|
||||
.screens-empty-all { padding: 0; color: var(--accent); font: inherit; background: transparent; }
|
||||
.screens-empty-all:hover { text-decoration-line: underline; text-underline-offset: 3px; }
|
||||
|
||||
/* ── Filmstrip: one screen at a time, its neighbours smaller and fainter on either side ── */
|
||||
/* The page stops scrolling; the strip fills the height between the pill and the bottom toolbar. */
|
||||
.screens-page.filmstrip { overflow: hidden; padding-bottom: calc(84px * var(--ui-scale)); }
|
||||
/* With the sidebar folded, its button floats where the sidebar starts and the strip takes the page's width, with the same
|
||||
gap either side, so the middle screen sits at the centre of the canvas (beside an open Inspector, of what it leaves). */
|
||||
.screens-page.filmstrip.side-folded { padding-left: 28px; }
|
||||
.screens-page.filmstrip.side-folded .screens-side.collapsed {
|
||||
position: absolute;
|
||||
z-index: 3;
|
||||
top: calc(var(--chrome-top) + var(--chrome-height) + 20px);
|
||||
left: var(--canvas-chrome-inline-inset);
|
||||
}
|
||||
/* A sideways swipe steps the strip; it must not also take the browser back a page. */
|
||||
html:has(.screens-page.filmstrip) { overscroll-behavior-x: none; }
|
||||
.screens-page.filmstrip .screens-body { height: 100%; }
|
||||
.screens-page.filmstrip .screens-side { max-height: 100%; }
|
||||
.screens-page.filmstrip .screens-sections { display: flex; height: 100%; flex-wrap: nowrap; align-items: stretch; }
|
||||
.screens-strip { display: flex; min-width: 0; flex: 1; flex-direction: column; align-items: center; gap: 8px; }
|
||||
.screens-strip-path {
|
||||
display: flex;
|
||||
width: 100%;
|
||||
min-height: 28px;
|
||||
flex: none;
|
||||
align-items: center;
|
||||
justify-content: safe center;
|
||||
gap: 6px;
|
||||
overflow: hidden;
|
||||
color: var(--tertiary);
|
||||
font-size: 13px;
|
||||
white-space: nowrap;
|
||||
}
|
||||
/* A long route keeps the path to one line: the screen's name shrinks to an ellipsis, and each row above it is capped
|
||||
at a width of its own. A path still too long is cut at its end, not on both sides. */
|
||||
.screens-strip-crumb { display: inline-flex; min-width: 0; flex: 0 1 auto; align-items: center; gap: 6px; }
|
||||
.screens-strip-crumb:not(.current) { max-width: 160px; flex-shrink: 0; }
|
||||
.screens-strip-crumb > svg { width: 12px; height: 12px; flex: none; opacity: 0.7; }
|
||||
.screens-strip-crumb.current { flex-shrink: 1; gap: 7px; color: var(--text); font-weight: 600; }
|
||||
.screens-strip-crumb.current > .screens-tree-dot { flex: none; }
|
||||
.screens-strip-crumb.current > .screens-tree-dot[class*="diff-"] { background: var(--diff); }
|
||||
.screens-strip-crumb-label { min-width: 0; overflow: hidden; text-overflow: ellipsis; }
|
||||
.screens-strip-crumb-label.path { font-size: 12px; }
|
||||
.screens-strip-stage {
|
||||
position: relative;
|
||||
width: 100%;
|
||||
min-height: 0;
|
||||
flex: 1;
|
||||
overflow: hidden;
|
||||
overflow: clip;
|
||||
/* The outer frames fade out towards the edges rather than being cut off. */
|
||||
mask-image: linear-gradient(to right, transparent, #000 12%, #000 88%, transparent);
|
||||
/* A finger's sideways swipe moves the strip, on any touch screen; an upward one still scrolls the page. */
|
||||
touch-action: pan-y;
|
||||
}
|
||||
.screens-strip-frame {
|
||||
position: absolute;
|
||||
top: 50%;
|
||||
left: 50%;
|
||||
/* A frame's size follows its screenshot's shape, so it eases with the move rather than snapping. */
|
||||
transition: transform 300ms cubic-bezier(0.2, 0.75, 0.2, 1), width 300ms cubic-bezier(0.2, 0.75, 0.2, 1), height 300ms cubic-bezier(0.2, 0.75, 0.2, 1), opacity 300ms ease;
|
||||
will-change: transform;
|
||||
}
|
||||
/* During a swipe the frames follow the gesture directly; they ease only when it lets go and the strip settles. */
|
||||
.screens-strip-stage.swiping .screens-strip-frame { transition: none; }
|
||||
/* After it lets go, the strip eases home from rest: by then the gesture (and a trackpad's momentum) has slowed to
|
||||
nearly nothing, and a curve that starts fast, as a step's does, would jerk it into motion. */
|
||||
.screens-strip-stage.settling .screens-strip-frame {
|
||||
transition-duration: var(--strip-settle-ms);
|
||||
transition-timing-function: cubic-bezier(0.45, 0, 0.2, 1);
|
||||
}
|
||||
@media (prefers-reduced-motion: reduce) { .screens-strip-frame { transition: none; } }
|
||||
.screens-strip-frame.dimmed:not(.focused) { opacity: calc(var(--dim-out) * 0.6) !important; }
|
||||
.screens-strip-target {
|
||||
display: block;
|
||||
width: 100%;
|
||||
height: 100%;
|
||||
overflow: hidden;
|
||||
padding: 0;
|
||||
border: 1px solid var(--border-subtle);
|
||||
border-radius: 14px;
|
||||
background: var(--element);
|
||||
cursor: pointer;
|
||||
}
|
||||
.screens-strip-frame.focused .screens-strip-target {
|
||||
border-color: color-mix(in srgb, var(--text) 30%, var(--border-subtle));
|
||||
box-shadow: 0 24px 48px rgb(0 0 0 / 0.08), 0 2px 6px rgb(0 0 0 / 0.08);
|
||||
cursor: zoom-in;
|
||||
}
|
||||
/* A changed neighbour is outlined in its status colour; the middle screen's status is the dot beside its name. */
|
||||
.screens-strip-frame:not(.focused):is(.diff-added, .diff-modified, .diff-removed, .diff-accessibility-only, .diff-needs-review, .diff-source-affected) .screens-strip-target { outline: 2px solid var(--diff); outline-offset: 2px; }
|
||||
/* Focused by the arrows, the middle frame keeps its screenshot's own colours: the brightening that marks a focused
|
||||
pressed button elsewhere (styles.css) would change what is being reviewed. Being in the middle is its focus. */
|
||||
.screens-page .screens-strip-target:focus-visible { filter: none; }
|
||||
.screens-strip-target img { display: block; width: 100%; height: 100%; object-fit: contain; }
|
||||
.screens-strip-placeholder { display: block; width: 100%; height: 100%; }
|
||||
|
||||
/* ── Layout switch: Grid or Filmstrip, in words, at the top right in the pill's row ── */
|
||||
.screens-layout-switch {
|
||||
position: absolute;
|
||||
z-index: 20;
|
||||
top: var(--chrome-top);
|
||||
right: calc(var(--screens-switch-right, 0px) + var(--canvas-chrome-inline-inset));
|
||||
display: inline-flex;
|
||||
height: var(--chrome-height);
|
||||
align-items: stretch;
|
||||
gap: 2px;
|
||||
padding: calc(3px * var(--ui-scale));
|
||||
border: 1px solid var(--border-subtle);
|
||||
border-radius: calc(10px * var(--ui-scale));
|
||||
background: var(--side-panel-surface);
|
||||
box-shadow: var(--floating-chrome-shadow);
|
||||
}
|
||||
.screens-layout-switch button {
|
||||
display: inline-flex;
|
||||
align-items: center;
|
||||
gap: 7px;
|
||||
padding: 0 12px 0 10px;
|
||||
border-radius: calc(7px * var(--ui-scale));
|
||||
color: var(--secondary);
|
||||
background: transparent;
|
||||
font-size: 13px;
|
||||
font-weight: 500;
|
||||
transition: color 120ms ease, background 120ms ease;
|
||||
}
|
||||
.screens-layout-switch button:hover { color: var(--text); background: var(--panel-hover); }
|
||||
.screens-layout-switch button[aria-pressed="true"] { color: var(--text); background: var(--selected); }
|
||||
.screens-layout-switch button > svg { width: 15px; height: 15px; flex: none; }
|
||||
.screens-layout-switch.compact button { padding: 0 9px; }
|
||||
.screens-layout-switch.compact button > span { display: none; }
|
||||
@@ -1,5 +1,5 @@
|
||||
import { useEffect, useMemo, useRef, useState, type CSSProperties, type KeyboardEvent, type ReactNode } from "react";
|
||||
import { ChevronRight, ChevronsDownUp, ChevronsUpDown, ListTree, Search } from "lucide-react";
|
||||
import { useEffect, useMemo, useRef, useState, type CSSProperties, type KeyboardEvent, type MouseEvent as ReactMouseEvent, type ReactNode } from "react";
|
||||
import { ChevronRight, ChevronsDownUp, ChevronsUpDown, GalleryHorizontal, LayoutGrid, ListTree, PanelLeftClose, PanelLeftOpen } from "lucide-react";
|
||||
import { artifactUrl, isLaunchScreen, type ExploreMap, type MapIndex, type Screen } from "../../utils/model";
|
||||
import { primaryScreenshotForScreen, screenshotSize, typicalScreenshotSize, type ScreenshotSize } from "../../utils/screen-images";
|
||||
import { diffClass, type BuildDiff, type DiffStatus } from "../../utils/build-diff";
|
||||
@@ -7,8 +7,8 @@ import { focusStatusOf, isCapturedChange } from "../../utils/changed-screens";
|
||||
import { displayPathForScreen, screenLabel } from "../../utils/screen-path";
|
||||
import { screenTree, treeIndex, treeNodeKey, treeScreenOrder, type ScreenTree, type ScreenTreeNode } from "../../utils/screen-tree";
|
||||
import type { Appearance } from "../../utils/appearance";
|
||||
import type { FocusRequest, FocusStatus } from "../../utils/navigation";
|
||||
import { shortcutsLive } from "../../utils/shortcuts";
|
||||
import type { FocusRequest, FocusStatus, ScreensLayout } from "../../utils/navigation";
|
||||
import { formatShortcut, SHORTCUTS, shortcutsLive } from "../../utils/shortcuts";
|
||||
import { normalizeSearchText } from "../../utils/search";
|
||||
import { createKeyHold } from "../../utils/key-hold";
|
||||
import { placeholderScreen } from "../../utils/map-frame";
|
||||
@@ -19,6 +19,7 @@ import { useCanvasVisibleFrame } from "../canvas/visible-frame-provider";
|
||||
import { PhoneSheet } from "../phone/phone-chrome";
|
||||
import { PanelSearch } from "../shared/panel-search";
|
||||
import { Tooltip } from "../shared/tooltip";
|
||||
import { ScreensFilmstrip } from "./screens-filmstrip";
|
||||
import "./screens.css";
|
||||
|
||||
/** The statuses a tree dot marks. The Changed filter keeps only the screens whose captures differ (isCapturedChange). */
|
||||
@@ -49,9 +50,15 @@ export type ScreensViewProps = {
|
||||
onFindRequestDone?: (() => void) | undefined;
|
||||
onSelectScreen: (id: string) => void;
|
||||
/** The tree and jump bar pick a screen without opening the Inspector; a screenshot click selects it as the canvas does. */
|
||||
onPickScreen?: ((id: string) => void) | undefined;
|
||||
onPickScreen?: ((id: string, options?: { replace?: boolean }) => void) | undefined;
|
||||
/** A click on the page around the cards clears the selection, as a click on a canvas's pane does. */
|
||||
onClearSelection?: (() => void) | undefined;
|
||||
/** Every card in a grid, or one screen at a time in a filmstrip. */
|
||||
layout?: ScreensLayout | undefined;
|
||||
/** A double-click on a card opens it in the filmstrip. */
|
||||
onChangeLayout?: ((layout: ScreensLayout) => void) | undefined;
|
||||
/** Closes the Inspector the first click of a double-click opened; in the filmstrip a click on its middle screen opens it. */
|
||||
onCloseInspector?: (() => void) | undefined;
|
||||
};
|
||||
|
||||
function statusOf(diff: BuildDiff | undefined, id: string): DiffStatus | undefined {
|
||||
@@ -85,6 +92,27 @@ function writeFolded(key: string, folded: ReadonlySet<string>): void {
|
||||
} catch { /* Folds last for this visit only. */ }
|
||||
}
|
||||
|
||||
/**
|
||||
* The canvas widths below which the layout switch drops its labels, and below which it is hidden: the pill at the top
|
||||
* left grows to 420px (`--left-collapsed-pill-width`), and the switch keeps clear of it, labelled or not.
|
||||
*/
|
||||
const SWITCH_LABELLED_FRAME_WIDTH = 640;
|
||||
const SWITCH_MINIMUM_FRAME_WIDTH = 540;
|
||||
|
||||
/** How soon, and how near, a second click follows the first to make a double-click that opens a card in the filmstrip. */
|
||||
const DOUBLE_CLICK_MS = 500;
|
||||
const DOUBLE_CLICK_SLOP_PX = 8;
|
||||
|
||||
/** A shown screen to stand for `selected`: itself, or the nearest shown screen after it in the tree, else before it. */
|
||||
function nearestShown(selected: string | undefined, shown: readonly string[], tree: readonly string[]): string | undefined {
|
||||
if (!selected) return undefined;
|
||||
if (shown.includes(selected)) return selected;
|
||||
const at = tree.indexOf(selected);
|
||||
if (at < 0) return undefined;
|
||||
const set = new Set(shown);
|
||||
return tree.slice(at + 1).find(id => set.has(id)) ?? tree.slice(0, at).reverse().find(id => set.has(id));
|
||||
}
|
||||
|
||||
/** The key that opens the find field: a character, not a key position, so it is read from the layout like "?". */
|
||||
export const FIND_KEY = "/";
|
||||
|
||||
@@ -159,7 +187,7 @@ function ScreenCell(props: {
|
||||
typicalSize?: ScreenshotSize | undefined;
|
||||
/** A phone's cell, whose screenshot is its own frame: no well frames it while it loads. */
|
||||
phone?: boolean | undefined;
|
||||
onSelect: () => void;
|
||||
onSelect: (event: ReactMouseEvent) => void;
|
||||
}) {
|
||||
const artifact = primaryScreenshotForScreen(props.screen, props.index);
|
||||
const url = artifactUrl(artifact);
|
||||
@@ -272,8 +300,9 @@ function Legend(props: { others: Appearance[] }) {
|
||||
}
|
||||
|
||||
/**
|
||||
* Screens as a page that scrolls. On desktop, one grid of every screen in the order of the tree beside it; on a
|
||||
* phone, a section per route folder (or per tab, when there are no route files), with the tree behind a Tree button.
|
||||
* Screens as a page that scrolls. On desktop, one grid of every screen in the order of the tree beside it; on a phone,
|
||||
* a section per route folder (or per tab, when there are no route files), with the tree behind a Tree button. Either
|
||||
* can show the same screens one at a time in a filmstrip (screens-filmstrip.tsx), which a finger swipes on a phone.
|
||||
*/
|
||||
export function ScreensView(props: ScreensViewProps) {
|
||||
// The report's screens, as the Map draws them: a public report's routes it never captured are not among them.
|
||||
@@ -295,10 +324,9 @@ export function ScreensView(props: ScreensViewProps) {
|
||||
const [filter, setFilter] = useState<Filter>(props.phone && changedIds.size > 0 ? "changed" : "all");
|
||||
const [treeOpen, setTreeOpen] = useState(false);
|
||||
// Find: a query narrows the tree and the grid to the screens whose route or title contains it, inside Changed or All.
|
||||
const [findOpen, setFindOpen] = useState(false);
|
||||
const [query, setQuery] = useState("");
|
||||
// The phone layout has no field to show or clear a query, so a query typed on desktop does not narrow it.
|
||||
const findQuery = findOpen && !props.phone ? query : "";
|
||||
const findQuery = props.phone ? "" : query;
|
||||
const matches = useMemo(() => findMatches(screens, props.index, findQuery), [props.index, screens, findQuery]);
|
||||
const inChanged = filter === "changed" && changedIds.size > 0;
|
||||
const inFilter = inChanged ? changedIds : new Set(screens.map(screen => screen.id));
|
||||
@@ -310,6 +338,23 @@ export function ScreensView(props: ScreensViewProps) {
|
||||
const treeOrder = useMemo(() => treeScreenOrder(tree), [tree]);
|
||||
const order = props.phone ? sections.flatMap(section => section.screenIds) : treeOrder.filter(id => shown.has(id));
|
||||
const others = [...new Set([...(props.changedElsewhere?.values() ?? [])].flat())];
|
||||
const filmstrip = props.layout === "filmstrip";
|
||||
// The filmstrip always has a screen in the middle: the selection when it is shown; else, when Changed or a find hides
|
||||
// it, the nearest shown screen after it in the tree (before it, at the end), as the grid's arrows step from it; else
|
||||
// the first screen.
|
||||
const stripFocus = filmstrip ? nearestShown(props.selectedScreenId, order, treeOrder) ?? order[0] : undefined;
|
||||
// The sidebar folds away to give the screens its width. Each switch of layout starts over: the filmstrip with the
|
||||
// sidebar folded, the grid with it open. A find's query lives only in the sidebar's field, so the sidebar stays open
|
||||
// while one narrows the screens. Changed folds away with it, and the button left in its place says it is on.
|
||||
const [side, setSide] = useState({ filmstrip, collapsed: filmstrip && !findQuery });
|
||||
if (side.filmstrip !== filmstrip) setSide({ filmstrip, collapsed: filmstrip && !findQuery });
|
||||
const sideCollapsed = side.filmstrip === filmstrip ? side.collapsed : filmstrip && !findQuery;
|
||||
const setSideCollapsed = (collapsed: boolean) => setSide({ filmstrip, collapsed });
|
||||
// A button that folds or opens the sidebar is replaced by the other one; the keyboard moves to it.
|
||||
const toggleSide = (collapsed: boolean) => {
|
||||
setSideCollapsed(collapsed);
|
||||
requestAnimationFrame(() => document.querySelector<HTMLElement>(".screens-side .screens-side-toggle")?.focus());
|
||||
};
|
||||
|
||||
// Folding. All keeps the reader's folds and remembers them per report. Changed folds separately, starting
|
||||
// each time with only the rows that hold no change folded, so trying Changed never disturbs the folds in All.
|
||||
@@ -363,49 +408,54 @@ export function ScreensView(props: ScreensViewProps) {
|
||||
setTreeOpen(false);
|
||||
if (!inFilter.has(id)) setFilter("all");
|
||||
(props.onPickScreen ?? props.onSelectScreen)(id);
|
||||
requestAnimationFrame(() => document.getElementById(cardId(id))?.scrollIntoView({ block: "center", behavior: "smooth" }));
|
||||
// The filmstrip brings the screen to its middle itself.
|
||||
if (!filmstrip) requestAnimationFrame(() => document.getElementById(cardId(id))?.scrollIntoView({ block: "center", behavior: "smooth" }));
|
||||
};
|
||||
|
||||
const findField = useRef<HTMLDivElement>(null);
|
||||
const focusFind = () => findField.current?.querySelector("input")?.focus();
|
||||
// `/` focuses the field, deferred a frame so the key itself is not typed into it. A folded sidebar opens first.
|
||||
const findOnOpen = useRef(false);
|
||||
const openFind = () => {
|
||||
setFindOpen(true);
|
||||
requestAnimationFrame(focusFind);
|
||||
if (!sideCollapsed) {
|
||||
requestAnimationFrame(focusFind);
|
||||
return;
|
||||
}
|
||||
findOnOpen.current = true;
|
||||
setSideCollapsed(false);
|
||||
};
|
||||
useEffect(() => {
|
||||
if (sideCollapsed || !findOnOpen.current) return;
|
||||
findOnOpen.current = false;
|
||||
requestAnimationFrame(focusFind);
|
||||
}, [sideCollapsed]);
|
||||
const closeFind = () => {
|
||||
setQuery("");
|
||||
setFindOpen(false);
|
||||
// The field took the keyboard; hand it back to the page so its arrows work again.
|
||||
if (document.activeElement instanceof HTMLElement) document.activeElement.blur();
|
||||
};
|
||||
// `/` from another canvas lands here with the field open.
|
||||
// `/` from another canvas lands here with the field focused.
|
||||
useEffect(() => {
|
||||
if (props.findRequest === undefined) return;
|
||||
if (!props.phone) openFind();
|
||||
props.onFindRequestDone?.();
|
||||
// eslint-disable-next-line react-hooks/exhaustive-deps -- a new request opens it once
|
||||
// eslint-disable-next-line react-hooks/exhaustive-deps -- a new request focuses it once
|
||||
}, [props.findRequest]);
|
||||
const findButton = props.phone ? null : (
|
||||
<Tooltip label="Find a screen" shortcut={FIND_KEY} placement="bottom">
|
||||
<button type="button" className="screens-tree-find" aria-label="Find a screen" onClick={openFind}>
|
||||
<Search aria-hidden="true" />
|
||||
</button>
|
||||
</Tooltip>
|
||||
);
|
||||
const findSearch = findOpen ? (
|
||||
// The find field heads the tree on desktop.
|
||||
const findSearch = props.phone ? null : (
|
||||
<div ref={findField} className="screens-find">
|
||||
<PanelSearch
|
||||
value={query}
|
||||
placeholder="Find…"
|
||||
placeholder="Search"
|
||||
ariaLabel="Find screens"
|
||||
clearLabel="Clear find query"
|
||||
name="screens-find"
|
||||
autoFocus
|
||||
hint={<kbd className="screens-find-key" aria-hidden="true">{FIND_KEY}</kbd>}
|
||||
onEscape={() => (query ? setQuery("") : closeFind())}
|
||||
onChange={setQuery}
|
||||
/>
|
||||
</div>
|
||||
) : null;
|
||||
);
|
||||
const filterChips = changedIds.size > 0 ? (
|
||||
<div className="screens-filter" role="group" aria-label="Show">
|
||||
{(["changed", "all"] as const).map((value) => (
|
||||
@@ -424,6 +474,7 @@ export function ScreensView(props: ScreensViewProps) {
|
||||
// A selection made elsewhere (search, the map, the Inspector) scrolls its card to the middle of
|
||||
// the page, as a pick in the tree does; a card already in view stays put.
|
||||
const scroller = useRef<HTMLElement>(null);
|
||||
const cardClick = useRef<{ id: string; at: number; x: number; y: number } | undefined>(undefined);
|
||||
const selected = props.selectedScreenId;
|
||||
const focusKey = props.focusRequest?.id === selected ? props.focusRequest?.key : undefined;
|
||||
const selectedShown = selected !== undefined && shown.has(selected);
|
||||
@@ -445,13 +496,13 @@ export function ScreensView(props: ScreensViewProps) {
|
||||
setFoldedChanged(unfold);
|
||||
}, [selected, focusKey, shape]);
|
||||
useEffect(() => {
|
||||
if (!selected || !selectedShown) return;
|
||||
if (!selected || !selectedShown || filmstrip) return;
|
||||
const card = document.getElementById(cardId(selected));
|
||||
if (!card || !scroller.current) return;
|
||||
const bounds = card.getBoundingClientRect();
|
||||
const view = scroller.current.getBoundingClientRect();
|
||||
if (bounds.top < view.top || bounds.bottom > view.bottom) card.scrollIntoView({ block: "center", behavior: "smooth" });
|
||||
}, [selected, selectedShown, focusKey]);
|
||||
}, [selected, selectedShown, focusKey, filmstrip]);
|
||||
|
||||
// On desktop the arrow keys move through the cards: ← and → in their order on the page (`order`), as the arrows step
|
||||
// through screens in Compare, and ↑ and ↓ to the card above or below, by where the cards sit, so they follow the grid
|
||||
@@ -459,13 +510,17 @@ export function ScreensView(props: ScreensViewProps) {
|
||||
// nothing picked, → and ↓ start at the first card, and a pick that Changed hides steps from where it sits in the tree.
|
||||
// The tree's rows keep their arrow keys, and so do the Inspector's controls. Phones are left as they were.
|
||||
// Held, an arrow keeps stepping as Compare's do (key-hold.ts). Return opens the picked screen in the Inspector, as a
|
||||
// click on its card does; on the card itself the button already does.
|
||||
// click on its card does; on the card itself the button already does. In the filmstrip, ← and → step from the screen
|
||||
// in the middle and Return opens it.
|
||||
const orderRef = useRef(order);
|
||||
orderRef.current = order;
|
||||
const treeOrderRef = useRef(treeOrder);
|
||||
treeOrderRef.current = treeOrder;
|
||||
const selectedRef = useRef(selected);
|
||||
selectedRef.current = selected;
|
||||
// In the filmstrip the arrows step from the screen in the middle, which is the pick once there is one.
|
||||
const stripFocusRef = useRef(stripFocus);
|
||||
stripFocusRef.current = stripFocus;
|
||||
const pickRef = useRef(props.onPickScreen ?? props.onSelectScreen);
|
||||
pickRef.current = props.onPickScreen ?? props.onSelectScreen;
|
||||
const openRef = useRef(props.onSelectScreen);
|
||||
@@ -479,6 +534,8 @@ export function ScreensView(props: ScreensViewProps) {
|
||||
const ids = orderRef.current;
|
||||
const vertical = code === "ArrowUp" || code === "ArrowDown";
|
||||
const forward = code === "ArrowRight" || code === "ArrowDown";
|
||||
// The filmstrip is one row.
|
||||
if (vertical && stripFocusRef.current !== undefined) return undefined;
|
||||
if (from && ids.includes(from)) return vertical ? cardInNextRow(from, ids, forward) : ids[ids.indexOf(from) + (forward ? 1 : -1)];
|
||||
if (from && treeOrderRef.current.includes(from)) {
|
||||
// Picked, but hidden by Changed: the nearest shown card past it in the tree's order.
|
||||
@@ -491,7 +548,7 @@ export function ScreensView(props: ScreensViewProps) {
|
||||
};
|
||||
const go = (id: string) => {
|
||||
pickRef.current(id);
|
||||
requestAnimationFrame(() => document.getElementById(cardId(id))?.querySelector<HTMLElement>(".screen-screenshot-target")?.focus({ preventScroll: true }));
|
||||
requestAnimationFrame(() => document.getElementById(cardId(id))?.querySelector<HTMLElement>(".screen-screenshot-target, .screens-strip-target")?.focus({ preventScroll: true }));
|
||||
};
|
||||
// A held arrow keeps stepping from the card the last step landed on, not the lagging pick.
|
||||
const hold = createKeyHold();
|
||||
@@ -520,13 +577,15 @@ export function ScreensView(props: ScreensViewProps) {
|
||||
if (event.target instanceof Element && event.target.matches(".screens-find input")) {
|
||||
if (event.isComposing || event.metaKey || event.ctrlKey || event.altKey || event.shiftKey || event.code === "ArrowLeft" || event.code === "ArrowRight") return;
|
||||
const ids = orderRef.current;
|
||||
const picked = selectedRef.current && ids.includes(selectedRef.current) ? selectedRef.current : undefined;
|
||||
// In the filmstrip they step from the screen in the middle, as the page's arrows do.
|
||||
const picked = stripFocusRef.current ?? (selectedRef.current && ids.includes(selectedRef.current) ? selectedRef.current : undefined);
|
||||
const id = !arrow ? picked ?? ids[0] : next(event.code === "ArrowDown" ? "ArrowRight" : "ArrowLeft", picked);
|
||||
if (!id) return;
|
||||
event.preventDefault();
|
||||
if (!arrow) { openRef.current(id); return; }
|
||||
pickRef.current(id);
|
||||
requestAnimationFrame(() => document.getElementById(cardId(id))?.scrollIntoView({ block: "nearest" }));
|
||||
// The filmstrip brings the screen to its middle itself; scrolling its frame would move the page under it.
|
||||
if (stripFocusRef.current === undefined) requestAnimationFrame(() => document.getElementById(cardId(id))?.scrollIntoView({ block: "nearest" }));
|
||||
return;
|
||||
}
|
||||
// The browser's own repeat of a held arrow would scroll the page under the hold.
|
||||
@@ -535,17 +594,18 @@ export function ScreensView(props: ScreensViewProps) {
|
||||
const target = event.target instanceof Element ? event.target : null;
|
||||
if (!arrow) {
|
||||
// Return on a button or a link presses it; elsewhere on the page it opens the pick.
|
||||
const selectedId = selectedRef.current;
|
||||
const selectedId = stripFocusRef.current ?? selectedRef.current;
|
||||
if (target?.closest("button, a, [role=\"button\"]") || !target?.closest("body") || !selectedId || !orderRef.current.includes(selectedId)) return;
|
||||
if (target !== document.body && !target.closest(".screens-page")) return;
|
||||
event.preventDefault();
|
||||
openRef.current(selectedId);
|
||||
return;
|
||||
}
|
||||
// The page, or the bottom toolbar that Screens was just opened from; its buttons have no arrow keys of their own.
|
||||
const onPage = !target || target === document.body || target.closest(".screens-page, .canvas-toolbar") !== null;
|
||||
// The page, or the bottom toolbar that Screens was just opened from, or the layout switch just used; their buttons
|
||||
// have no arrow keys of their own.
|
||||
const onPage = !target || target === document.body || target.closest(".screens-page, .canvas-toolbar, .screens-layout-switch") !== null;
|
||||
if (!onPage || target?.closest(".screens-tree-list")) return;
|
||||
const id = next(event.code, selectedRef.current);
|
||||
const id = next(event.code, stripFocusRef.current ?? selectedRef.current);
|
||||
if (!id) return;
|
||||
event.preventDefault();
|
||||
go(id);
|
||||
@@ -566,6 +626,29 @@ export function ScreensView(props: ScreensViewProps) {
|
||||
};
|
||||
}, [props.phone]);
|
||||
|
||||
// A double-click on a card's screenshot opens that screen in the filmstrip. The first click selects it and opens the
|
||||
// Inspector, which narrows the grid and can slide over the card, so the second click may land on another card or on
|
||||
// the Inspector: the double-click is heard on the whole document, and the screen opened is the one the first click
|
||||
// picked. The route under a screenshot copies a link and is no click on the card.
|
||||
const openFilmstripRef = useRef<((id: string) => void) | undefined>(undefined);
|
||||
openFilmstripRef.current = !props.phone && !filmstrip && props.onChangeLayout ? (id: string) => {
|
||||
(props.onPickScreen ?? props.onSelectScreen)(id);
|
||||
props.onCloseInspector?.();
|
||||
props.onChangeLayout!("filmstrip");
|
||||
} : undefined;
|
||||
useEffect(() => {
|
||||
const onDoubleClick = (event: MouseEvent) => {
|
||||
const first = cardClick.current;
|
||||
// A double-click elsewhere, or later, is not this card's.
|
||||
if (!first || event.timeStamp - first.at > DOUBLE_CLICK_MS
|
||||
|| Math.hypot(event.clientX - first.x, event.clientY - first.y) > DOUBLE_CLICK_SLOP_PX) return;
|
||||
cardClick.current = undefined;
|
||||
openFilmstripRef.current?.(first.id);
|
||||
};
|
||||
document.addEventListener("dblclick", onDoubleClick);
|
||||
return () => document.removeEventListener("dblclick", onDoubleClick);
|
||||
}, []);
|
||||
|
||||
// The Inspector floats over the right edge; the page keeps its content clear of it.
|
||||
const { visibleFrame } = useCanvasVisibleFrame();
|
||||
const style = !props.phone && visibleFrame
|
||||
@@ -574,6 +657,40 @@ export function ScreensView(props: ScreensViewProps) {
|
||||
|
||||
if (screens.length === 0) return <NoScreens map={props.map} />;
|
||||
|
||||
// Grid or Filmstrip, in words, at the top right where the Map keeps its camera: outside the page, so it stays put
|
||||
// as the grid scrolls, and clear of the Inspector.
|
||||
// A canvas narrowed by the Inspector keeps the switch's icons only, clear of the pill; one too narrow for even those
|
||||
// hides it, as the Map's camera hides (camera-controls.tsx). Esc, a double-click and closing the Inspector remain.
|
||||
const frameWidth = visibleFrame?.width ?? Infinity;
|
||||
const layoutSwitch = !props.phone && props.onChangeLayout && frameWidth >= SWITCH_MINIMUM_FRAME_WIDTH ? (
|
||||
<div className={`screens-layout-switch${frameWidth < SWITCH_LABELLED_FRAME_WIDTH ? " compact" : ""}`} role="group" aria-label="Screens layout"
|
||||
style={visibleFrame ? ({ "--screens-switch-right": `calc(100% - ${visibleFrame.x + visibleFrame.width}px)` } as CSSProperties) : undefined}>
|
||||
{([
|
||||
["grid", "Grid", <LayoutGrid key="grid" aria-hidden="true" />, SHORTCUTS.screens.grid],
|
||||
["filmstrip", "Filmstrip", <GalleryHorizontal key="filmstrip" aria-hidden="true" />, SHORTCUTS.screens.filmstrip],
|
||||
] as const)
|
||||
.map(([value, label, icon, shortcut]) => (
|
||||
<Tooltip key={value} label={label} shortcut={formatShortcut(shortcut)} placement="bottom">
|
||||
<button type="button" aria-label={label} aria-pressed={(filmstrip ? "filmstrip" : "grid") === value}
|
||||
onClick={() => props.onChangeLayout!(value)}>
|
||||
{icon}<span aria-hidden="true">{label}</span>
|
||||
</button>
|
||||
</Tooltip>
|
||||
))}
|
||||
</div>
|
||||
) : null;
|
||||
|
||||
// On a phone the switch is a pair of icons at the end of the Changed / All row.
|
||||
const phoneLayoutSwitch = props.phone && props.onChangeLayout ? (
|
||||
<div className="screens-layout-toggle" role="group" aria-label="Screens layout">
|
||||
{([["grid", "Grid", <LayoutGrid key="grid" aria-hidden="true" />], ["filmstrip", "Filmstrip", <GalleryHorizontal key="filmstrip" aria-hidden="true" />]] as const)
|
||||
.map(([value, label, icon]) => (
|
||||
<button key={value} type="button" aria-label={label} aria-pressed={(filmstrip ? "filmstrip" : "grid") === value}
|
||||
onClick={() => props.onChangeLayout!(value)}>{icon}</button>
|
||||
))}
|
||||
</div>
|
||||
) : null;
|
||||
const dimmed = (id: string) => Boolean(props.focus?.length) && !props.focus!.some((state) => state === focusStatusOf(props.diff?.screens.get(id)));
|
||||
const cell = (id: string) => {
|
||||
const screen = props.index.screens.get(id);
|
||||
return screen ? (
|
||||
@@ -583,11 +700,25 @@ export function ScreensView(props: ScreensViewProps) {
|
||||
typicalSize={typicalSize}
|
||||
phone={props.phone}
|
||||
selected={props.selectedScreenId === id}
|
||||
dimmed={Boolean(props.focus?.length) && !props.focus!.some((state) => state === focusStatusOf(props.diff?.screens.get(id)))}
|
||||
onSelect={() => props.onSelectScreen(id)} />
|
||||
dimmed={dimmed(id)}
|
||||
onSelect={(event) => {
|
||||
// The second click of a double-click selects nothing: it may land on another card the first click's Inspector
|
||||
// moved under the pointer. The first click is kept with its place, for the double-click that follows.
|
||||
if (event.detail >= 2) return;
|
||||
cardClick.current = { id, at: event.timeStamp, x: event.clientX, y: event.clientY };
|
||||
props.onSelectScreen(id);
|
||||
}} />
|
||||
) : null;
|
||||
};
|
||||
|
||||
const strip = stripFocus ? (
|
||||
<ScreensFilmstrip order={order} focusedId={stripFocus} selectedId={props.selectedScreenId}
|
||||
index={props.index} diff={props.diff} tree={tree} shape={shape}
|
||||
typicalSize={typicalSize} frameId={cardId} dimmed={dimmed} phone={props.phone}
|
||||
dot={(id) => dotClass(props.diff, props.changedElsewhere, id)}
|
||||
onPick={props.onPickScreen ?? props.onSelectScreen} onOpen={props.onSelectScreen} />
|
||||
) : null;
|
||||
|
||||
// A find inside Changed can match only screens Changed hides; the empty state says so and offers All.
|
||||
const noMatch = `No ${inChanged ? "changed " : ""}screens match “${findQuery.trim()}”`;
|
||||
const matchedElsewhere = matches && inChanged ? [...matches].filter(id => !inFilter.has(id)).length : 0;
|
||||
@@ -601,20 +732,24 @@ export function ScreensView(props: ScreensViewProps) {
|
||||
);
|
||||
|
||||
return (
|
||||
<main ref={scroller} className={`screens-page${props.phone ? " phone" : ""}`} aria-label="Screens" style={style}
|
||||
<>
|
||||
{layoutSwitch}
|
||||
<main ref={scroller} className={`screens-page${props.phone ? " phone" : ""}${filmstrip ? " filmstrip" : ""}${filmstrip && sideCollapsed && !props.phone ? " side-folded" : ""}`} aria-label="Screens" style={style}
|
||||
onClick={(event) => {
|
||||
if (!props.onClearSelection || !props.selectedScreenId) return;
|
||||
// The filmstrip always shows a screen; clearing the pick there would only jump it back to the first.
|
||||
if (!props.onClearSelection || !props.selectedScreenId || filmstrip) return;
|
||||
if ((event.target as Element).closest("button, a, input, .screens-cell, .screens-side")) return;
|
||||
props.onClearSelection();
|
||||
}}>
|
||||
{props.phone && filterChips ? <div className="screens-head">{filterChips}</div> : null}
|
||||
{props.phone && (filterChips || phoneLayoutSwitch) ? <div className="screens-head">{filterChips}{phoneLayoutSwitch}</div> : null}
|
||||
|
||||
{props.phone ? (
|
||||
<nav className="screens-jump" aria-label="Sections">
|
||||
<button type="button" className="screens-jump-chip tree" onClick={() => setTreeOpen(true)}>
|
||||
<ListTree aria-hidden="true" />Tree
|
||||
</button>
|
||||
{sections.map(section => {
|
||||
{/* The filmstrip's path names where the screen is; the Tree jumps anywhere. */}
|
||||
{filmstrip ? null : sections.map(section => {
|
||||
const dot = section.screenIds.map(id => dotClass(props.diff, props.changedElsewhere, id)).find(Boolean);
|
||||
return (
|
||||
<a key={section.id} className="screens-jump-chip" href={`#${sectionAnchor(section.id)}`}
|
||||
@@ -632,12 +767,29 @@ export function ScreensView(props: ScreensViewProps) {
|
||||
) : null}
|
||||
|
||||
<div className="screens-body">
|
||||
{props.phone ? null : (
|
||||
{props.phone ? null : sideCollapsed ? (
|
||||
<aside className="screens-side collapsed">
|
||||
<button type="button" className={`screens-side-toggle${inChanged ? " narrowed" : ""}`} aria-expanded={false}
|
||||
aria-label={inChanged ? "Show sidebar, showing changed screens only" : "Show sidebar"}
|
||||
title={inChanged ? "Show sidebar · Changed only" : "Show sidebar"}
|
||||
onClick={() => toggleSide(false)}>
|
||||
<PanelLeftOpen aria-hidden="true" />
|
||||
</button>
|
||||
</aside>
|
||||
) : (
|
||||
<aside className="screens-side">
|
||||
<nav className="screens-tree" aria-label={tree.mode === "source" ? "Route files" : "Navigation"}>
|
||||
{findSearch ? <div className="screens-tree-head searching">{findSearch}</div>
|
||||
: filterChips || foldAll || findButton ? <div className="screens-tree-head">{filterChips}{findButton}{foldAll}</div> : null}
|
||||
<h2>{tree.mode === "source" ? "app/" : "Explored app"}</h2>
|
||||
{/* The find field heads the tree with fold-all and the sidebar's own fold beside it, so a report without
|
||||
changes has no empty row; Changed / All follows under it, the whole width, when there are changes. */}
|
||||
<div className="screens-tree-head">
|
||||
{findSearch}{foldAll}
|
||||
{/* Folding the sidebar away clears its find, which would otherwise narrow the screens out of sight. */}
|
||||
<button type="button" className="screens-side-toggle" aria-label="Hide sidebar" title="Hide sidebar" aria-expanded
|
||||
onClick={() => { setQuery(""); toggleSide(true); }}>
|
||||
<PanelLeftClose aria-hidden="true" />
|
||||
</button>
|
||||
</div>
|
||||
{filterChips}
|
||||
{matches && order.length === 0
|
||||
? <p className="screens-find-empty" role="status">{noMatch}</p>
|
||||
: treeRows}
|
||||
@@ -646,7 +798,7 @@ export function ScreensView(props: ScreensViewProps) {
|
||||
</aside>
|
||||
)}
|
||||
<div className="screens-sections">
|
||||
{props.phone ? sections.map(section => (
|
||||
{props.phone ? strip ?? sections.map(section => (
|
||||
<section key={section.id} id={sectionAnchor(section.id)} className="screens-section" aria-label={section.name ?? section.title}>
|
||||
<header className="screens-section-head">
|
||||
<h2>{section.name ?? section.title}</h2>
|
||||
@@ -664,7 +816,7 @@ export function ScreensView(props: ScreensViewProps) {
|
||||
<button type="button" className="screens-empty-all" onPointerDown={(event) => event.preventDefault()}
|
||||
onClick={() => { setFilter("all"); focusFind(); }}>Show all</button></p>
|
||||
: <p>Try part of a route, or press Esc to show every {inChanged ? "changed " : ""}screen.</p>}</div>
|
||||
: <div className="screens-grid">{order.map(cell)}</div>
|
||||
: strip ?? <div className="screens-grid">{order.map(cell)}</div>
|
||||
)}
|
||||
</div>
|
||||
</div>
|
||||
@@ -678,5 +830,6 @@ export function ScreensView(props: ScreensViewProps) {
|
||||
</PhoneSheet>
|
||||
) : null}
|
||||
</main>
|
||||
</>
|
||||
);
|
||||
}
|
||||
@@ -14,6 +14,8 @@ export type FocusStatus = "added" | "modified" | "accessibility-only" | "removed
|
||||
export type InspectView = "session" | "diff";
|
||||
/** Which way the inspector's transition list reads: into the screen, or out of it. */
|
||||
export type TransitionDirection = "in" | "out";
|
||||
/** How Screens lays out its screens: every card in a grid, or one at a time in a filmstrip. */
|
||||
export type ScreensLayout = "grid" | "filmstrip";
|
||||
|
||||
export type Route = {
|
||||
canvas: CanvasView;
|
||||
@@ -35,6 +37,8 @@ export type Route = {
|
||||
focus: FocusStatus[];
|
||||
/** Progressive Map groups the reader explicitly expanded, in stable URL order. */
|
||||
expandedGroups: string[];
|
||||
/** Screens' layout; unset is the grid. Only Screens has one. */
|
||||
layout?: ScreensLayout | undefined;
|
||||
};
|
||||
|
||||
/** What the grammar needs from the app: which baselines exist, and which screens record a route. */
|
||||
@@ -218,11 +222,12 @@ export function canonicalRoute(route: Route, ctx: RouteContext): Route {
|
||||
baseline,
|
||||
focus: compared ? FOCUSES.filter((status) => route.focus.includes(status)) : [],
|
||||
expandedGroups,
|
||||
...(canvas === "screens" && route.layout === "filmstrip" ? { layout: "filmstrip" as const } : {}),
|
||||
};
|
||||
}
|
||||
|
||||
/** The query parameters that mean the same in another target's report of the run. */
|
||||
const PLACE_PARAMS = ["inspect", "dir", "focus"] as const;
|
||||
const PLACE_PARAMS = ["inspect", "dir", "focus", "layout"] as const;
|
||||
|
||||
/**
|
||||
* Where the reader is, as another target's report reads it: the canvas and the screen's route (which resolves to that
|
||||
@@ -291,6 +296,7 @@ export function parseLocation(location: LocationLike, ctx: RouteContext): Route
|
||||
baseline: baseline === null ? ctx.defaultBaseline : baseline === "none" ? "" : baseline,
|
||||
focus,
|
||||
expandedGroups: legacyGraph ? [] : params.getAll("expand"),
|
||||
...(params.get("layout") === "filmstrip" ? { layout: "filmstrip" as const } : {}),
|
||||
}, ctx);
|
||||
}
|
||||
|
||||
@@ -319,6 +325,7 @@ export function formatRoute(route: Route, ctx: RouteContext): string {
|
||||
params.set("baseline", next.baseline === "" ? "none" : next.baseline);
|
||||
}
|
||||
if (next.focus.length > 0) params.set("focus", next.focus.join(","));
|
||||
if (next.layout) params.set("layout", next.layout);
|
||||
|
||||
const search = params.toString().replace(/%2C/gi, ",");
|
||||
return `/${next.canvas}${suffix}${search ? `?${search}` : ""}`;
|
||||
|
||||
@@ -0,0 +1,21 @@
|
||||
import type { ScreensLayout } from "./navigation";
|
||||
|
||||
function storageKey(runId: string): string {
|
||||
return `explore:screens-layout:${runId}`;
|
||||
}
|
||||
|
||||
/** The layout Screens last showed for a report, so opening Screens again shows it; unavailable storage remembers nothing. */
|
||||
export function readScreensLayout(runId: string | undefined): ScreensLayout | undefined {
|
||||
if (!runId) return undefined;
|
||||
try {
|
||||
return localStorage.getItem(storageKey(runId)) === "filmstrip" ? "filmstrip" : undefined;
|
||||
} catch { return undefined; }
|
||||
}
|
||||
|
||||
export function writeScreensLayout(runId: string | undefined, layout: ScreensLayout): void {
|
||||
if (!runId) return;
|
||||
try {
|
||||
if (layout === "filmstrip") localStorage.setItem(storageKey(runId), layout);
|
||||
else localStorage.removeItem(storageKey(runId));
|
||||
} catch { /* The layout lasts for this visit only. */ }
|
||||
}
|
||||
@@ -116,6 +116,11 @@ export const SHORTCUTS = {
|
||||
screens: ctrl("Digit2", "2"),
|
||||
compare: ctrl("Digit3", "3"),
|
||||
},
|
||||
/** Screens only, on desktop: G for the grid and E for the filmstrip, as Lightroom's Library switches Grid and Loupe. */
|
||||
screens: {
|
||||
grid: plain("KeyG", "G"),
|
||||
filmstrip: plain("KeyE", "E"),
|
||||
},
|
||||
/** Compare only. The arrows walk changed screens; J and K walk the changed areas of one. */
|
||||
compare: {
|
||||
previousScreen: plain("ArrowLeft", "←"),
|
||||
|
||||
Reference in new issue
Block a user