Skip to content

DeepTutor: Lifelong Personalized Tutoring. https://deeptutor.info/.

fix(reading): preserve PDF reading position across resizes

ZyPulsec0a51ce90ec6
diff --git a/web/components/reading/PdfDocumentView.tsx b/web/components/reading/PdfDocumentView.tsx
index 8ab121f13..2f6fcbeb7 100644
--- a/web/components/reading/PdfDocumentView.tsx
+++ b/web/components/reading/PdfDocumentView.tsx
@@ -1,6 +1,13 @@
"use client";
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import {
+ useCallback,
+ useEffect,
+ useLayoutEffect,
+ useMemo,
+ useRef,
+ useState,
+} from "react";
import { Loader2 } from "lucide-react";
import { useTranslation } from "react-i18next";
import { loadPdfjs, pdfjsWasmUrl, type PdfDocument } from "@/lib/pdfjs-loader";
@@ -91,6 +98,13 @@ export function PdfDocumentView({
message: string;
} | null>(null);
const [pageWidth, setPageWidth] = useState(0);
+ const committedWidthRef = useRef(0);
+ const resizeAnchorRef = useRef<{
+ doc: PdfDocument;
+ locator: string;
+ fraction: number;
+ viewportOffset: number;
+ } | null>(null);
const [visibleLocator, setVisibleLocator] = useState(1);
// Tagged with the jump's nonce for the same reason: a stale flash cannot
// outlive the request that produced it.
@@ -158,13 +172,61 @@ export function PdfDocumentView({
// -- width ---------------------------------------------------------------
+ useLayoutEffect(() => {
+ committedWidthRef.current = pageWidth;
+ const anchor = resizeAnchorRef.current;
+ resizeAnchorRef.current = null;
+ const root = scrollRef.current;
+ if (!root || !anchor || anchor.doc !== doc) return;
+ const page = root.querySelector<HTMLElement>(
+ `[data-reader-unit="${anchor.locator}"]`,
+ );
+ if (!page) return;
+ const rect = page.getBoundingClientRect();
+ // Restore after the new page heights commit, before paint or the visible
+ // locator effect can report the page at the old pixel scroll position.
+ root.scrollTop = Math.max(
+ 0,
+ root.scrollTop +
+ rect.top -
+ root.getBoundingClientRect().top +
+ anchor.fraction * rect.height -
+ anchor.viewportOffset,
+ );
+ }, [doc, pageWidth]);
+
useEffect(() => {
const element = scrollRef.current;
if (!element) return;
const measure = () => {
// Leave room for the scrollbar gutter and the page's own margin.
const available = element.clientWidth - 48;
- setPageWidth(Math.max(240, Math.min(1100, available)));
+ const nextWidth = Math.max(240, Math.min(1100, available));
+ if (nextWidth === committedWidthRef.current) {
+ // A resize can return to the committed width before React renders.
+ // Do not leave an unused anchor to override a later user scroll.
+ resizeAnchorRef.current = null;
+ } else if (doc && !resizeAnchorRef.current) {
+ const rootRect = element.getBoundingClientRect();
+ const pages =
+ element.querySelectorAll<HTMLElement>("[data-reader-unit]");
+ for (const page of pages) {
+ const rect = page.getBoundingClientRect();
+ if (rect.height <= 0 || rect.bottom <= rootRect.top) continue;
+ if (rect.top >= rootRect.bottom) break;
+ // The first visible page anchors the viewport's top edge. Keep the
+ // point in page coordinates, plus any padding/gap above that page.
+ // Coalesced notifications retain this anchor until the width commits.
+ resizeAnchorRef.current = {
+ doc,
+ locator: page.dataset.readerUnit!,
+ fraction: Math.max(0, (rootRect.top - rect.top) / rect.height),
+ viewportOffset: Math.max(0, rect.top - rootRect.top),
+ };
+ break;
+ }
+ }
+ setPageWidth(nextWidth);
};
measure();
const observer = new ResizeObserver(measure);
diff --git a/web/tests/e2e/pdf-reading-resize.audit.ts b/web/tests/e2e/pdf-reading-resize.audit.ts
new file mode 100644
index 000000000..cb2431d3f
--- /dev/null
+++ b/web/tests/e2e/pdf-reading-resize.audit.ts
@@ -0,0 +1,221 @@
+import { expect, test, type Locator } from "@playwright/test";
+import { jsPDF } from "jspdf";
+
+const MATERIAL_ID = "dddddddddddddddd";
+const WORKSPACE_ID = "pdf-resize-workspace";
+const SESSION_ID = "pdf-resize-session";
+const PAGE_COUNT = 160;
+
+function pdfFixture(): Buffer {
+ const document = new jsPDF({ format: "a4" });
+ for (let locator = 1; locator <= PAGE_COUNT; locator += 1) {
+ if (locator > 1) document.addPage();
+ document.text(`Resize regression page ${locator}`, 20, 30);
+ }
+ return Buffer.from(document.output("arraybuffer"));
+}
+
+const pdfBytes = pdfFixture();
+const material = {
+ material_id: MATERIAL_ID,
+ content_id: MATERIAL_ID,
+ filename: "resize-regression.pdf",
+ title: "PDF resize regression",
+ source_kind: "file",
+ source_url: "",
+ unit: "page",
+ unit_count: PAGE_COUNT,
+ mime: "application/pdf",
+ render_mode: "pdf",
+ has_raw_view: true,
+ status: "ready",
+ progress: 0,
+ cover_url: "",
+ error_code: "",
+ error_detail: "",
+ byte_size: pdfBytes.length,
+ size_bytes: pdfBytes.length,
+ char_count: 1000,
+ created_at: 1,
+ updated_at: 2,
+ last_opened_at: 2,
+ collections: [],
+ annotation_count: 0,
+ outline: [],
+ outline_text: "",
+ unit_refs: [],
+};
+
+test.beforeEach(async ({ page }) => {
+ await page.route("**/api/**", async (route) => {
+ const path = new URL(route.request().url()).pathname;
+ const json = (payload: unknown) => route.fulfill({ json: payload });
+ if (path === "/api/auth/status") {
+ return json({ enabled: false, authenticated: true });
+ }
+ if (path === "/api/settings/ui") return json({ language: "en" });
+ if (path === "/api/dashboard/suggestions") {
+ return json({ suggestions: [], stale: false });
+ }
+ if (path === "/api/settings/llm-options") {
+ return json({
+ active: { profile_id: "p", model_id: "m" },
+ options: [
+ {
+ profile_id: "p",
+ model_id: "m",
+ profile_name: "Profile",
+ model_name: "Model",
+ model: "model",
+ provider: "provider",
+ is_active_default: true,
+ },
+ ],
+ });
+ }
+ if (path === "/api/partners" || path === "/api/partner-groups")
+ return json([]);
+ if (path === "/api/sessions") return json({ sessions: [] });
+ if (path === `/api/sessions/${SESSION_ID}`) {
+ return json({
+ id: SESSION_ID,
+ session_id: SESSION_ID,
+ title: material.title,
+ created_at: 1,
+ updated_at: 2,
+ status: "idle",
+ preferences: { capability: "immersive_reading" },
+ active_turns: [],
+ messages: [],
+ });
+ }
+ if (path === `/api/reading/workspaces/${WORKSPACE_ID}`) {
+ return json({
+ workspace: {
+ workspace_id: WORKSPACE_ID,
+ title: material.title,
+ description: "",
+ active_material_id: MATERIAL_ID,
+ created_at: 1,
+ updated_at: 2,
+ tabs: [
+ {
+ material,
+ tab_order: 0,
+ pinned: false,
+ opened: true,
+ added_at: 1,
+ },
+ ],
+ },
+ sessions: [],
+ });
+ }
+ if (path === `/api/reading/workspaces/${WORKSPACE_ID}/sessions`) {
+ return json({ sessions: [] });
+ }
+ if (path === "/api/reading/supported-formats") {
+ return json({
+ extensions: [".pdf"],
+ max_bytes: 1024 * 1024,
+ raw_view_extensions: [".pdf"],
+ });
+ }
+ if (path === "/api/reading/extensions" || path.endsWith("/annotations"))
+ return json([]);
+ if (path === "/api/reading/materials") return json([material]);
+ if (path === `/api/reading/materials/${MATERIAL_ID}`) return json(material);
+ if (path === `/api/reading/materials/${MATERIAL_ID}/raw`) {
+ return route.fulfill({ contentType: "application/pdf", body: pdfBytes });
+ }
+ if (path.endsWith("/position"))
+ return json({ locator: 1, source_anchor: "" });
+ const unit = /\/units\/(\d+)$/.exec(path);
+ if (unit) {
+ return json({
+ locator: Number(unit[1]),
+ unit: "page",
+ text: `Resize regression page ${unit[1]}`,
+ });
+ }
+ return json({});
+ });
+});
+
+async function withinPage(root: Locator, locator: number): Promise<number> {
+ return root.evaluate((element, pageNumber) => {
+ const page = element.querySelector<HTMLElement>(
+ `[data-reader-unit="${pageNumber}"]`,
+ )!;
+ const pageRect = page.getBoundingClientRect();
+ return (
+ (element.getBoundingClientRect().top - pageRect.top) / pageRect.height
+ );
+ }, locator);
+}
+
+test("keeps the reading point when annotations toggle and the window resizes", async ({
+ page,
+}) => {
+ await page.setViewportSize({ width: 1440, height: 900 });
+ await page.goto(`/learning/reading/${WORKSPACE_ID}/sessions/${SESSION_ID}`, {
+ waitUntil: "domcontentloaded",
+ });
+ const root = page
+ .locator(".dt-reader-scroll")
+ .filter({ has: page.locator('[data-reader-unit="99"]') });
+ await expect(root).toBeVisible();
+ await expect(root.locator('[data-reader-unit="1"] .textLayer')).toContainText(
+ "Resize regression page 1",
+ );
+ await page
+ .getByRole("button", { name: "Expand contents", exact: true })
+ .click();
+ await page.getByRole("tab", { name: "Annotations", exact: true }).click();
+
+ await root.evaluate((element) => {
+ const target = element.querySelector<HTMLElement>(
+ '[data-reader-unit="99"]',
+ )!;
+ const rect = target.getBoundingClientRect();
+ element.scrollTop +=
+ rect.top - element.getBoundingClientRect().top + rect.height * 0.3;
+ });
+ await expect(
+ root.locator('[data-reader-unit="99"] .textLayer'),
+ ).toContainText("Resize regression page 99");
+ await expect.poll(() => withinPage(root, 99)).toBeCloseTo(0.3, 2);
+
+ for (const control of ["Close contents", "Expand contents"]) {
+ const beforeWidth = await root
+ .locator('[data-reader-unit="99"]')
+ .evaluate((element) => element.getBoundingClientRect().width);
+ await page.getByRole("button", { name: control, exact: true }).click();
+ await expect
+ .poll(() =>
+ root
+ .locator('[data-reader-unit="99"]')
+ .evaluate((element) => element.getBoundingClientRect().width),
+ )
+ .not.toBe(beforeWidth);
+ await expect.poll(() => withinPage(root, 99)).toBeCloseTo(0.3, 2);
+ }
+
+ for (const width of [1200, 1600, 1440]) {
+ const beforeWidth = await root
+ .locator('[data-reader-unit="99"]')
+ .evaluate((element) => element.getBoundingClientRect().width);
+ await page.setViewportSize({ width, height: 900 });
+ await expect
+ .poll(() =>
+ root
+ .locator('[data-reader-unit="99"]')
+ .evaluate((element) => element.getBoundingClientRect().width),
+ )
+ .not.toBe(beforeWidth);
+ await expect.poll(() => withinPage(root, 99)).toBeCloseTo(0.3, 2);
+ }
+ await expect(
+ root.locator('[data-reader-unit="99"] .textLayer'),
+ ).toContainText("Resize regression page 99");
+});
diff --git a/web/tests/pdf-reading-resize.spec.tsx b/web/tests/pdf-reading-resize.spec.tsx
new file mode 100644
index 000000000..dbae6cd15
--- /dev/null
+++ b/web/tests/pdf-reading-resize.spec.tsx
@@ -0,0 +1,262 @@
+import { act, fireEvent, render, waitFor } from "@testing-library/react";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+ PdfDocumentView,
+ type PdfDocumentViewProps,
+} from "@/components/reading/PdfDocumentView";
+
+const pdf = vi.hoisted(() => ({ ratios: new Map<number, number>() }));
+
+// Keep both reader components real; only the PDF decoding/painting boundary is
+// replaced. Page heights still come from PdfPage's measured aspect ratios.
+vi.mock("@/lib/pdfjs-loader", () => ({
+ outputScale: () => 1,
+ pdfjsWasmUrl: () => "/pdfjs/wasm/",
+ loadPdfjs: async () => ({
+ getDocument: () => ({
+ destroy: async () => undefined,
+ promise: Promise.resolve({
+ getPage: async (locator: number) => ({
+ getViewport: ({ scale }: { scale: number }) => ({
+ width: 600 * scale,
+ height: 600 * (pdf.ratios.get(locator) ?? 1.414) * scale,
+ }),
+ render: () => ({
+ promise: Promise.resolve(),
+ cancel: () => undefined,
+ }),
+ getTextContent: async () => ({ items: [] }),
+ }),
+ }),
+ }),
+ TextLayer: class {
+ async render() {}
+ cancel() {}
+ },
+ }),
+}));
+
+vi.mock("react-i18next", () => {
+ const t = (key: string) => key;
+ return { useTranslation: () => ({ t }) };
+});
+
+const GAP = 16;
+const ROOT_TOP = 80;
+let containerWidth: number;
+let viewportHeight: number;
+let resizeCallbacks: Set<() => void>;
+
+function pageTop(page: HTMLElement): number {
+ let top = GAP;
+ for (
+ let sibling = page.previousElementSibling;
+ sibling;
+ sibling = sibling.previousElementSibling
+ ) {
+ top += Number.parseFloat((sibling as HTMLElement).style.height) + GAP;
+ }
+ return top;
+}
+
+function pageAt(root: HTMLElement, locator: number): HTMLElement {
+ const page = root.querySelector<HTMLElement>(
+ `[data-reader-unit="${locator}"]`,
+ );
+ if (!page) throw new Error(`Page ${locator} is missing`);
+ return page;
+}
+
+function positionWithin(root: HTMLElement, locator: number): number {
+ const page = pageAt(root, locator);
+ return (
+ (root.scrollTop - pageTop(page)) / Number.parseFloat(page.style.height)
+ );
+}
+
+async function resize(width: number): Promise<void> {
+ await act(async () => {
+ containerWidth = width;
+ for (const notify of resizeCallbacks) notify();
+ });
+}
+
+async function openReader(overrides: Partial<PdfDocumentViewProps> = {}) {
+ const onVisibleLocatorChange = vi.fn();
+ const props: PdfDocumentViewProps = {
+ materialId: "resize-pdf",
+ unitCount: 160,
+ annotations: [],
+ jump: null,
+ onSelection: vi.fn(),
+ onVisibleLocatorChange,
+ ...overrides,
+ };
+ const view = render(<PdfDocumentView {...props} />);
+ const root = view.container.querySelector<HTMLElement>(".dt-reader-scroll")!;
+ let scrollTop = 0;
+ // jsdom supplies no layout. Model the browser's stacking and scroll clamp
+ // from the real page elements/styles, without stubbing either component.
+ Object.defineProperty(root, "scrollTop", {
+ configurable: true,
+ get: () => scrollTop,
+ set: (value: number) => {
+ const pages = root.querySelectorAll<HTMLElement>("[data-reader-unit]");
+ const last = pages[pages.length - 1];
+ const contentHeight = last
+ ? pageTop(last) + Number.parseFloat(last.style.height) + GAP
+ : viewportHeight;
+ scrollTop = Math.max(0, Math.min(value, contentHeight - viewportHeight));
+ },
+ });
+ await waitFor(() => expect(pageAt(root, 1).style.width).toBe("600px"));
+ await act(async () => {});
+ return { ...view, root, props, onVisibleLocatorChange };
+}
+
+async function scrollTo(root: HTMLElement, locator: number, fraction = 0.3) {
+ const page = pageAt(root, locator);
+ root.scrollTop =
+ pageTop(page) + Number.parseFloat(page.style.height) * fraction;
+ await act(async () => {
+ fireEvent.scroll(root);
+ await new Promise<void>((resolve) =>
+ window.requestAnimationFrame(() => resolve()),
+ );
+ });
+}
+
+beforeEach(() => {
+ containerWidth = 648;
+ viewportHeight = 500;
+ resizeCallbacks = new Set();
+ pdf.ratios.clear();
+ vi.stubGlobal(
+ "ResizeObserver",
+ class {
+ constructor(private readonly callback: () => void) {}
+ observe() {
+ resizeCallbacks.add(this.callback);
+ }
+ disconnect() {
+ resizeCallbacks.delete(this.callback);
+ }
+ },
+ );
+ vi.spyOn(HTMLElement.prototype, "clientWidth", "get").mockImplementation(
+ function (this: HTMLElement) {
+ return this.classList.contains("dt-reader-scroll") ? containerWidth : 0;
+ },
+ );
+ vi.spyOn(HTMLElement.prototype, "getBoundingClientRect").mockImplementation(
+ function (this: HTMLElement) {
+ if (this.classList.contains("dt-reader-scroll")) {
+ return new DOMRect(120, ROOT_TOP, containerWidth, viewportHeight);
+ }
+ if (this.dataset.readerUnit) {
+ const root = this.closest<HTMLElement>(".dt-reader-scroll")!;
+ return new DOMRect(
+ 144,
+ ROOT_TOP + pageTop(this) - root.scrollTop,
+ Number.parseFloat(this.style.width),
+ Number.parseFloat(this.style.height),
+ );
+ }
+ return new DOMRect();
+ },
+ );
+});
+
+afterEach(() => vi.unstubAllGlobals());
+
+describe("PDF reading position during layout changes", () => {
+ it("keeps page 99 and its within-page position when the sidebar closes and reopens", async () => {
+ const { root, onVisibleLocatorChange } = await openReader();
+ await scrollTo(root, 99);
+ expect(onVisibleLocatorChange).toHaveBeenLastCalledWith(99);
+ onVisibleLocatorChange.mockClear();
+
+ await resize(1098);
+ expect(pageAt(root, 99).style.width).toBe("1050px");
+ expect(positionWithin(root, 99)).toBeCloseTo(0.3, 5);
+ await resize(648);
+ expect(positionWithin(root, 99)).toBeCloseTo(0.3, 5);
+ expect(
+ onVisibleLocatorChange.mock.calls.every(([locator]) => locator === 99),
+ ).toBe(true);
+ });
+
+ it("uses the latest user scroll as the anchor during successive window resizes", async () => {
+ const { root } = await openReader();
+ await scrollTo(root, 99, 0.4);
+ for (const width of [848, 1048, 748, 548, 648]) {
+ await resize(width);
+ expect(positionWithin(root, 99)).toBeCloseTo(0.4, 5);
+ }
+ await scrollTo(root, 120, 0.25);
+ await resize(998);
+ expect(positionWithin(root, 120)).toBeCloseTo(0.25, 5);
+ });
+
+ it("preserves the anchor across coalesced resize notifications and a cancelled resize", async () => {
+ const { root } = await openReader();
+ await scrollTo(root, 99);
+ await act(async () => {
+ containerWidth = 1098;
+ for (const notify of resizeCallbacks) notify();
+ containerWidth = 848;
+ for (const notify of resizeCallbacks) notify();
+ });
+ expect(positionWithin(root, 99)).toBeCloseTo(0.3, 5);
+ await act(async () => {
+ containerWidth = 1098;
+ for (const notify of resizeCallbacks) notify();
+ containerWidth = 848;
+ for (const notify of resizeCallbacks) notify();
+ });
+ await scrollTo(root, 120, 0.2);
+ await resize(648);
+ expect(positionWithin(root, 120)).toBeCloseTo(0.2, 5);
+ });
+
+ it("preserves page-top padding and handles mixed measured page heights", async () => {
+ pdf.ratios.set(2, 0.75);
+ pdf.ratios.set(99, 1.8);
+ const { root } = await openReader();
+ expect(root.scrollTop).toBe(0);
+ await resize(1098);
+ expect(root.scrollTop).toBe(0);
+ await scrollTo(root, 99);
+ await waitFor(() => expect(pageAt(root, 99).style.height).toBe("1890px"));
+ await scrollTo(root, 99, 0.2);
+ await resize(648);
+ expect(positionWithin(root, 99)).toBeCloseTo(0.2, 5);
+ });
+
+ it("allows an explicit page jump after a resize and anchors subsequent resizes there", async () => {
+ const view = await openReader();
+ await scrollTo(view.root, 99);
+ await resize(1098);
+ view.rerender(
+ <PdfDocumentView {...view.props} jump={{ locator: 120, nonce: 1 }} />,
+ );
+ await waitFor(() =>
+ expect(pageAt(view.root, 120).getBoundingClientRect().top).toBe(
+ ROOT_TOP + GAP,
+ ),
+ );
+ await resize(648);
+ expect(pageAt(view.root, 120).getBoundingClientRect().top).toBe(
+ ROOT_TOP + GAP,
+ );
+ });
+
+ it("clamps restoration at the document end", async () => {
+ const { root } = await openReader();
+ await scrollTo(root, 160, 0.6);
+ await resize(348);
+ const lastRect = pageAt(root, 160).getBoundingClientRect();
+ expect(lastRect.top).toBeLessThan(ROOT_TOP + viewportHeight);
+ expect(lastRect.bottom + GAP).toBeCloseTo(ROOT_TOP + viewportHeight, 5);
+ });
+});