Compare commits

..
Author SHA1 Message Date
Brent Vatne 005ca2d0cf Name euxy's PR by its repository in comments 2026-10-15 20:40:11 -07:00
Brent Vatne 05f85ca9d9 Make measured moves exact and never hide a change
Review fixes for measured outlines:

- A region that moved and also changed is not a move: after aligning it by
  the move, three or more pixels still differing by over 140 in any channel
  mean its content changed (re-rasterized text stays under about 125; new
  content is about 200). Colour-only changes are caught per channel.
- Near-tie fits go to the smallest move, so content that is the same all along
  one axis (full-width bars, hairlines) is measured; a second fit nearly as
  good two or more pixels away (repeating content) leaves the region
  unmeasured rather than reporting a wrong direction.
- The vertical search reaches 20 pixels, since drift adds up down long
  screens; sub-pixel offsets come from whole-number steps, so moves up and
  down are judged alike; moves are measured only while the comparison's time
  budget lasts.
- Every region the comparison found is measured, not only the eight it
  publishes, and allRegionsMoved records that all of them moved. The Viewer
  says "Nothing on this screen changed content" only then, and only when no
  other finding remains; it hides only the generic visual finding.
- Each outline carries one number, to a tenth: areas merge only when their
  moves are within a third of each other and span at most half a point
  together, and a moved outline never grows around a changed area.
- The outline and measurement switches keep the choice in memory where
  browser storage is denied, and the Inspector's side-by-side places Before
  outlines too.
2026-10-15 20:35:17 -07:00
Brent Vatne 0240437a4f Label outlines with how far moved areas moved
A layout that grew by a device pixel marks every edge below it as changed, so
an SDK upgrade reads as dozens of modified screens with nothing visible to say
why. CI now measures, for each changed region, the shift that best lines
Before up with After; when one shift explains the region, the report records
it as the region's shift (screenshot pixels, right and down positive). New
text, another colour or a caret is not a move. A move of half a pixel or less
needs a quarter of the difference explained (text re-rasterizes rather than
moves at that size), a larger one 60%, and a best fit at the edge of the search
is rejected, since repeating rows line up with themselves a pitch away.

With Highlight on, the Viewer draws a moved area dashed, where its content is
on each side, labelled with how far it moved ("↑4pt", "↓1–2pt"); areas that
moved together merge into one outline. When every area only moved, What
changed says the layout shifted and how far, in place of the generic visual
finding, and a Show measurements switch there turns the labels off in every
mode. iOS screenshots are one pixel per point; Android's are labelled in
screenshot pixels, since the report does not know the screen's density.
2026-10-15 19:48:19 -07:00
27 changed files with 88 additions and 648 deletions

No files matched your search

