diff --git a/packages/app/e2e/browser/file-editing.spec.ts b/packages/app/e2e/browser/file-editing.spec.ts
index 049c765640..caac7d040c 100644
--- a/packages/app/e2e/browser/file-editing.spec.ts
+++ b/packages/app/e2e/browser/file-editing.spec.ts
@@ -777,7 +777,9 @@ test.describe("CodeMirror workspace file editing", () => {
await replaceEditorText(page, "# Saved from source\n");
await expect(page.getByTestId("workspace-tab-modified-file_notes.md")).toBeVisible();
await selectFileView(page, "Preview");
- await expect(visibleFilePane.getByText("Saved from source", { exact: true })).toBeVisible();
+ await expect(
+ visibleFilePane.getByRole("heading", { name: "Saved from source", exact: true }),
+ ).toBeVisible();
await expect(toolbar.getByLabel("Line 1, column 1")).toHaveCount(0);
await expect.poll(() => readFile(markdownPath, "utf8")).toBe("# Saved from source\n");
await expect(page.getByTestId("workspace-tab-modified-file_notes.md")).not.toBeVisible();
@@ -864,11 +866,52 @@ test.describe("CodeMirror workspace file editing", () => {
await selectFileView(page, "Source");
await expect(page.getByTestId("file-source-editor")).toBeVisible();
- await expect(preview.host).toHaveCount(0);
+ await expect(preview.host).toBeHidden();
await selectFileView(page, "Preview");
await expect(preview.host).toBeVisible();
});
+ test("shows the changed HTML page after the file changes on disk while Source shows", async ({
+ page,
+ withWorkspace,
+ }) => {
+ const workspace = await withWorkspace({ prefix: "file-editing-html-hidden-change-" });
+ const htmlPath = path.join(workspace.repoPath, "plan.html");
+ await writeFile(htmlPath, "
First plan
");
+ await workspace.navigateTo();
+ await openWorkspaceFile(page, "plan.html");
+ const preview = htmlPreview(page);
+ await expect(preview.document.getByRole("heading", { name: "First plan" })).toBeVisible();
+
+ await selectFileView(page, "Source");
+ await writeFile(htmlPath, "Changed on disk
");
+ await expect(editor(page)).toContainText("Changed on disk");
+ await selectFileView(page, "Preview");
+
+ await expect(preview.document.getByRole("heading", { name: "Changed on disk" })).toBeVisible();
+ });
+
+ test("shows the HTML page edited in Source when Preview shows again", async ({
+ page,
+ withWorkspace,
+ }) => {
+ const workspace = await withWorkspace({ prefix: "file-editing-html-hidden-edit-" });
+ await writeFile(
+ path.join(workspace.repoPath, "plan.html"),
+ "First plan
",
+ );
+ await workspace.navigateTo();
+ await openWorkspaceFile(page, "plan.html");
+ const preview = htmlPreview(page);
+ await expect(preview.document.getByRole("heading", { name: "First plan" })).toBeVisible();
+
+ await selectFileView(page, "Source");
+ await replaceEditorText(page, "Edited plan
");
+ await selectFileView(page, "Preview");
+
+ await expect(preview.document.getByRole("heading", { name: "Edited plan" })).toBeVisible();
+ });
+
test("keeps HTML fragment links in the preview and scrolls to the target", async ({
page,
withWorkspace,
diff --git a/packages/app/e2e/browser/file-view-scroll.spec.ts b/packages/app/e2e/browser/file-view-scroll.spec.ts
new file mode 100644
index 0000000000..9aac09d32d
--- /dev/null
+++ b/packages/app/e2e/browser/file-view-scroll.spec.ts
@@ -0,0 +1,130 @@
+import { writeFile } from "node:fs/promises";
+import path from "node:path";
+import { expect, test, type Page } from "../support/fixtures";
+import { openFileExplorer, openFileFromExplorer } from "../support/helpers/file-explorer";
+
+// Switching a file tab between Preview and Source returns to where each view was left.
+
+const sections = Array.from({ length: 200 }, (_, index) => index);
+const LONG_MARKDOWN = sections.map((i) => `## Section ${i}\n\nParagraph ${i}.\n`).join("\n");
+const LONG_HTML = `${sections
+ .map((i) => `Section ${i}
Paragraph ${i}
`)
+ .join("")}`;
+
+type FileView = "markdown preview" | "html preview" | "source";
+
+function htmlPreviewFrame(page: Page) {
+ const frame = page.frames().find((candidate) => candidate.url().startsWith("data:text/html"));
+ if (!frame) throw new Error("The HTML preview frame is not loaded.");
+ return frame;
+}
+
+/**
+ * Moves the view's visible scroller to `offset` when given, and returns its offset. The
+ * scroller is Markdown's scroll view, CodeMirror's scroller, or the HTML page itself.
+ */
+async function viewScroll(page: Page, view: FileView, offset?: number): Promise {
+ if (view === "html preview") {
+ return htmlPreviewFrame(page).evaluate((target) => {
+ if (target !== undefined) window.scrollTo(0, target);
+ return window.scrollY;
+ }, offset);
+ }
+ return page.evaluate(
+ (input) => {
+ const visible = (element: HTMLElement) => element.offsetParent !== null;
+ let scroller: HTMLElement | null;
+ if (input.view === "source") {
+ scroller =
+ [...document.querySelectorAll(".cm-scroller")].find(visible) ?? null;
+ } else {
+ scroller =
+ [
+ ...document.querySelectorAll('[data-testid="markdown-preview-frame"]'),
+ ].find(visible) ?? null;
+ while (scroller && !(scroller.scrollHeight > scroller.clientHeight + 10)) {
+ scroller = scroller.parentElement;
+ }
+ }
+ if (!scroller) throw new Error(`No visible scroller for the ${input.view}.`);
+ if (input.offset !== undefined) scroller.scrollTop = input.offset;
+ return scroller.scrollTop;
+ },
+ { view, offset },
+ );
+}
+
+async function openLongFile(
+ page: Page,
+ withWorkspace: (options?: { prefix?: string }) => Promise<{
+ repoPath: string;
+ navigateTo(): Promise;
+ }>,
+ name: string,
+ content: string,
+): Promise {
+ const workspace = await withWorkspace({ prefix: "file-view-scroll-" });
+ await writeFile(path.join(workspace.repoPath, name), content);
+ await workspace.navigateTo();
+ await openFileExplorer(page);
+ await openFileFromExplorer(page, name);
+ await expect(page.getByTestId("file-mode-preview")).toBeVisible({ timeout: 30_000 });
+}
+
+async function showView(page: Page, view: "preview" | "source"): Promise {
+ await page.getByTestId(`file-mode-${view}`).click();
+}
+
+/** Scrolls the view past the first screen and returns where it settled. */
+async function scrollDown(page: Page, view: FileView): Promise {
+ await expect(async () => {
+ expect(await viewScroll(page, view, 1200)).toBeGreaterThan(1000);
+ }).toPass({ timeout: 15_000 });
+ // CodeMirror can adjust the offset once after a scroll; read it after that settles.
+ await page.waitForTimeout(300);
+ return viewScroll(page, view);
+}
+
+async function expectOffsetKept(page: Page, view: FileView, offset: number): Promise {
+ await expect.poll(() => viewScroll(page, view), { timeout: 5_000 }).toBe(offset);
+}
+
+test("Markdown preview keeps its scroll offset after showing Source", async ({
+ page,
+ withWorkspace,
+}) => {
+ await openLongFile(page, withWorkspace, "long.md", LONG_MARKDOWN);
+ const offset = await scrollDown(page, "markdown preview");
+
+ await showView(page, "source");
+ await expect(page.getByTestId("file-source-editor")).toBeVisible();
+ await showView(page, "preview");
+
+ await expectOffsetKept(page, "markdown preview", offset);
+});
+
+test("HTML preview keeps its scroll offset after showing Source", async ({
+ page,
+ withWorkspace,
+}) => {
+ await openLongFile(page, withWorkspace, "long.html", LONG_HTML);
+ const offset = await scrollDown(page, "html preview");
+
+ await showView(page, "source");
+ await expect(page.getByTestId("file-source-editor")).toBeVisible();
+ await showView(page, "preview");
+
+ await expectOffsetKept(page, "html preview", offset);
+});
+
+test("Source keeps its scroll offset after showing Preview", async ({ page, withWorkspace }) => {
+ await openLongFile(page, withWorkspace, "long.md", LONG_MARKDOWN);
+ await showView(page, "source");
+ const offset = await scrollDown(page, "source");
+
+ await showView(page, "preview");
+ await expect(page.getByTestId("markdown-preview-frame")).toBeVisible();
+ await showView(page, "source");
+
+ await expectOffsetKept(page, "source", offset);
+});
diff --git a/packages/app/src/file-panels/html-preview-navigation-guard.test.tsx b/packages/app/src/file-panels/html-preview-navigation-guard.test.tsx
new file mode 100644
index 0000000000..d9e03ad658
--- /dev/null
+++ b/packages/app/src/file-panels/html-preview-navigation-guard.test.tsx
@@ -0,0 +1,48 @@
+// @vitest-environment jsdom
+
+import { renderHook } from "@testing-library/react";
+import type { ReactNode } from "react";
+import { describe, expect, it } from "vitest";
+import { RetainedPanelActivity } from "@/components/retained-panel";
+import { useHtmlPreviewNavigationGuard } from "./html-preview-navigation";
+
+const DOCUMENT = "report";
+
+function renderGuard(initialActive: boolean) {
+ let active = initialActive;
+ const view = renderHook(() => useHtmlPreviewNavigationGuard(DOCUMENT), {
+ wrapper: ({ children }: { children: ReactNode }) => (
+ {children}
+ ),
+ });
+ return {
+ navigate: (url: string) => view.result.current({ url }),
+ setActive(next: boolean) {
+ active = next;
+ view.rerender();
+ },
+ };
+}
+
+describe("useHtmlPreviewNavigationGuard", () => {
+ it("loads the document once and refuses the page loading it again", () => {
+ const guard = renderGuard(true);
+
+ expect(guard.navigate("about:blank")).toBe(true);
+ expect(guard.navigate("about:blank")).toBe(false);
+ expect(guard.navigate("https://example.com/leak")).toBe(false);
+ expect(guard.navigate("about:blank#section")).toBe(true);
+ });
+
+ it("loads the document again in the WebView that shows after the panel was hidden", () => {
+ const guard = renderGuard(true);
+ expect(guard.navigate("about:blank")).toBe(true);
+
+ // iOS destroys the native WebView of a hidden panel and makes a new one when it shows.
+ guard.setActive(false);
+ guard.setActive(true);
+
+ expect(guard.navigate("about:blank")).toBe(true);
+ expect(guard.navigate("about:blank")).toBe(false);
+ });
+});
diff --git a/packages/app/src/file-panels/html-preview-navigation.ts b/packages/app/src/file-panels/html-preview-navigation.ts
index fafd4e5793..151dd1657f 100644
--- a/packages/app/src/file-panels/html-preview-navigation.ts
+++ b/packages/app/src/file-panels/html-preview-navigation.ts
@@ -1,3 +1,6 @@
+import { useCallback, useEffect, useRef } from "react";
+import { useRetainedPanelActive } from "@/components/retained-panel";
+
export type HtmlPreviewNavigationKind = "initialDocument" | "fragment" | "blocked";
const INITIAL_DOCUMENT_URLS = new Set(["about:blank", "about:srcdoc", ""]);
@@ -7,3 +10,35 @@ export function htmlPreviewNavigationKind(url: string): HtmlPreviewNavigationKin
if (url.startsWith("about:blank#") || url.startsWith("about:srcdoc#")) return "fragment";
return "blocked";
}
+
+/**
+ * Decides each navigation the native WebView asks about: the document loads once, a fragment
+ * moves within it, and anything else is refused.
+ */
+export function useHtmlPreviewNavigationGuard(
+ document: string,
+): (request: { url: string }) => boolean {
+ // Latched per document rather than once for the lifetime of the WebView: the
+ // file pane re-renders with new content on every live-file refresh, and each of
+ // those is a fresh initial load that has to be allowed through.
+ const loadedDocumentRef = useRef(null);
+ // The latch belongs to one native WebView, not to this component. iOS destroys the WebView of a
+ // hidden retained panel and makes a new one when the panel shows, and that one loads the
+ // document again. Releasing the latch while hidden lets that load through; a page on a kept
+ // WebView gains at most a load of an inert initial URL.
+ const active = useRetainedPanelActive();
+ useEffect(() => {
+ if (!active) loadedDocumentRef.current = null;
+ }, [active]);
+ return useCallback(
+ ({ url }: { url: string }) => {
+ const navigationKind = htmlPreviewNavigationKind(url);
+ if (navigationKind === "fragment") return true;
+ if (navigationKind === "blocked") return false;
+ if (loadedDocumentRef.current === document) return false;
+ loadedDocumentRef.current = document;
+ return true;
+ },
+ [document],
+ );
+}
diff --git a/packages/app/src/file-panels/html-preview.tsx b/packages/app/src/file-panels/html-preview.tsx
index 08ded111e7..752a048390 100644
--- a/packages/app/src/file-panels/html-preview.tsx
+++ b/packages/app/src/file-panels/html-preview.tsx
@@ -1,8 +1,8 @@
-import { useCallback, useMemo, useRef } from "react";
+import { useMemo } from "react";
import { StyleSheet } from "react-native-unistyles";
import { WebView } from "react-native-webview";
import { withPreviewCsp } from "./html-preview-csp";
-import { htmlPreviewNavigationKind } from "./html-preview-navigation";
+import { useHtmlPreviewNavigationGuard } from "./html-preview-navigation";
// A preview is a viewer, not a browser. Only the document Paseo hands the WebView
// loads; navigations the page attempts afterwards are refused, so a link, a
@@ -35,21 +35,7 @@ const BASE_URL = "about:blank";
export function FileHtmlPreview({ html, testID }: { html: string; testID?: string }) {
const document = useMemo(() => withPreviewCsp(html), [html]);
const source = useMemo(() => ({ html: document, baseUrl: BASE_URL }), [document]);
- // Latched per document rather than once for the lifetime of the WebView: the
- // file pane re-renders with new content on every live-file refresh, and each of
- // those is a fresh initial load that has to be allowed through.
- const loadedDocumentRef = useRef(null);
- const allowOnlyInitialDocument = useCallback(
- ({ url }: { url: string }) => {
- const navigationKind = htmlPreviewNavigationKind(url);
- if (navigationKind === "fragment") return true;
- if (navigationKind === "blocked") return false;
- if (loadedDocumentRef.current === document) return false;
- loadedDocumentRef.current = document;
- return true;
- },
- [document],
- );
+ const allowOnlyInitialDocument = useHtmlPreviewNavigationGuard(document);
return (
{
+ it("loads a changed document in a new frame", () => {
+ const view = render();
+ const firstFrame = view.getByTestId("preview");
+
+ view.rerender();
+ const changedFrame = view.getByTestId("preview");
+
+ expect(changedFrame).not.toBe(firstFrame);
+ expect(decodeURIComponent(changedFrame.getAttribute("src") ?? "")).toContain("Changed plan");
+ });
+});
diff --git a/packages/app/src/file-panels/html-preview.web.tsx b/packages/app/src/file-panels/html-preview.web.tsx
index eac275bfe8..fc56a4038b 100644
--- a/packages/app/src/file-panels/html-preview.web.tsx
+++ b/packages/app/src/file-panels/html-preview.web.tsx
@@ -32,7 +32,11 @@ export function FileHtmlPreview({ html, testID }: { html: string; testID?: strin
[html],
);
return (
+ // Each document loads in a new frame. The Source view keeps this preview mounted and hidden,
+ // and it gets a changed document in the same render that shows it again. Chromium can leave a
+ // reused frame blank when it navigates at that moment.
- {showPreview ? (
-
- ) : (
+ {Preview ? (
+
+ ) : null}
+
- )}
+
);
}
@@ -237,9 +249,17 @@ function EditableTextFile({
vimMode={showPreview ? null : vimMode}
conflict={conflict}
/>
- {showPreview ? (
-
- ) : (
+ {Preview ? (
+
+ ) : null}
+
- )}
+
);
}
+/**
+ * A view of the panel that stays mounted, hidden, while the other view shows, so switching back
+ * returns to the same scroll offset. It mounts the first time it shows.
+ */
+function RetainedView({ active, children }: { active: boolean; children: ReactNode }) {
+ const [shown, setShown] = useState(active);
+ if (active && !shown) setShown(true);
+ if (!shown) return null;
+ return (
+
+ {children}
+
+ );
+}
+
+/**
+ * The Preview, retained like the Source. While hidden it keeps the text it last showed, so
+ * editing in Source does not render the hidden Preview on every change.
+ */
+function RetainedPreview({
+ active,
+ preview: Preview,
+ text,
+ params,
+ workspaceId,
+ host,
+}: TextFilePreviewProps & { active: boolean; preview: ComponentType }) {
+ const [shownText, setShownText] = useState(text);
+ if (active && shownText !== text) setShownText(text);
+ const previewText = active ? text : shownText;
+ const preview = useMemo(
+ () => ,
+ [Preview, previewText, params, workspaceId, host],
+ );
+ return {preview};
+}
+
/** The editor over the panel's buffer. Each mount shows Loading until the editor shows the text. */
function SourceEditor(props: Omit, "onReady">) {
const [ready, setReady] = useState(false);
@@ -268,6 +325,7 @@ function SourceEditor(props: Omit, "
const styles = StyleSheet.create((theme) => ({
container: { flex: 1, minHeight: 0 },
+ view: { minHeight: 0 },
editor: { flex: 1, minHeight: 0 },
centerState: {
flex: 1,