feat(web): plein écran du lecteur (natif + fallback) et navigation flèches clavier durcie

apps/web/src/reader/readerRuntime.test.ts

@@ -15,6 +15,7 @@ import {
   zoomReaderSize
 } from "./readerLayout";
 import { classifyPdfCanvas, pdfCanvasHasVisibleContent, pdfCanvasVisible, pdfRenderScale } from "./pdfRender";
+import { isElementFullscreen, isReaderInteractiveTarget, readerArrowAction, shouldHandleReaderArrowKey, supportsElementFullscreen } from "./readerFullscreen";
 import { configurePdfWorker, pdfWorkerSrc } from "./pdfWorker";
 import { readerErrorMessage } from "./ReaderError";
 
@@ -163,4 +164,89 @@ describe("reader runtime helpers", () => {
     expect(nextReaderPage(8, 12)).toBe(9);
     expect(nextReaderPage(12, 12)).toBe(12);
   });
+
+  it("only maps unmodified horizontal reader arrow shortcuts", () => {
+    expect(readerArrowAction({ key: "ArrowLeft" })).toBe("previous");
+    expect(readerArrowAction({ key: "ArrowRight" })).toBe("next");
+    expect(readerArrowAction({ key: "ArrowUp" })).toBeNull();
+    expect(readerArrowAction({ key: "ArrowDown" })).toBeNull();
+    expect(readerArrowAction({ key: "ArrowRight", defaultPrevented: true })).toBeNull();
+    expect(readerArrowAction({ key: "ArrowRight", ctrlKey: true })).toBeNull();
+  });
+
+  it("detects fullscreen support and active fullscreen element", () => {
+    const fullscreenElement = { requestFullscreen: () => Promise.resolve() } as unknown as HTMLElement;
+    const regularElement = {} as HTMLElement;
+    const documentRef = { fullscreenElement } as unknown as Document;
+
+    expect(supportsElementFullscreen(fullscreenElement)).toBe(true);
+    expect(supportsElementFullscreen(regularElement)).toBe(false);
+    expect(isElementFullscreen(fullscreenElement, documentRef)).toBe(true);
+    expect(isElementFullscreen(regularElement, documentRef)).toBe(false);
+  });
+
+  it("keeps reader arrow shortcuts away from interactive or external targets", () => {
+    const originalElement = globalThis.Element;
+    const originalNode = globalThis.Node;
+    let fakeDocument: { body: FakeNode; documentElement: FakeNode };
+
+    class FakeNode {
+      get ownerDocument() {
+        return fakeDocument;
+      }
+
+      addEventListener() {
+        return undefined;
+      }
+
+      dispatchEvent() {
+        return true;
+      }
+
+      removeEventListener() {
+        return undefined;
+      }
+    }
+    class FakeElement extends FakeNode {
+      constructor(
+        private readonly interactive: boolean,
+        private readonly children: FakeNode[] = []
+      ) {
+        super();
+      }
+
+      closest() {
+        return this.interactive ? this : null;
+      }
+
+      contains(target: EventTarget | null) {
+        return (target as unknown) === this || this.children.includes(target as unknown as FakeNode);
+      }
+    }
+    fakeDocument = {
+      body: new FakeNode(),
+      documentElement: new FakeNode()
+    };
+
+    try {
+      Object.defineProperty(globalThis, "Node", { configurable: true, value: FakeNode });
+      Object.defineProperty(globalThis, "Element", { configurable: true, value: FakeElement });
+
+      const readerChild = new FakeElement(false);
+      const readerElement = new FakeElement(false, [readerChild]) as unknown as HTMLElement;
+      const externalElement = new FakeElement(false);
+      const interactiveElement = new FakeElement(true);
+      const keyEvent = (event: object) => event as unknown as KeyboardEvent;
+
+      expect(isReaderInteractiveTarget(interactiveElement as unknown as EventTarget)).toBe(true);
+      expect(shouldHandleReaderArrowKey(keyEvent({ key: "ArrowRight", target: interactiveElement }), readerElement)).toBe(false);
+      expect(shouldHandleReaderArrowKey(keyEvent({ key: "ArrowRight", target: externalElement }), readerElement)).toBe(false);
+      expect(shouldHandleReaderArrowKey(keyEvent({ key: "ArrowRight", target: readerChild }), readerElement)).toBe(true);
+      expect(shouldHandleReaderArrowKey(keyEvent({ key: "ArrowLeft", target: fakeDocument.body }), readerElement)).toBe(true);
+      expect(shouldHandleReaderArrowKey(keyEvent({ key: "ArrowRight", ctrlKey: true, target: readerChild }), readerElement)).toBe(false);
+    } finally {
+      Object.defineProperty(globalThis, "Node", { configurable: true, value: originalNode });
+      Object.defineProperty(globalThis, "Element", { configurable: true, value: originalElement });
+    }
+  });
 });