+12 -52
View File
@@ -20,49 +20,9 @@ Explore maps your app: a screenshot of every screen, connected by the taps betwe
</details>
## Quick start
## Try it on your app
Review a change to your own app, on your machine. You need an Expo SDK 57+ app with Expo Router or React Navigation, Node.js 24.12+, and EAS Simulator access ([join the waitlist](https://expo.dev/services/simulators)). No API keys, no CI.
From your app's directory:
1. **Make the app buildable on EAS, if it is not yet.**
```sh
npx eas-cli@latest login
npx eas-cli@latest init
```
Then set `ios.bundleIdentifier` in your app config, add a simulator profile to `eas.json`, and commit. The review builds your last commit as the "before".
```json
{ "build": { "explore": { "ios": { "simulator": true } } } }
```
2. **Change a screen, then review the change.** Edit some text near the top of a screen (Explore captures the first screenful) and run:
```sh
npx @expo/explore capture
```
Explore builds your last commit and your uncommitted changes on EAS, captures the screens the changes can affect, before and after, on EAS Simulator, and opens the report in your browser. The first run waits for an EAS build; later runs reuse it while your native code is unchanged.
Or paste this into Claude Code or Codex from your app's directory:
```text
Show me an Expo Explore review of a change to this app. Follow the "Review a change on
this machine" section of https://unpkg.com/@expo/explore/skills/explore-setup/SKILL.md.
If the app cannot build for the iOS Simulator on EAS yet, set that up (an EAS project,
ios.bundleIdentifier, an "explore" profile with ios.simulator: true) and ask me before
you commit it. If I have no uncommitted changes, change some text near the top of a
screen. Then run npx @expo/explore capture and open the report.
```
Explore uses its defaults until you run `npx @expo/explore setup`, which writes `.expo-explore/config.yaml` for you to change. Next: [review every pull request](#set-up-ci).
## Map every screen of any app
To map every screen of an app instead, with no config, paste this into Claude Code or Codex from your app's directory. It explores a build you point to, or an Expo project straight from its source:
Paste this into Claude Code or Codex from your app's directory. It explores a build you point to, or an Expo project straight from its source:
```text
Show me Expo Explore working on this app. Follow
@@ -129,7 +89,7 @@ One card per screen the run reached, laid out by how many taps it took, with the
### Review a change before you push it
The review a PR gets also runs on your machine, between any two commits, with your committed `.expo-explore/config.yaml` or, before you have one, [the defaults](#quick-start). No tokens or keys to set: it uses your `eas login` and your Claude Code or Codex login.
Once Explore is [set up](#set-up-ci) (`.expo-explore/config.yaml` committed), the review a PR gets also runs on your machine, between any two commits. No tokens or keys to set: it uses your `eas login` and your Claude Code or Codex login.
```text
Review my current changes with Expo Explore. Follow the "Review a change on this machine"
@@ -148,13 +108,13 @@ Every run is kept on your machine for 30 days. `npx @expo/explore reports` lists
<summary><strong>Run it yourself</strong></summary>
```sh
npx @expo/explore capture # HEAD and your uncommitted changes, against where HEAD left the default branch
npx @expo/explore capture --committed # HEAD alone
npx @expo/explore capture --base v1.3.0 --head v1.4.0 --scope all --upload
npx @expo/explore capture:review # HEAD against where it left the default branch
npx @expo/explore capture:review --uncommitted # your uncommitted changes too
npx @expo/explore capture:review --base v1.3.0 --head v1.4.0 --scope all --upload
```
- It checks out both commits as temporary worktrees, installs their dependencies, captures every configured platform on EAS Simulator (`--platform` picks one), and opens the report in a local Viewer. `--upload` hosts it and prints the link; `report:upload <report.zip>` hosts one you already have.
- Your checkout, index and branches are never touched. Your uncommitted changes, untracked files included, are reviewed as `eas build` would upload them; `--committed`, or `cli.requireCommit: true` in `eas.json`, leaves them out.
- Your checkout, index and branches are never touched. `--uncommitted` takes tracked changes only; `--include-untracked` adds untracked files, which are uploaded with the EAS build.
- It runs both commits' code on your machine, as you: installing their dependencies, evaluating the app config, and bundling the JavaScript. That is what checking them out and running them would do, so review only commits you would run, and someone else's branch only if you trust it.
- Installs run without credential environment variables, which keeps tokens out of reach of a registry a commit's `.npmrc` names; that is not a sandbox. A registry that needs `${NPM_TOKEN}` in the project's `.npmrc` must be authenticated in your own `~/.npmrc`.
- Captures are cached in `~/.cache/expo-explore`, so the same base is not captured twice (`--no-cache` skips it); a capture unused for 30 days goes, and the cache stays under 2 GB. Ctrl+C stops the run's simulator sessions.
@@ -194,8 +154,8 @@ report:
```
- Run `expo-explore setup --workflows` after enabling it to add the `deploy` job.
- A [comparison of two commits](#compare-any-two-commits) links its hosted report from the run's summary instead of a PR comment. `capture --upload` on your machine deploys to the same project with your `eas login`.
- `expo-explore report:upload <report.zip>...` hosts reports already on your machine the same way: a review's reports (one per platform, from `capture --output` or a downloaded `explore-review` artifact) or an `explore:binary` report.
- A [comparison of two commits](#compare-any-two-commits) links its hosted report from the run's summary instead of a PR comment. `capture:review --upload` on your machine deploys to the same project with your `eas login`.
- `expo-explore report:upload <report.zip>...` hosts reports already on your machine the same way: a review's reports (one per platform, from `capture:review --output` or a downloaded `explore-review` artifact) or an `explore:binary` report.
- `EXPO_TOKEN` must be able to create the EAS project, so use a [robot user's](https://docs.expo.dev/accounts/programmatic-access/) token.
- The report is encrypted, and only a request carrying the link's token can open it. Treat the link like a shared file link; see [report access](docs/private-review.md#hosted-previews).
@@ -212,7 +172,7 @@ The prompt above walks through these steps with you. To do them yourself:
- `EXPO_TOKEN`: create it in [Expo access tokens](https://expo.dev/settings/access-tokens). For [hosted previews](#hosted-previews), use a [robot user](https://docs.expo.dev/accounts/programmatic-access/) that can create projects.
- A secret for each `{{secret:NAME}}` in your setup steps. Run `npx @expo/explore setup --workflows` after you add one.
4. Commit, merge to the default branch, and run **Expo Explore baseline** from GitHub Actions.
5. Open a PR. **Expo Explore review** runs and posts a comment with the report. To see a whole review of your branch first, run `npx @expo/explore capture` on your machine.
5. Open a PR. **Expo Explore review** runs and posts a comment with the report. To see a whole review of your branch first, run `npx @expo/explore capture:review` on your machine.
A failed run shows an error code and a next action in the PR comment; see [CI troubleshooting](docs/quickstart-ci.md#diagnose-a-failed-run).
@@ -292,7 +252,7 @@ There are a few ways to snapshot a release:
- **On demand:** in your repository's Actions tab, open **Expo Explore compare**, choose **Run workflow**, and set `base` to the last release's tag (`v1.3.0`), `head` to the new tag or release candidate (`v1.4.0-rc.1`), `scope` to `all` and `expires-in` to `never`. The run's summary links the report.
- **Automatically, on every tag:** add the `release-review.yml` in [The comparison workflow](#compare) below. It compares each tag, release candidates included, with the last stable tag, so a release candidate is reviewed against what people have now.
- **On your machine, without CI:** `npx @expo/explore capture --base v1.3.0 --head v1.4.0 --scope all --upload`, with your `eas login`. `npx @expo/explore reports` lists the runs you have kept.
- **On your machine, without CI:** `npx @expo/explore capture:review --base v1.3.0 --head v1.4.0 --scope all --upload`, with your `eas login`. `npx @expo/explore reports` lists the runs you have kept.
`scope: all` captures every screen, not only those whose source changed, so the report shows the whole release with what changed since the last one marked; `expires-in: never` keeps its link.
@@ -448,7 +408,7 @@ curl -s "$LINK/api/v1/screens?status=modified" | jq '.items[] | {route, status,
4. It compares the captures. A screen with a source change is **Modified** if its captures differ.
5. It uploads the report to GitHub Actions and posts a PR comment.
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](#review-a-change-before-you-push-it)). The workflows' logic lives in `expo-explore ci:*` commands, so a fix reaches CI with the `@expo/explore` version the workflows pin.
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:review`, [above](#review-a-change-before-you-push-it)). The workflows' logic lives in `expo-explore ci:*` commands, so a fix reaches CI with the `@expo/explore` version the workflows pin.
Reports and baselines are kept for 30 days and diagnostics for 7. Hosted deployments are never deleted automatically; see [report access](docs/private-review.md).
+2 -2
View File
@@ -1,12 +1,12 @@
{
"name": "@expo/explore",
"version": "0.19.5",
"version": "0.19.2",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"name": "@expo/explore",
"version": "0.19.5",
"version": "0.19.2",
"license": "MIT",
"dependencies": {
"@expo/repack-app": "0.10.1",
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@expo/explore",
"version": "0.19.5",
"version": "0.19.2",
"description": "Source-driven mobile app maps, deterministic CI capture, and visual reviews",
"license": "MIT",
"type": "module",
+6 -6
View File
@@ -152,18 +152,18 @@ Repeat `expo-explore doctor --json` and fix each `fail` until none remain, colle
## Review a change on this machine
The same review CI runs works locally, between any two commits. It reads `.expo-explore/config.yaml` from the head commit, else from the checkout when setup wrote it but it is not committed, else uses the defaults `setup --non-interactive` would write (with several simulator profiles, the one named `explore`), so it works before setup:
Once `.expo-explore/config.yaml` is committed, the same review CI runs works locally, between any two commits:
```sh
npx @expo/explore capture # HEAD and the uncommitted changes, against where HEAD left the default branch
npx @expo/explore capture --committed # HEAD alone
npx @expo/explore capture --base v1.3.0 --head v1.4.0 --scope all
npx @expo/explore capture:review # HEAD against where it left the default branch
npx @expo/explore capture:review --uncommitted # your uncommitted changes to tracked files against HEAD's base
npx @expo/explore capture:review --base v1.3.0 --head v1.4.0 --scope all
```
- It prints which commits it compares. Each is checked out as a detached worktree in a temporary directory, its dependencies installed (frozen lockfile, no scripts, no Explore credentials in the environment), and removed afterwards; the user's checkout, index and branches are never touched.
- It runs both commits' code as the user (dependency installs, the app config, bundling). Before reviewing a branch the user did not write, say so and ask; credential-free installs are not a sandbox.
- Logins: `EXPO_TOKEN` and the provider's API key when they are set; otherwise the user's `eas login` and their local `claude` or `codex` login for the configured provider. If `eas whoami` fails, tell them to run `eas login`.
- Without `--head`, the head is HEAD plus the working tree's changes, untracked non-ignored files included, which is what `eas build` uploads. It lists them; check that list for secrets the user would not want built. `--committed` reviews HEAD alone, and an `eas.json` with `cli.requireCommit: true` leaves the changes out unless `--uncommitted` is passed.
- `--uncommitted` includes tracked files only. `--include-untracked` adds untracked, non-ignored files, which are uploaded with the EAS build, so check the listed files first and never include secrets.
- Every configured platform is reviewed unless `--platform` picks one. It opens the report in a local Viewer; `--upload` hosts it instead and prints the link, `--no-open` or `--json` only prints the report paths.
- Every run is kept on this machine for 30 days: `npx @expo/explore reports list` (or `--json`) shows them, `reports open <id|latest>` reopens one in the local Viewer, and `reports upload <id>` hosts it without capturing again. Run bare in a terminal, `reports` is an arrow-key picker for the user.
- To host a report after the fact, run `npx @expo/explore report:upload <report.zip>...` with the paths it printed (or the `--output` directory's `<platform>/report.zip`), one per platform. It uses the same project as `--upload` and does not capture again.
@@ -176,7 +176,7 @@ npx @expo/explore capture --base v1.3.0 --head v1.4.0 --scope all
- **Releases.** Unless the user asks otherwise, compare each release with the last stable release, with `scope: all` (every screen, so the report shows the whole release with what changed marked) and, when hosted previews are on, `expires-in: never` (the link outlives the 30-day artifact). For every tag as it is pushed, add the `release-review.yml` from the README's "Compare any two commits" section: it finds the newest earlier tag without a `-` (so a release candidate is compared with the last stable release) and calls `explore-compare.yml` with `secrets: inherit` and `permissions: { contents: read, actions: read }`. A nightly compares with yesterday's tag; a release branch with `main`.
- **Once, on demand.** The workflow must be on the default branch to be dispatched: `gh workflow run explore-compare.yml -f base=<ref> -f head=<ref> -f scope=all -f expires-in=never`, or **Run workflow** under Actions → Expo Explore compare.
- **Without CI.** `npx @expo/explore capture --base <ref> --head <ref> --scope all --upload` runs the same comparison on this machine (see the previous section).
- **Without CI.** `npx @expo/explore capture:review --base <ref> --head <ref> --scope all --upload` runs the same comparison on this machine (see the previous section).
- Call the workflow once per workflow run (a second call in the same run reuses the first one's artifact names). A `base` the baseline workflow captured in the last 30 days is reused, so only `head` is captured.
- To verify, run it once on the latest tag and open the run's summary: it lists each platform's result and links the report.
+4 -5
View File
@@ -1,6 +1,6 @@
---
name: readme-refresh
description: Refresh Expo Explore's README.md with euxy (github.com/brentvatne/euxy) as the reference app. Regenerate every screenshot in docs/screenshots from a current euxy review report and PR comment, then re-read the README as a first-time user: the top level only says what Explore does, links the live euxy example, gives numbered quick-start steps for reviewing a change to your own app, a prompt to copy for exploring any build, and one for setting up CI; everything else lives in collapsibles. Use after a Viewer or PR-comment change that the README shows, a new command or setting, or a release that made a README claim stale. Not for the docs/ guides or the shipped skills.
description: Refresh Expo Explore's README.md with euxy (github.com/brentvatne/euxy) as the reference app. Regenerate every screenshot in docs/screenshots from a current euxy review report and PR comment, then re-read the README as a first-time user: the top level only says what Explore does, links the live euxy example, and gives a prompt to copy for trying it on your app and one for setting up CI; everything else lives in collapsibles. Use after a Viewer or PR-comment change that the README shows, a new command or setting, or a release that made a README claim stale. Not for the docs/ guides or the shipped skills.
---
# Refresh the README
@@ -60,10 +60,9 @@ Look at every PNG you produced before committing, light and dark: the selected s
Read the README top to bottom once without opening a collapsible. At that level it may only answer, in this order:
1. What Explore is (one short paragraph), the hero image, and the link to the live euxy example (`explore-example--euxy.expo.app`, redeployed on every merge to main by `.github/workflows/example-report.yml`).
2. **Quick start**: the smallest set of steps to see a review of the reader's own Expo app on their machine, numbered and with nothing optional in them: make the app buildable on EAS (login, init, bundle identifier, a simulator profile named `explore`) and commit (the before build is the last commit), then edit a screen near its top and run `capture`, which reviews uncommitted changes as `eas build` would upload them and uses setup's defaults when there is no config. After the steps, a prompt that has Claude Code or Codex do the same through the explore-setup skill's "Review a change on this machine" section. Run the steps on a fresh `create-expo-app` before changing them.
3. **Map every screen of any app**: one sentence and a prompt to paste into Claude Code or Codex that gets a simulator build of any app (Expo or not, or just a build) and runs `explore:binary` on it. After its collapsibles, **Review a change before you push it**: one sentence, a prompt that runs `capture` locally (the explore-setup skill's "Review a change on this machine" section) on a set-up app, and the `reports` picker image (`readme-reports-*.png`) with one sentence on saved runs, at the top level, not inside a collapsible. Each section keeps its own "Run it yourself"; never put one section between another's prompt and its collapsibles.
4. **Set up CI**: one sentence, then two subsections, each a sentence on what it gives and a prompt to paste: **Review on every PR** (the setup prompt, then a few grouped collapsibles: Hosted previews first, then Manual setup (the setup prompt's steps done by hand, in order: setup, doctor, secrets, baseline, first PR), Capture modes: deterministic or agent, iOS, Android, or both, Keep your setup current) and **Compare any two commits** (a prompt that follows the explore-setup skill's "Compare any two commits" section, the ways to snapshot a release as bullets, then the comparison workflow collapsed).
5. **What you get**: the PR comment, Compare, and Screens, each a heading, one line, and its picture, then a prompt for asking an agent about a report.
2. **Try it on your app**: one sentence and a prompt to paste into Claude Code or Codex that gets a simulator build of any app (Expo or not, or just a build) and runs `explore:binary` on it. After its collapsibles, **Review a change before you push it**: one sentence, a prompt that runs `capture:review` locally (the explore-setup skill's "Review a change on this machine" section) on a set-up app, and the `reports` picker image (`readme-reports-*.png`) with one sentence on saved runs, at the top level, not inside a collapsible. Each section keeps its own "Run it yourself"; never put one section between another's prompt and its collapsibles.
3. **Set up CI**: one sentence, then two subsections, each a sentence on what it gives and a prompt to paste: **Review on every PR** (the setup prompt, then a few grouped collapsibles: Hosted previews first, then Manual setup (the setup prompt's steps done by hand, in order: setup, doctor, secrets, baseline, first PR), Capture modes: deterministic or agent, iOS, Android, or both, Keep your setup current) and **Compare any two commits** (a prompt that follows the explore-setup skill's "Compare any two commits" section, the ways to snapshot a release as bullets, then the comparison workflow collapsed).
4. **What you get**: the PR comment, Compare, and Screens, each a heading, one line, and its picture, then a prompt for asking an agent about a report.
Lead with prompts, not explanations: a reader should be able to copy something and see Explore work. Everything else, the manual commands, requirements, options, the manual setup, capture modes, hosted previews, iOS and Android, agent mode, repository settings, how agents read a report, how it works, limitations, contributing, goes into a `<details>` block under the section it belongs to, with a `<summary>` that says what the reader will find. Keep bullets to one or two sentences. Group related collapsibles rather than adding one per topic, so a section shows a handful, not nine. Requirements sit collapsed right under the example report link. Keep the collapsibles' `id` attributes that other docs link to (`#hosted-previews`, `#platforms`, `#compare`, `#agents`), and keep the Inspiration section (screenmap and Revyl's Atlas).
+14 -58
View File
@@ -8,7 +8,7 @@ import { runCiReview } from "./pipeline.js";
import { resolveCommit } from "./workflow-steps.js";
import { ciLayout, installCommand, type PackageManager } from "./workflow-install.js";
import { configPlatforms, readExploreConfig, resolvePlatformConfig, withRunOverrides, DEFAULT_EXPLORE_CONFIG_PATH, type ExploreConfig, type ExplorePlatform } from "../config/explore-config.js";
import { AGENT_PROVIDERS, defaultExploreConfig } from "../config/setup.js";
import { AGENT_PROVIDERS } from "../config/setup.js";
import type { PrepareCiExplorationOptions } from "../capture/agent/exploration.js";
import { createCiAgentSession } from "../capture/agent/session.js";
import { createLocalCiAgentSession } from "../capture/agent/session-local.js";
@@ -32,10 +32,10 @@ export type LocalReviewOptions = {
project: string;
base?: string | undefined;
head?: string | undefined;
/** Review HEAD alone, leaving out the working tree's changes. */
committed?: boolean | undefined;
/** Review the working tree even when eas.json sets cli.requireCommit. Without --head this is the default. */
/** Review uncommitted changes to tracked files as the head (the working tree, not a commit). */
uncommitted?: boolean | undefined;
/** With `uncommitted`: also include untracked files that are not ignored. */
untracked?: boolean | undefined;
platform?: ExplorePlatform | undefined;
scope?: string | undefined;
expiresIn?: string | undefined;
@@ -89,7 +89,7 @@ export async function snapshotWorkingTree(root: string, options: { untracked?: b
for (const file of untracked) bytes += (await stat(join(root, file)).catch(() => ({ size: 0 }))).size;
if (bytes > UNTRACKED_LIMIT_BYTES) throw new CiError({ code: "LOCAL_REVIEW_UNTRACKED_TOO_LARGE", stage: "preflight",
message: `The untracked files add up to ${Math.round(bytes / 1024 / 1024)} MB; they would be uploaded with the EAS build.`,
nextAction: "Ignore or commit the large files, or pass --committed to review HEAD alone." });
nextAction: "Ignore or commit the large files, or leave out --include-untracked." });
must(git(root, ["add", options.untracked ? "-A" : "-u", "--", "."], environment), "Cannot stage the working tree", "Check the repository's state.");
const tree = must(git(root, ["write-tree"], environment), "Cannot write the working tree", "Check the repository's state.");
await rm(index, { force: true });
@@ -271,49 +271,6 @@ export async function stopRecordedSessions(outputs: string[], environment: NodeJ
return stopped;
}
/**
* What the head of a review without --head is: the working tree, as `eas build` uploads it (tracked and untracked
* files, not ignored ones), unless the app's eas.json sets cli.requireCommit, which makes eas build refuse uncommitted
* changes, or --committed asks for HEAD alone. --head names a commit, so the working tree is never part of it.
*/
export async function reviewHeadSource(options: Pick<LocalReviewOptions, "head" | "committed" | "uncommitted">, project: string):
Promise<"working-tree" | "commit" | "require-commit"> {
const namedHead = options.head !== undefined && options.head !== "HEAD";
if (options.uncommitted && (namedHead || options.committed)) throw new CiError({ code: "LOCAL_REVIEW_UNCOMMITTED_HEAD", stage: "preflight",
message: "--uncommitted reviews the working tree, which is on top of HEAD.", nextAction: `Leave out ${namedHead ? "--head" : "--committed"}, or leave out --uncommitted.` });
if (namedHead || options.committed) return "commit";
if (options.uncommitted) return "working-tree";
let eas: unknown;
try { eas = JSON.parse(await readFile(join(project, "eas.json"), "utf8")); } catch { return "working-tree"; }
const cli = eas !== null && typeof eas === "object" ? (eas as { cli?: unknown }).cli : undefined;
return cli !== null && typeof cli === "object" && (cli as { requireCommit?: unknown }).requireCommit === true ? "require-commit" : "working-tree";
}
/**
* The config a local review runs with: the head commit's; else the one in your checkout, when setup has written it but
* it is not committed yet; else the defaults setup would write, so an app can be reviewed before it is set up. A
* config path passed with --config must be in the head commit.
*/
export async function localReviewConfig(options: { project: string; head: string; configPath: string; explicit: boolean;
platform?: ExplorePlatform | undefined; progress?: Progress }): Promise<ExploreConfig> {
const progress = options.progress ?? silentProgress;
if (options.explicit || await exists(join(options.head, options.configPath))) return readExploreConfig(options.head, options.configPath);
if (await exists(join(options.project, options.configPath))) {
progress(`config: ${options.configPath} from your checkout (it is not in the head commit)`);
return readExploreConfig(options.project, options.configPath);
}
let config: ExploreConfig;
try { config = await defaultExploreConfig(options.project, options.platform); }
catch (error) {
throw new CiError({ code: "LOCAL_REVIEW_CONFIG_DEFAULTS", stage: "preflight",
message: `There is no ${options.configPath}, so this review uses setup's defaults, which need this: ${(error as Error).message}`,
nextAction: "Fix that and rerun (with several simulator profiles, the one named explore is used), or run expo-explore setup to write a config." });
}
progress(`config: none yet, so setup's defaults (${config.app.bundleId}, EAS profile ${config.app.easProfile}, ${config.device.name}); `
+ "expo-explore setup writes one you can change");
return config;
}
export async function runLocalReview(options: LocalReviewOptions): Promise<LocalReviewResult> {
const environment = { ...(options.environment ?? process.env) };
const progress = options.progress ?? silentProgress;
@@ -349,14 +306,14 @@ export async function runLocalReview(options: LocalReviewOptions): Promise<Local
// The commits.
const headRef = options.head ?? "HEAD";
let head: LocalReviewResult["head"];
const source = await reviewHeadSource(options, project);
if (source === "require-commit") progress("head: HEAD; eas.json sets cli.requireCommit, so uncommitted changes are left out as eas build leaves them out (--uncommitted includes them)");
if (source === "working-tree") {
const snapshot = await snapshotWorkingTree(root, { untracked: true, work });
if (options.uncommitted) {
if (options.head && options.head !== "HEAD") throw new CiError({ code: "LOCAL_REVIEW_UNCOMMITTED_HEAD", stage: "preflight",
message: "--uncommitted reviews the working tree, which is on top of HEAD.", nextAction: "Leave out --head, or leave out --uncommitted." });
const snapshot = await snapshotWorkingTree(root, { untracked: options.untracked, work });
head = snapshot ? { ref: "uncommitted changes", sha: snapshot.sha, uncommitted: snapshot.changed } : { ref: "HEAD", sha: resolveCommit(root, "HEAD", "head") };
if (snapshot) progress(`head: HEAD with your uncommitted changes to ${snapshot.changed.length} file${snapshot.changed.length === 1 ? "" : "s"}, as eas build would upload them`
+ (snapshot.untracked.length ? ` (untracked, kept in .git/objects until git gc: ${snapshot.untracked.join(", ")})` : "") + "; --committed leaves them out");
else progress("head: HEAD (no uncommitted changes)");
if (snapshot) progress(`head: your uncommitted changes to ${snapshot.changed.length} file${snapshot.changed.length === 1 ? "" : "s"}`
+ (snapshot.untracked.length ? ` (untracked, uploaded with the build and kept in .git/objects until git gc: ${snapshot.untracked.join(", ")})` : ""));
else progress("head: no uncommitted changes, reviewing HEAD");
} else {
const sha = resolveCommit(root, headRef, "head");
head = { ref: reportRef(root, headRef, sha), sha };
@@ -364,7 +321,7 @@ export async function runLocalReview(options: LocalReviewOptions): Promise<Local
const baseSha = options.base ? resolveCommit(root, options.base, "base") : undefined;
const base = options.base && baseSha ? { ref: reportRef(root, options.base, baseSha), sha: baseSha } : defaultBase(root, head.sha);
if (base.sha === head.sha) throw new CiError({ code: "COMPARE_SAME_COMMIT", stage: "preflight", message: `${base.ref} and ${head.ref} are the same commit (${head.sha.slice(0, 8)}).`,
nextAction: "Change something to review it, or pass --base with an earlier commit." });
nextAction: "Pass --base with an earlier commit, or --uncommitted to review your uncommitted changes." });
progress(`comparing ${head.ref} (${head.sha.slice(0, 8)}) with ${base.ref} (${base.sha.slice(0, 8)})`);
// The checkouts, and the config at head.
@@ -376,8 +333,7 @@ export async function runLocalReview(options: LocalReviewOptions): Promise<Local
}
const projects = { base: join(checkouts.base, appDirectory), head: join(checkouts.head, appDirectory) };
const configPath = options.configPath ?? DEFAULT_EXPLORE_CONFIG_PATH;
const rawConfig = await localReviewConfig({ project, head: projects.head, configPath, explicit: options.configPath !== undefined,
platform: options.platform, progress });
const rawConfig = await readExploreConfig(projects.head, configPath);
const platforms = options.platform ? [options.platform] : configPlatforms(rawConfig);
const repository = repositoryName(root, rawConfig);
+2 -5
View File
@@ -26,12 +26,9 @@ const aliases: Record<string, string> = {
"config platforms": "config:platforms",
};
/** One-word names for commands people type: `capture` is the local review, `capture:review` without its CI flags. */
const shortNames: Record<string, string> = { capture: "capture:review" };
const first = argv[0] ?? "help";
const pair = `${first} ${argv[1] ?? ""}`.trim();
export const command = aliases[pair] ?? shortNames[first] ?? first;
export const command = aliases[pair] ?? first;
export const resultContract = ["source:verify", "capture:review", "capture:baseline", "ci:report", "ci:publish", "ci:failure", "ci:deploy", "ci:pr", "ci:find-baseline", "ci:compare-refs", "ci:after-capture", "config:platforms", "explore:binary", "explore:session", "report:upload", "reports"].includes(command)
? "explore.result" : QUERY_CONTRACT;
const commandArgCount = aliases[pair] ? 2 : 1;
@@ -84,7 +81,7 @@ const flagKinds: Record<string, Record<string, "value" | "boolean">> = {
export: { output: "value" },
"export:web": {catalog:"value",output:"value"},
"capture:review": { "base-project":"value", "head-project":"value", "pull-request":"value", compare:"value", output:"value", config:"value", platform:"value", scope:"value", "expires-in":"value",
base:"value", head:"value", project:"value", committed:"boolean", uncommitted:"boolean", "include-untracked":"boolean", upload:"boolean", "no-open":"boolean", "no-cache":"boolean", port:"value" },
base:"value", head:"value", project:"value", uncommitted:"boolean", "include-untracked":"boolean", upload:"boolean", "no-open":"boolean", "no-cache":"boolean", port:"value" },
+2 -3
View File
@@ -221,12 +221,11 @@ export async function captureBaseline(): Promise<void> {
output({ ok: true, ...await runBaselineCi({ ...(platform ? { platform } : {}), project, sha: required("sha"), output: required("output"), config, progress: stderrProgress() }) });
}
/** `capture` (or `capture:review`) `[--base REF] [--head REF | --committed]`: a local review, opened in the Viewer or hosted with --upload. */
/** `capture:review [--base REF] [--head REF | --uncommitted]`: a local review, opened in the Viewer or hosted with --upload. */
async function localReview(): Promise<void> {
const platform = platformFlag();
const result = await runLocalReview({ project: flag("project") ?? process.cwd(), base: flag("base"), head: flag("head"),
// --include-untracked is accepted from before untracked files were included by default.
committed: has("committed"), uncommitted: has("uncommitted"), ...(platform ? { platform } : {}),
uncommitted: has("uncommitted"), untracked: has("include-untracked"), ...(platform ? { platform } : {}),
scope: flag("scope"), expiresIn: flag("expires-in"), cache: !has("no-cache"), configPath: flag("config"), progress: stderrProgress() });
if (has("output")) {
for (const report of result.reports) {
+3 -6
View File
@@ -17,14 +17,11 @@ const GET_STARTED = `Get started (run these in the Expo app's directory):
(--offline skips EAS and GitHub; --check-model sends one small request with the local provider key)
doctor --capture [--project DIRECTORY] [--output DIRECTORY] [--platform ios|android] [--yes]
(captures the committed HEAD like the baseline workflow, with your eas login, and reports each route)
capture [--base REF] [--head REF | --committed] [--platform ios|android] [--scope all|changes]
capture:review [--base REF] [--head REF | --uncommitted [--include-untracked]] [--platform ios|android] [--scope all|changes]
[--upload [--expires-in 7d|30d|never]] [--no-open] [--no-cache] [--output DIRECTORY] [--project DIRECTORY]
(on this machine: checks out both commits in temporary worktrees, captures them with your eas login and your
local claude or codex login, and opens the report; the head is HEAD with your uncommitted changes, as eas build
uploads them (--committed, or cli.requireCommit in eas.json, leaves them out); the base defaults to where HEAD
left the default branch;
without .expo-explore/config.yaml it uses the defaults setup would write;
it runs both commits' code as you, so review only commits you would run; capture:review is the same command)
local claude or codex login, and opens the report; the base defaults to where HEAD left the default branch;
it runs both commits' code as you, so review only commits you would run)
view [--catalog FILE] [--port N] [--no-open]
(opens a report in the Viewer)
reports [list | open ID | add REPORT... | upload ID | rm ID | prune] [--all] [--json]
+1 -1
View File
@@ -176,7 +176,7 @@ async function uploadSavedRun(run: SavedRun): Promise<void> {
}
function listLines(runs: SavedRun[], now = Date.now()): string[] {
if (!runs.length) return ["No saved runs yet. expo-explore capture reviews your branch on this machine, and its report is kept here."];
if (!runs.length) return ["No saved runs yet. expo-explore capture:review reviews your branch on this machine, and its report is kept here."];
const idWidth = Math.max(...runs.map(run => run.id.length));
return [...runs.map(run => `${run.id.padEnd(idWidth)} ${kindLabel(run).padEnd(9)}${runTitle(run)} (${run.platforms.join(", ")}, ${friendlyTime(run.createdAt, now)})`),
"", "Open one with: expo-explore reports open <id>"];
+1 -1
View File
@@ -129,7 +129,7 @@ export function renderPicker(state: PickerState, options: { width: number; heigh
if (!runs.length) {
const empty = state.runs.length
? [` ${paint.dim(state.filter ? `Nothing matches "${state.filter}".` : `No saved runs of ${state.repository}. Press tab for every repository.`)}`]
: [` ${paint.text("No saved runs yet.")}`, ` ${paint.dim("expo-explore capture reviews your branch on this machine, and its report is kept here.")}`];
: [` ${paint.text("No saved runs yet.")}`, ` ${paint.dim("expo-explore capture:review reviews your branch on this machine, and its report is kept here.")}`];
return [...header, ...empty, "", ...footer].map(line => fit(line, width));
}
const selected = runs[Math.min(state.selected, runs.length - 1)]!;
+2 -15
View File
@@ -4,7 +4,7 @@ import { dirname, join, resolve } from "node:path";
import { createInterface } from "node:readline/promises";
import { fileURLToPath } from "node:url";
import { stringify } from "yaml";
import { DEFAULT_EXPLORE_CONFIG_PATH, readExploreConfig, validateExploreConfig, type ExploreConfig, type ExplorePlatform } from "./explore-config.js";
import { DEFAULT_EXPLORE_CONFIG_PATH, readExploreConfig, validateExploreConfig, type ExploreConfig } from "./explore-config.js";
import { explorationSecretNames } from "./exploration-inputs.js";
import type { RouteEntryReport } from "../ci/route-entry.js";
import type { CiInstallResult } from "../ci/workflow-install.js";
@@ -60,8 +60,6 @@ type SetupOptions = {
appState?: string | undefined;
workflows?: boolean | undefined;
nonInteractive?: boolean;
/** Return the config without writing anything. */
dryRun?: boolean;
check?: boolean;
};
type Interaction = {
@@ -236,14 +234,6 @@ export type SetupResult = {
nextSteps?: string[];
};
/**
* The config `setup --non-interactive` would write, without writing it: what a local review runs with in an app that
* has no config yet. Throws setup's errors when the app cannot be built for capture.
*/
export async function defaultExploreConfig(project: string, platform?: ExplorePlatform): Promise<ExploreConfig> {
return (await runExploreSetup({ project, platform, nonInteractive: true, dryRun: true })).config;
}
/**
* The guided setup. It writes what it can derive (app identity, mode, route parameters it was given,
* an agent-instructions draft, CI files) and hands the app-specific flows to the user's coding agent.
@@ -300,9 +290,7 @@ export async function runExploreSetup(options: SetupOptions = {}, interaction?:
}
const schemes = Array.isArray(app.scheme) ? app.scheme.filter((value): value is string => typeof value === "string") : undefined;
const scheme = await choose("URL scheme (optional)", options.scheme, schemes?.[0] ?? string(app.scheme), schemes);
const profile = await choose(platform === "android" ? "EAS emulator (APK) build profile" : "EAS simulator build profile", options.profile,
// With several, the one named explore, the name the README and the explore-setup skill give it.
profiles.length === 1 ? profiles[0]! : profiles.includes("explore") ? "explore" : "", profiles);
const profile = await choose(platform === "android" ? "EAS emulator (APK) build profile" : "EAS simulator build profile", options.profile, profiles.length === 1 ? profiles[0]! : "", profiles);
if (!profiles.includes(profile)) throw new Error(`Choose ${platform === "android" ? "an Android APK" : "a simulator"} profile from eas.json with --profile: ${profiles.join(", ")}.`);
const inferredProvider = dependencies["expo-router"] ? "expo-router" : dependencies["@react-navigation/native"] ? "react-navigation" : "auto";
const provider = await choose("Navigation provider", options.navigation, inferredProvider, ["auto", "expo-router", "react-navigation"]);
@@ -402,7 +390,6 @@ export async function runExploreSetup(options: SetupOptions = {}, interaction?:
const answer = await ui!.ask("Write this config? (yes/no)", "yes");
if (!/^(y|yes)$/i.test(answer.trim())) throw new Error("Setup canceled; no config was written.");
}
if (options.dryRun) return { path, config, created: false };
await mkdir(parent, { recursive: true });
await writeFile(path, yaml, { flag: "wx" });
if (instructions) await writeFile(instructionsPath, instructions, { flag: "wx" });
+4 -7
View File
@@ -406,13 +406,10 @@ test("the Screens tree folds by row, by keyboard, and all at once, and remembers
await tree.getByRole("button", { name: "Expand all" }).click();
await expect.poll(() => rows.count()).toBe(expandedRows);
// The tree names the folders, so the page beside it is one grid without section headings, in the tree's order.
await expect(page.locator(".screens-page .screens-section-head")).toHaveCount(0);
await expect(page.locator(".screens-page .screens-grid")).toHaveCount(1);
const treeOrder = await tree.locator(".screens-tree-row[data-screen-id]").evaluateAll(rows => rows.map(row => row.dataset.screenId));
const gridOrder = await page.locator(".screens-page .screens-cell").evaluateAll(cells => cells.map(cell => cell.dataset.screenId));
assert.ok(gridOrder.length > 1);
assert.deepEqual(gridOrder, treeOrder);
// Section headings name the folder, with the path beneath.
const onboarding = page.getByRole("region", { name: "Onboarding" });
await expect(onboarding.getByRole("heading", { level: 2 })).toHaveText("Onboarding");
await expect(onboarding.locator(".screens-section-head .path")).toHaveText("app/onboarding");
assert.deepEqual(errors, []);
});
+2 -96
View File
@@ -1309,100 +1309,7 @@ for (const canvas of ["map", "screens"] as const) {
});
}
test("← and → step through the Screens cards in page order, with focus, and leave the tree's arrows alone", async ({ page }) => {
await serveWorkspace(page);
await page.goto("/screens");
const grid = page.getByRole("main", { name: "Screens" });
await grid.getByRole("button", { name: /^All/ }).click();
const cells = grid.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 card = (id: string) => grid.locator(`.screens-cell[data-screen-id="${id}"] .screen-screenshot-card`);
const target = (id: string) => grid.locator(`.screens-cell[data-screen-id="${id}"] .screen-screenshot-target`);
// With nothing selected, → starts at the first card.
await expect(grid.locator(".screen-screenshot-card.selected")).toHaveCount(0);
await page.keyboard.press("ArrowRight");
await expect(card(ids[0]!)).toHaveClass(/selected/);
await expect(target(ids[0]!)).toBeFocused();
await page.keyboard.press("ArrowRight");
await expect(card(ids[1]!)).toHaveClass(/selected/);
await expect(target(ids[1]!)).toBeFocused();
await page.keyboard.press("ArrowRight");
await expect(card(ids[2]!)).toHaveClass(/selected/);
await page.keyboard.press("ArrowLeft");
await expect(card(ids[1]!)).toHaveClass(/selected/);
await expect(card(ids[2]!)).not.toHaveClass(/selected/);
// ↓ and ↑ move a row, to the card in the same column.
const tops = await cells.evaluateAll(elements => elements.map(element => Math.round(element.getBoundingClientRect().top)));
const columns = tops.filter(top => top === tops[0]).length;
if (ids.length > 1 + columns) {
await page.keyboard.press("ArrowDown");
await expect(card(ids[1 + columns]!)).toHaveClass(/selected/);
await expect(target(ids[1 + columns]!)).toBeFocused();
await page.keyboard.press("ArrowUp");
await expect(card(ids[1]!)).toHaveClass(/selected/);
}
// Held, → keeps stepping, as in Compare, and stops on release.
const selectedAt = async () => ids.indexOf((await grid.locator(".screens-cell:has(.screen-screenshot-card.selected)").getAttribute("data-screen-id"))!);
const from = await selectedAt();
await page.keyboard.down("ArrowRight");
await expect.poll(selectedAt, { timeout: 4000 }).toBeGreaterThanOrEqual(Math.min(ids.length - 1, from + 3));
await page.keyboard.up("ArrowRight");
const released = await selectedAt();
await page.waitForTimeout(500);
expect(await selectedAt()).toBe(released);
// Return opens the pick in the Inspector, from the card or from anywhere on the page.
const inspector = page.getByRole("complementary", { name: "Inspector panel" });
await expect(inspector).toBeHidden();
await page.keyboard.press("Enter");
await expect(inspector).toBeVisible();
await page.keyboard.press("Escape");
await expect(inspector).toBeHidden();
await page.evaluate(() => (document.activeElement as HTMLElement | null)?.blur());
await page.keyboard.press("Enter");
await expect(inspector).toBeVisible();
await page.keyboard.press("Escape");
await expect(inspector).toBeHidden();
// In the tree, ← and → fold and unfold rows; they do not step the cards.
const picked = await selectedAt();
const row = grid.locator(".screens-tree-row").first();
await row.focus();
await page.keyboard.press("ArrowLeft");
await expect(card(ids[picked]!)).toHaveClass(/selected/);
});
test("→ steps the Screens cards right after Screens is opened from the toolbar, and from a pick that Changed hides", async ({ page }) => {
await serveWorkspace(page);
await page.goto("/map");
await page.getByRole("group", { name: "Canvas view" }).getByRole("button", { name: "Screens", exact: true }).click();
const grid = page.getByRole("main", { name: "Screens" });
const cells = grid.locator(".screens-grid .screens-cell");
await expect(cells.first()).toBeVisible();
// Focus is still on the toolbar's Screens button.
await page.keyboard.press("ArrowRight");
await expect(cells.first().locator(".screen-screenshot-card")).toHaveClass(/selected/);
// Pick a screen that Changed hides, then show Changed: → goes to the next changed card after it in the tree.
await grid.getByRole("button", { name: /^All/ }).click();
const all = await cells.evaluateAll(elements => elements.map(element => element.getAttribute("data-screen-id")!));
await grid.getByRole("button", { name: /^Changed/ }).click();
const changed = await cells.evaluateAll(elements => elements.map(element => element.getAttribute("data-screen-id")!));
const hidden = all.find((id, position) => !changed.includes(id) && all.slice(position + 1).some(next => changed.includes(next)));
test.skip(!hidden, "the fixture has no unchanged screen before a changed one");
await grid.getByRole("button", { name: /^All/ }).click();
await grid.locator(`.screens-cell[data-screen-id="${hidden}"] .screen-screenshot-target`).click();
await grid.getByRole("button", { name: /^Changed/ }).click();
const expected = all.slice(all.indexOf(hidden!) + 1).find(id => changed.includes(id))!;
await page.keyboard.press("ArrowRight");
await expect(grid.locator(`.screens-cell[data-screen-id="${expected}"] .screen-screenshot-card`)).toHaveClass(/selected/);
});
test("reuses the Map screenshot card in Screens, with the route under the screenshot at the card's left edge", async ({ page }) => {
test("reuses the Map screenshot card visual in Screens, with the route at the card's left edge", async ({ page }) => {
await serveWorkspace(page);
await page.goto("/screens");
@@ -1430,9 +1337,8 @@ test("reuses the Map screenshot card in Screens, with the route under the screen
};
});
expect(layout.flexDirection).toBe("column");
// The card is the Map's, so the heading still comes first in the markup; Screens shows it as the card's footer.
expect(layout.headingBeforeImage).toBe(true);
expect(layout.headingTop).toBeGreaterThan(layout.imageTop);
expect(layout.headingTop).toBeLessThan(layout.imageTop);
expect(layout.titleLeftDelta).toBeLessThan(1);
}
-13
View File
@@ -122,19 +122,6 @@ test("version prints the package version", () => {
}
});
test("capture is the local review, capture:review by a shorter name", async (t) => {
const outside = await mkdtemp(join(tmpdir(), "explore-capture-"));
t.after(() => rm(outside, { recursive: true, force: true }));
const failures = ["capture", "capture:review"].map(command => [
runFailure(outside, [command, "--bogus", "--json"]),
runFailure(outside, [command, "--committed", "--json"]),
]);
assert.deepEqual(failures[0], failures[1], "the same flags, errors and result contract");
assert.equal(failures[0][0].command, "capture:review");
assert.equal(failures[0][0].diagnostic.code, "CLI_ARGUMENT_INVALID");
assert.equal(failures[0][1].diagnostic.code, "LOCAL_REVIEW_GIT_FAILED", "--committed is a known flag; outside a repository the review stops");
});
test("removed map-writing commands fail as unknown commands", () => {
for (const command of ["init", "screen:add", "attempt:commit", "frontier:claim", "gap:add", "finish"]) {
const result = spawnSync(process.execPath, [cli, command], { cwd: root, encoding: "utf8" });
+1 -51
View File
@@ -5,7 +5,7 @@ import { spawnSync } from 'node:child_process';
import { lstat, mkdtemp, readFile, realpath, rm, writeFile } from 'node:fs/promises';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import { appEnvironment, captureCacheDirectory, defaultBase, installDependencies, keepCapture, localInstallCommand, localReviewConfig, reportRef, reviewHeadSource, runLocalReview, snapshotWorkingTree } from '../../dist/ci/local-review.js';
import { appEnvironment, captureCacheDirectory, defaultBase, installDependencies, keepCapture, localInstallCommand, reportRef, runLocalReview, snapshotWorkingTree } from '../../dist/ci/local-review.js';
import { mkdir, readdir } from 'node:fs/promises';
import { startLocalReportServer } from '../../dist/report/local-report-server.js';
import { fixture, git } from '../helpers/public-ci-fixture.mjs';
@@ -56,56 +56,6 @@ test('the working tree becomes a commit on HEAD without touching the index, file
assert.deepEqual({ status: git(root, 'status', '--porcelain'), index: git(root, 'diff', '--cached', '--name-only'), refs: git(root, 'for-each-ref'), head: git(root, 'rev-parse', 'HEAD') }, before);
});
test('the head is the working tree, as eas build uploads it, unless --committed, --head, or eas.json requireCommit says otherwise', async t => {
const project = await scratch(t, 'explore-local-head-');
assert.equal(await reviewHeadSource({}, project), 'working-tree', 'no eas.json');
await writeFile(join(project, 'eas.json'), JSON.stringify({ cli: { version: '>= 16' }, build: {} }));
assert.equal(await reviewHeadSource({}, project), 'working-tree');
assert.equal(await reviewHeadSource({ committed: true }, project), 'commit');
assert.equal(await reviewHeadSource({ head: 'HEAD' }, project), 'working-tree', '--head HEAD is the default head');
assert.equal(await reviewHeadSource({ head: 'v1.0.0' }, project), 'commit');
await writeFile(join(project, 'eas.json'), JSON.stringify({ cli: { requireCommit: true } }));
assert.equal(await reviewHeadSource({}, project), 'require-commit', 'eas build refuses uncommitted changes here, so the review leaves them out');
assert.equal(await reviewHeadSource({ uncommitted: true }, project), 'working-tree', '--uncommitted includes them anyway');
await writeFile(join(project, 'eas.json'), '{ not json');
assert.equal(await reviewHeadSource({}, project), 'working-tree');
for (const conflict of [{ uncommitted: true, head: 'v1.0.0' }, { uncommitted: true, committed: true }]) {
await assert.rejects(reviewHeadSource(conflict, project), { code: 'LOCAL_REVIEW_UNCOMMITTED_HEAD' });
}
});
test('a review uses the head commit\'s config, else an uncommitted one, else the defaults setup would write', async t => {
const project = await scratch(t, 'explore-local-app-');
const head = await scratch(t, 'explore-local-head-');
const json = (path, value) => writeFile(join(project, path), JSON.stringify(value));
await json('package.json', { dependencies: { expo: '*', 'expo-router': '*' } });
await json('app.json', { expo: { name: 'Test app', scheme: 'test-app', ios: { bundleIdentifier: 'com.example.test' } } });
await json('eas.json', { build: { explore: { ios: { simulator: true } } } });
const configPath = '.expo-explore/config.yaml';
const resolve = (options = {}) => localReviewConfig({ project, head, configPath, explicit: false, ...options });
const messages = [];
const defaults = await resolve({ progress: message => messages.push(message) });
assert.equal(defaults.mode, 'deterministic');
assert.deepEqual([defaults.app.platform, defaults.app.bundleId, defaults.app.easProfile, defaults.app.scheme], ['ios', 'com.example.test', 'explore', 'test-app']);
assert.equal(defaults.navigation.provider, 'expo-router');
assert.equal(defaults.exploration.scope, 'changes');
assert.match(messages.join('\n'), /setup's defaults \(com\.example\.test, EAS profile explore, iPhone 17\)/);
await assert.rejects(lstat(join(project, '.expo-explore')), { code: 'ENOENT' }, 'the defaults are not written');
const config = name => `mode: deterministic\napp:\n name: ${name}\n platform: ios\n bundleId: com.example.test\n easProfile: explore\n`
+ 'navigation:\n provider: expo-router\ndevice:\n name: iPhone 17\nexploration:\n scope: changes\n';
await mkdir(join(project, '.expo-explore')); await writeFile(join(project, configPath), config('Checkout'));
assert.equal((await resolve()).app.name, 'Checkout', 'setup ran but its config is not committed yet');
await mkdir(join(head, '.expo-explore')); await writeFile(join(head, configPath), config('Head'));
assert.equal((await resolve()).app.name, 'Head', 'the commit under review wins');
await assert.rejects(resolve({ configPath: 'other.yaml', explicit: true }), { code: 'CONFIG_READ_FAILED' }, 'a --config path must be in the commit');
await rm(join(project, '.expo-explore'), { recursive: true }); await rm(join(head, '.expo-explore'), { recursive: true });
await rm(join(project, 'eas.json'));
await assert.rejects(resolve(), error => error.code === 'LOCAL_REVIEW_CONFIG_DEFAULTS' && /no \.expo-explore\/config\.yaml.*No eas\.json found/s.test(error.message));
});
test('with no base, a branch is compared with where it left the default branch', async t => {
const root = await repository(t);
const fork = git(root, 'rev-parse', 'HEAD');
+1 -15
View File
@@ -3,7 +3,7 @@ import test from "node:test";
const { tsImport } = await import("tsx/esm/api");
const { indexMap } = await tsImport("../../viewer/src/utils/model.ts", import.meta.url);
const { screenTree, treeScreenOrder } = await tsImport("../../viewer/src/utils/screen-tree.ts", import.meta.url);
const { screenTree } = await tsImport("../../viewer/src/utils/screen-tree.ts", import.meta.url);
const at = (second) => `2026-10-13T00:00:${String(second).padStart(2, "0")}.000Z`;
function screen(id, title, depth, extra = {}) {
@@ -49,20 +49,6 @@ test("with route files, sections follow the app directory and the tabs lead", ()
assert.deepEqual(folders, ["(tabs)/"]);
});
test("the screens' order is the tree's, depth first: a nested folder's screens come right after their parent's", () => {
// The folders are found as settings, feed, settings/security: sections keep that order, while the tree nests
// security under settings. The Screens grid and its arrow keys follow the tree, as the sidebar reads.
const screens = [screen("profile", "A profile", 1), screen("feed", "B feed", 1), screen("security", "C security", 1), screen("loose", "D loose", 1)];
const routeFiles = new Map([
["profile", "app/settings/profile.tsx"],
["feed", "app/feed/index.tsx"],
["security", "app/settings/security/index.tsx"],
]);
const tree = screenTree(screens, indexMap(map({ screens })), routeFiles);
assert.deepEqual(tree.sections.flatMap(section => section.screenIds), ["profile", "feed", "security", "loose"]);
assert.deepEqual(treeScreenOrder(tree), ["profile", "security", "feed", "loose"]);
});
test("a black-box exploration groups by the tab each screen was opened from", () => {
const screens = [
screen("seq", "Sequencer", 0),
+2 -7
View File
@@ -78,16 +78,11 @@ test("EAS profile inheritance is respected and device builds cannot be selected"
explore: { extends: "base", ios: { buildConfiguration: "Release" } },
production: { extends: "base", ios: { simulator: false } },
} });
await assert.rejects(runExploreSetup({ project, ...options }), /--profile/);
await assert.rejects(runExploreSetup({ project, ...options, profile: "production" }), /--profile/);
await assert.rejects(stat(path), { code: "ENOENT" });
// Of several simulator profiles, the one named explore is the default; without one, setup asks for --profile.
await runExploreSetup({ project, ...options });
await runExploreSetup({ project, ...options, profile: "explore" });
assert.equal((await readExploreConfig(project)).app.easProfile, "explore");
await rm(path);
await json("eas.json", { build: { base: { ios: { simulator: true } }, sim: { extends: "base" } } });
await assert.rejects(runExploreSetup({ project, ...options }), /--profile: base, sim/);
await runExploreSetup({ project, ...options, profile: "sim" });
assert.equal((await readExploreConfig(project)).app.easProfile, "sim");
});
test("dynamic config uses the app's Expo resolver instead of stale app.json", async (t) => {
+1 -17
View File
@@ -15,21 +15,6 @@ test("hints print modifiers in Apple's ⌥⇧⌘ order and as Ctrl+Alt+Shift els
assert.equal(formatShortcut(SHORTCUTS.camera.fit, true), "⇧1");
assert.equal(formatShortcut({ code: "KeyT", key: "T", mod: true, alt: true }, false), "Ctrl+Alt+T");
assert.equal(formatShortcut(SHORTCUTS.edit.redo, false), "Ctrl+Shift+Z");
// The Control key itself prints as ⌃ on a Mac, where ⌘ would be a different key.
assert.equal(formatShortcut(SHORTCUTS.canvasByNumber.screens, true), "⌃2");
assert.equal(formatShortcut(SHORTCUTS.canvasByNumber.screens, false), "Ctrl+2");
});
test("Ctrl+1, Ctrl+2 and Ctrl+3 reach Map, Screens and Compare with Control alone, never ⌘ (the browser's tab keys)", () => {
assert.equal(matchesShortcut(key("Digit1", { ctrlKey: true }), SHORTCUTS.canvasByNumber.map), true);
assert.equal(matchesShortcut(key("Digit2", { ctrlKey: true }), SHORTCUTS.canvasByNumber.screens), true);
assert.equal(matchesShortcut(key("Digit3", { ctrlKey: true }), SHORTCUTS.canvasByNumber.compare), true);
assert.equal(matchesShortcut(key("Digit1", { metaKey: true }), SHORTCUTS.canvasByNumber.map), false);
assert.equal(matchesShortcut(key("Digit1", { ctrlKey: true, metaKey: true }), SHORTCUTS.canvasByNumber.map), false);
assert.equal(matchesShortcut(key("Digit1", { ctrlKey: true, shiftKey: true }), SHORTCUTS.canvasByNumber.map), false);
// Compare's 1, 2, 3 (Split, Swipe, Flip) stay plain digits.
assert.equal(matchesShortcut(key("Digit1", { ctrlKey: true }), SHORTCUTS.compare.split), false);
assert.equal(matchesShortcut(key("Digit1"), SHORTCUTS.canvasByNumber.map), false);
});
test("a chord matches only its own modifiers, on either ⌘ or Ctrl", () => {
@@ -50,8 +35,7 @@ test("no two shortcuts share a chord", () => {
const seen = new Map();
for (const [group, entries] of Object.entries(SHORTCUTS)) {
for (const [name, shortcut] of Object.entries(entries)) {
// Off Apple keyboards ⌘ is Ctrl, so a Control chord clashes with the same ⌘ chord.
const chord = `${shortcut.code}:${Boolean(shortcut.mod || shortcut.ctrl)}:${Boolean(shortcut.alt)}:${Boolean(shortcut.shift)}`;
const chord = `${shortcut.code}:${Boolean(shortcut.mod)}:${Boolean(shortcut.alt)}:${Boolean(shortcut.shift)}`;
const clash = seen.get(chord);
assert.ok(!clash, `${group}.${name} repeats ${clash}`);
seen.set(chord, `${group}.${name}`);
+1 -5
View File
@@ -46,7 +46,6 @@ import {
type ThemePreference,
} from "./utils/navigation";
import {
CANVAS_NUMBER_KEYS,
matchesShortcut,
modalOpen,
SHORTCUTS,
@@ -143,10 +142,7 @@ const LEGACY_COLLAPSED_STORAGE_KEY = "expo-explore:panel-collapsed";
const RIGHT_COLLAPSED_STORAGE_KEY = "expo-explore:right-panel-collapsed";
// The shell's keyboard map, paired with what each key selects. Read as lists so a key and the
// thing it reaches stay one entry.
const CANVAS_KEYS = [
...Object.entries(SHORTCUTS.canvas),
...(CANVAS_NUMBER_KEYS ? Object.entries(SHORTCUTS.canvasByNumber) : []),
] as [CanvasView, Shortcut][];
const CANVAS_KEYS = Object.entries(SHORTCUTS.canvas) as [CanvasView, Shortcut][];
/** Before data loads there is no comparison to assume. A workspace reparses the URL on arrival. */
const EMPTY_ROUTE_CONTEXT: RouteContext = {
@@ -1,7 +1,7 @@
import { useEffect } from "react";
import { createPortal } from "react-dom";
import { X } from "lucide-react";
import { CANVAS_NUMBER_KEYS, formatShortcut, SHORTCUTS, type Shortcut } from "../../utils/shortcuts";
import { formatShortcut, SHORTCUTS, type Shortcut } from "../../utils/shortcuts";
import type { CanvasView } from "../../utils/navigation";
import { useModalDialog } from "../../hooks/use-modal-dialog";
@@ -63,9 +63,6 @@ export function shortcutGroups(context: ShortcutContext): Group[][] {
label: context.hasChanges ? "Map, Screens, Compare" : "Map, Screens",
keys: sections.map((section) => SHORTCUTS.canvas[section]),
},
...(CANVAS_NUMBER_KEYS
? [{ label: "The same, by their place in the toolbar", keys: sections.map((section) => SHORTCUTS.canvasByNumber[section]) }]
: []),
{ label: "Search screens", keys: [SHORTCUTS.app.search] },
...(context.handoff ? [{ label: "Hand off to AI", keys: [SHORTCUTS.app.handoff] }] : []),
...(context.hasChanges ? [{ label: "Changed screens menu", keys: [SHORTCUTS.app.changes] }] : []),
@@ -86,17 +83,9 @@ export function shortcutGroups(context: ShortcutContext): Group[][] {
{ label: "Close the inspector, then deselect", keys: ["Esc"] },
],
};
const screensGroup: Group = {
title: "Screens",
rows: [
{ label: "Move through the screens", keys: ["←", "→", "↑", "↓"] },
{ label: "Close the inspector, then deselect", keys: ["Esc"] },
],
};
const here: Group[] = context.canvas === "compare"
? [reviewGroup(context)]
: [...(context.review ? [reviewGroup(context)] : []), ...(context.canvas === "map" ? [mapGroup] : []),
...(context.canvas === "screens" ? [screensGroup] : []), CAMERA];
: [...(context.review ? [reviewGroup(context)] : []), ...(context.canvas === "map" ? [mapGroup] : []), CAMERA];
return [here, [goTo, view]];
}
-85
View File
@@ -184,91 +184,6 @@ button.screens-tree-row:hover { color: var(--text); background: var(--panel-hove
.screens-cell-via { overflow: hidden; color: var(--tertiary); font-size: 11px; text-overflow: ellipsis; white-space: nowrap; }
.screens-cell-elsewhere { color: var(--modified); font-size: 11px; font-weight: 600; }
/* ── Desktop grid ── */
/* One evenly spaced grid. Each screen is a card: the screenshot in a grey well and the route under it, with the
status as the tree's dot before it, the way file browsers show documents. Nothing is framed in the status colour,
so the page reads as a list of screens rather than a canvas of them. */
.screens-page:not(.phone) .screens-sections { display: block; padding-top: 0; }
.screens-page:not(.phone) .screens-grid { gap: 12px; }
/* Wide enough for a 28-character route after the dot, in the footer's 10.5px mono with room to spare: Linux's
fonts set it at about 183px. Five cards fit beside the tree at 1440px. */
.screens-page:not(.phone) .screens-cell { width: 216px; }
.screens-page:not(.phone) .screens-cell .screen-screenshot-card {
overflow: hidden;
gap: 0;
border: 1px solid var(--border-subtle);
border-radius: 12px;
background: var(--surface);
transition: border-color 120ms ease, box-shadow 120ms ease;
}
.screens-page:not(.phone) .screens-cell .screen-screenshot-card:has(.screen-screenshot-target:hover) { border-color: color-mix(in srgb, var(--accent) 55%, var(--border-subtle)); }
.screens-page:not(.phone) .screens-cell .screen-screenshot-card.selected { border-color: var(--accent); box-shadow: 0 0 0 1px var(--accent); }
/* The status is laid out against the card, not the screenshot, so it can sit in the footer. */
.screens-page:not(.phone) .screens-cell :is(.screen-screenshot-slot, .diff-frame) { position: static; }
.screens-page:not(.phone) .screens-cell .screen-screenshot-slot { order: 1; height: 236px; flex: none; padding: 12px 0; background: var(--element); }
.screens-page:not(.phone) .screens-cell .screen-screenshot-card.selected .screen-screenshot-slot { background: var(--accent-soft); }
.screens-page:not(.phone) .screens-cell .screen-node-image img,
.screens-page:not(.phone) .screens-cell .screen-node-image > .image-placeholder,
.screens-page:not(.phone) .screens-cell .screen-screenshot-card .diff-frame .screen-node-image img,
.screens-page:not(.phone) .screens-cell .screen-screenshot-card .diff-frame .screen-node-image > .image-placeholder {
border-color: transparent;
border-radius: 8px;
box-shadow: 0 1px 3px rgb(0 0 0 / 0.14);
}
/* The image box hugs the screenshot, so its corners and shadow are the screenshot's and no box shows around it. */
/* The screenshot fits the well both ways at its own proportions (styles.css's max-width and max-height), so a
landscape capture is framed as itself, not letterboxed inside a portrait-sized box. */
.screens-page:not(.phone) .screens-cell .screen-node-image img { width: auto; height: auto; background: transparent; }
/* No screenshot: the well has a size here, so the placeholder fits it the way styles.css fits it to a Map slot,
at the screenshot's proportions, rather than by the cell's width as a phone's cell does (phone.css). */
.screens-page:not(.phone) .screens-cell .screen-node-image:has(> .image-placeholder) { container-type: size; }
.screens-page:not(.phone) .screens-cell .screen-node-image > .image-placeholder {
width: min(
100cqw - 2 * var(--frame-border),
(100cqh - 2 * var(--frame-border)) * var(--screenshot-width) / var(--screenshot-height),
var(--screenshot-width) * 1px
);
height: min(
100cqh - 2 * var(--frame-border),
(100cqw - 2 * var(--frame-border)) * var(--screenshot-height) / var(--screenshot-width),
var(--screenshot-height) * 1px
);
aspect-ratio: auto;
}
/* A selected card's button is pressed, and a focused pressed button brightens (styles.css). Here that would wash out
the screenshot and, as a filter, become the box the status is placed in, lifting it into the well. Keyboard focus
rings the card instead. */
.screens-page:not(.phone) .screens-cell .screen-screenshot-target:focus-visible { filter: none; outline: 0; }
.screens-page:not(.phone) .screens-cell .screen-screenshot-card:has(.screen-screenshot-target:focus-visible) {
box-shadow: 0 0 0 3px color-mix(in srgb, var(--accent) 42%, transparent);
}
.screens-page:not(.phone) .screens-cell .screen-screenshot-card.selected:has(.screen-screenshot-target:focus-visible) {
box-shadow: 0 0 0 1px var(--accent), 0 0 0 4px color-mix(in srgb, var(--accent) 32%, transparent);
}
.screens-page:not(.phone) .screens-cell .screen-node-heading { order: 2; min-height: 0; padding: 10px 6px 10px 8px; }
.screens-page:not(.phone) .screens-cell .screen-screenshot-card:has(.diff-label) .screen-node-heading { padding-left: 20px; }
.screens-page:not(.phone) .screens-cell .screen-node-title { font-size: 10.5px; line-height: 14px; }
.screens-page:not(.phone) .screens-cell .screen-screenshot-card.selected .screen-node-title { color: var(--accent-strong); font-weight: 600; }
/* The status is the tree's dot before the route, in the status colour (a square for accessibility only); the word
stays in the label's accessible name. */
.screens-page:not(.phone) .screens-cell .screen-screenshot-card .diff-label {
top: auto;
bottom: 13.5px;
left: 8px;
width: 7px;
height: 7px;
overflow: hidden;
padding: 0;
border-radius: 50%;
color: transparent;
background: var(--diff);
box-shadow: none;
font-size: 0;
transform: none;
}
.screens-page:not(.phone) .screens-cell .diff-accessibility-only .diff-label { border-radius: 2px; }
.screens-page:not(.phone) .screens-cell :is(.screens-cell-via, .screens-cell-elsewhere) { padding-inline: 2px; }
/* ── Phone ── */
/* The space under the top bar is a block, not padding: both engines inset a sticky child's rest
position by the scroll container's padding, which pushed the section bar a bar's height too low. */
+18 -142
View File
@@ -5,11 +5,9 @@ import { primaryScreenshotForScreen, screenshotSize } from "../../utils/screen-i
import { diffClass, type BuildDiff, type DiffStatus } from "../../utils/build-diff";
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 { screenTree, treeIndex, treeNodeKey, 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 { HOLD_INITIAL_DELAY_MS, holdIntervalMs } from "../../utils/key-hold";
import { ScreenScreenshotCard } from "../canvas/screen-screenshot-card";
import { useCanvasVisibleFrame } from "../canvas/visible-frame-provider";
import { PhoneSheet } from "../phone/phone-chrome";
@@ -77,26 +75,6 @@ function cardId(id: string): string {
return `screens-card-${id.replace(/[^A-Za-z0-9_-]/g, "_")}`;
}
/**
* The card in the row above or below a screen's, nearest it across: read from where the cards sit, so it follows the
* grid however many columns the page has room for. A short last row still takes ↓ from the row above it.
*/
function cardInNextRow(from: string, ids: readonly string[], down: boolean): string | undefined {
const box = (id: string) => document.getElementById(cardId(id))?.getBoundingClientRect();
const here = box(from);
if (!here) return undefined;
const centre = (rect: DOMRect) => rect.left + rect.width / 2;
const rows = ids.flatMap(id => {
const rect = box(id);
return rect && (down ? rect.top >= here.bottom - 1 : rect.bottom <= here.top + 1) ? [{ id, rect }] : [];
});
if (!rows.length) return undefined;
const nearestTop = down ? Math.min(...rows.map(row => row.rect.top)) : Math.max(...rows.map(row => row.rect.top));
const row = rows.filter(candidate => Math.abs(candidate.rect.top - nearestTop) < 1);
return row.reduce((best, candidate) =>
Math.abs(centre(candidate.rect) - centre(here)) < Math.abs(centre(best.rect) - centre(here)) ? candidate : best).id;
}
function sectionAnchor(id: string): string {
return `screens-section-${id.replace(/[^A-Za-z0-9_-]/g, "_")}`;
}
@@ -190,7 +168,6 @@ function TreeRows(props: {
<button type="button" style={style}
className={`screens-tree-row${node.tab ? " tab" : ""}${props.visible.has(screen.id) ? "" : " filtered"}`}
aria-current={props.selectedScreenId === screen.id ? "true" : undefined}
data-screen-id={screen.id}
aria-expanded={key ? open : undefined}
data-tree-key={key}
onClick={() => props.onSelect(screen.id)}>
@@ -225,8 +202,8 @@ 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: a section per route folder (or per tab, when there are no route
* files), with the tree of them beside it on desktop and behind a Tree button on a phone.
*/
export function ScreensView(props: ScreensViewProps) {
const tree: ScreenTree = useMemo(
@@ -245,9 +222,6 @@ export function ScreensView(props: ScreensViewProps) {
const sections = tree.sections
.map(section => ({ ...section, screenIds: section.screenIds.filter(id => shown.has(id)) }))
.filter(section => section.screenIds.length > 0);
// The desktop grid reads in the tree's order, not the sections' (screen-tree.ts).
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())];
// Folding. All keeps the reader's folds and remembers them per report. Changed folds separately, starting
@@ -347,118 +321,12 @@ export function ScreensView(props: ScreensViewProps) {
requestAnimationFrame(() => document.getElementById(cardId(id))?.scrollIntoView({ block: "center", behavior: "smooth" }));
};
// 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
// at any width. A step picks the screen as the tree does, leaving the Inspector as it is, and focus follows it; with
// 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.
const orderRef = useRef(order);
orderRef.current = order;
const treeOrderRef = useRef(treeOrder);
treeOrderRef.current = treeOrder;
const selectedRef = useRef(selected);
selectedRef.current = selected;
const pickRef = useRef(props.onPickScreen ?? props.onSelectScreen);
pickRef.current = props.onPickScreen ?? props.onSelectScreen;
const openRef = useRef(props.onSelectScreen);
openRef.current = props.onSelectScreen;
useEffect(() => {
if (props.phone) return;
/** The card an arrow moves to from `from` (the pick, or the last card a hold stepped to). */
const next = (code: string, from: string | undefined): string | undefined => {
const ids = orderRef.current;
const vertical = code === "ArrowUp" || code === "ArrowDown";
const forward = code === "ArrowRight" || code === "ArrowDown";
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.
const shownIds = new Set(ids);
const all = treeOrderRef.current;
const at = all.indexOf(from);
return (forward ? all.slice(at + 1) : all.slice(0, at).reverse()).find(candidate => shownIds.has(candidate));
}
return forward ? ids[0] : ids[ids.length - 1];
};
const go = (id: string) => {
pickRef.current(id);
requestAnimationFrame(() => document.getElementById(cardId(id))?.querySelector<HTMLElement>(".screen-screenshot-target")?.focus({ preventScroll: true }));
};
let hold: { code: string; at: string; timer: ReturnType<typeof setTimeout> } | undefined;
const endHold = () => {
if (hold) clearTimeout(hold.timer);
hold = undefined;
};
const beginHold = (code: string, at: string) => {
endHold();
let step = 1;
const tick = () => {
const id = hold && next(code, hold.at);
if (!hold || !id) { endHold(); return; }
go(id);
hold = { code, at: id, timer: setTimeout(tick, holdIntervalMs(step)) };
step += 1;
};
hold = { code, at, timer: setTimeout(tick, HOLD_INITIAL_DELAY_MS) };
};
const onKeyDown = (event: globalThis.KeyboardEvent) => {
const arrow = ["ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown"].includes(event.code);
if (!arrow && event.key !== "Enter") return;
// The browser's own repeat of a held arrow would scroll the page under the hold.
if (event.repeat && hold?.code === event.code) { event.preventDefault(); return; }
if (event.metaKey || event.ctrlKey || event.altKey || event.shiftKey || event.defaultPrevented || !shortcutsLive(event)) return;
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;
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;
if (!onPage || target?.closest(".screens-tree-list")) return;
const id = next(event.code, selectedRef.current);
if (!id) return;
event.preventDefault();
go(id);
beginHold(event.code, id);
};
const onKeyUp = (event: globalThis.KeyboardEvent) => {
if (hold && event.code === hold.code) endHold();
};
window.addEventListener("keydown", onKeyDown);
window.addEventListener("keyup", onKeyUp);
window.addEventListener("blur", endHold);
return () => {
endHold();
window.removeEventListener("keydown", onKeyDown);
window.removeEventListener("keyup", onKeyUp);
window.removeEventListener("blur", endHold);
};
}, [props.phone]);
// The Inspector floats over the right edge; the page keeps its content clear of it.
const { visibleFrame } = useCanvasVisibleFrame();
const style = !props.phone && visibleFrame
? ({ "--screens-right-inset": `calc(100% - ${visibleFrame.x + visibleFrame.width}px)` } as CSSProperties)
: undefined;
const cell = (id: string) => {
const screen = props.index.screens.get(id);
return screen ? (
<ScreenCell key={id} screen={screen} index={props.index} diff={props.diff}
elsewhere={isChanged(props.diff, id) ? undefined : props.changedElsewhere?.get(id)}
via={tree.via.get(id)}
selected={props.selectedScreenId === id}
dimmed={Boolean(props.focus?.length) && !props.focus!.some((state) => state === focusStatusOf(props.diff?.screens.get(id)))}
onSelect={() => props.onSelectScreen(id)} />
) : null;
};
const treeRows = (
<ul className="screens-tree-list" onKeyDown={onTreeKey}>
<TreeRows nodes={tree.tree} depth={0} index={props.index} diff={props.diff} elsewhere={props.changedElsewhere}
@@ -510,20 +378,28 @@ export function ScreensView(props: ScreensViewProps) {
</aside>
)}
<div className="screens-sections">
{props.phone ? sections.map(section => (
{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>
{section.path ? <span className="path">{breakAfterSlashes(section.title)}</span>
: section.subtitle ? <span>{section.subtitle}</span> : null}
</header>
<div className="screens-grid">{section.screenIds.map(cell)}</div>
<div className="screens-grid">
{section.screenIds.map(id => {
const screen = props.index.screens.get(id);
return screen ? (
<ScreenCell key={id} screen={screen} index={props.index} diff={props.diff}
elsewhere={isChanged(props.diff, id) ? undefined : props.changedElsewhere?.get(id)}
via={tree.via.get(id)}
selected={props.selectedScreenId === id}
dimmed={Boolean(props.focus?.length) && !props.focus!.some((state) => state === focusStatusOf(props.diff?.screens.get(id)))}
onSelect={() => props.onSelectScreen(id)} />
) : null;
})}
</div>
</section>
)) : (
// On desktop the tree beside the page already shows the folders, so every screen sits in one evenly
// spaced grid in the tree's order, without headings between them.
<div className="screens-grid">{order.map(cell)}</div>
)}
))}
</div>
</div>
+1 -1
View File
@@ -54,7 +54,7 @@ export function handoffPrompt(input: HandoffInput, view?: HandoffView): string {
input.pageUrl,
"",
`Fetch the link first${local ? " (from this machine, with curl if your fetch tool refuses local addresses)" : ""}. It explains the report's JSON API. Go through the changed screens, compare the before and after screenshots${appearances}, and tell me which changes look intended and which look like regressions. For each regression, name the source file to fix.`,
...(local ? ["", "The link is served by `expo-explore capture` on this machine and stops working when it exits."] : []),
...(local ? ["", "The link is served by `expo-explore capture:review` on this machine and stops working when it exits."] : []),
];
if (view) {
const where = [view.screen, view.view, view.platform, view.appearance].filter(Boolean).join(" · ");
+2 -2
View File
@@ -4,8 +4,8 @@
* or a spinner accelerates. The browser's own key repeat is ignored (its rate is a fixed OS setting),
* so the hold is timed here and ends on key up, blur, or the end of the list.
*/
export const HOLD_INITIAL_DELAY_MS = 250;
export const HOLD_FIRST_INTERVAL_MS = 200;
export const HOLD_INITIAL_DELAY_MS = 400;
export const HOLD_FIRST_INTERVAL_MS = 300;
export const HOLD_FLOOR_INTERVAL_MS = 70;
const HOLD_DECAY = 0.8;
-16
View File
@@ -228,22 +228,6 @@ export type ScreenTreeIndex = {
parents: Map<string, string>;
};
/**
* Every screen in the order the tree lists it: depth first, so a subfolder's screens follow its parent folder's own,
* where sections list folders in the order they were found. A screen the tree leaves out comes last.
*/
export function treeScreenOrder(tree: ScreenTree): string[] {
const ids: string[] = [];
const walk = (nodes: readonly ScreenTreeNode[]) => {
for (const node of nodes) {
if (node.kind === "screen") ids.push(node.screenId);
walk(node.children);
}
};
walk(tree.tree);
return [...new Set([...ids, ...tree.sections.flatMap(section => section.screenIds)])];
}
export function treeIndex(tree: readonly ScreenTreeNode[]): ScreenTreeIndex {
const index: ScreenTreeIndex = { keys: [], screensUnder: new Map(), ancestors: new Map(), parents: new Map() };
const walk = (nodes: readonly ScreenTreeNode[], above: string[]): string[] => nodes.flatMap((node) => {
+3 -23
View File
@@ -7,8 +7,6 @@ export type Shortcut = {
code: string;
/** ⌘ on Apple keyboards, Ctrl everywhere else. */
mod?: boolean;
/** The Control key itself on every keyboard, for chords whose ⌘ form the browser keeps (⌘1–⌘9 switch tabs). */
ctrl?: boolean;
/** ⌥ on Apple keyboards, Alt everywhere else. */
alt?: boolean;
shift?: boolean;
@@ -19,12 +17,6 @@ export type Shortcut = {
const APPLE = typeof navigator !== "undefined"
&& /Mac|iPhone|iPad|iPod/.test(navigator.platform || navigator.userAgent);
/**
* Whether Ctrl+1–3 reach the page. On Apple keyboards ⌃ is free (the browser's tab keys are ⌘1–9); elsewhere the
* browser keeps Ctrl+1–8 for its tabs, so those keys are neither handled nor printed there.
*/
export const CANVAS_NUMBER_KEYS = APPLE;
function mod(code: string, key: string): Shortcut {
return { code, key, mod: true };
}
@@ -33,10 +25,6 @@ function modShift(code: string, key: string): Shortcut {
return { code, key, mod: true, shift: true };
}
function ctrl(code: string, key: string): Shortcut {
return { code, key, ctrl: true };
}
function shift(code: string, key: string): Shortcut {
return { code, key, shift: true };
}
@@ -80,12 +68,6 @@ export const SHORTCUTS = {
screens: plain("KeyS", "S"),
compare: plain("KeyC", "C"),
},
/** The canvases by their place in the toolbar, as tabs are numbered elsewhere. Apple keyboards only (CANVAS_NUMBER_KEYS). */
canvasByNumber: {
map: ctrl("Digit1", "1"),
screens: ctrl("Digit2", "2"),
compare: ctrl("Digit3", "3"),
},
/** Compare only. The arrows walk changed screens; J and K walk the changed areas of one. */
compare: {
previousScreen: plain("ArrowLeft", "←"),
@@ -110,10 +92,10 @@ export const SHORTCUTS = {
/** The hint, in the idiom of the keyboard reading it: Apple's ⌥⇧⌘ order, or Ctrl+Alt+Shift. */
export function formatShortcut(shortcut: Shortcut, apple = APPLE): string {
if (apple) {
return `${shortcut.ctrl ? "⌃" : ""}${shortcut.alt ? "⌥" : ""}${shortcut.shift ? "⇧" : ""}${shortcut.mod ? "⌘" : ""}${shortcut.key}`;
return `${shortcut.alt ? "⌥" : ""}${shortcut.shift ? "⇧" : ""}${shortcut.mod ? "⌘" : ""}${shortcut.key}`;
}
const parts: string[] = [];
if (shortcut.mod || shortcut.ctrl) parts.push("Ctrl");
if (shortcut.mod) parts.push("Ctrl");
if (shortcut.alt) parts.push("Alt");
if (shortcut.shift) parts.push("Shift");
parts.push(shortcut.key);
@@ -122,9 +104,7 @@ export function formatShortcut(shortcut: Shortcut, apple = APPLE): string {
export function matchesShortcut(event: KeyboardEvent, shortcut: Shortcut): boolean {
if (event.code !== shortcut.code) return false;
if (shortcut.ctrl) {
if (!event.ctrlKey || event.metaKey) return false;
} else if ((event.metaKey || event.ctrlKey) !== Boolean(shortcut.mod)) return false;
if ((event.metaKey || event.ctrlKey) !== Boolean(shortcut.mod)) return false;
if (event.shiftKey !== Boolean(shortcut.shift)) return false;
return event.altKey === Boolean(shortcut.alt);
}