@file-viewer/renderer-pdf 2.2.4 → 2.2.6

package/dist/pdf.js

@@ -5,6 +5,8 @@ import { DEFAULT_FILE_VIEWER_PDF_WORKER_PATH, resolveFileViewerPdfAssetUrls, res
 import { pdfViewerStyle } from './pdfStyles.js';
 import { collectMalformedIdentityFontNames, createPdfCjkFontFallbackManager, detectMalformedIdentityCjkFontFamilies, } from './pdfFontFallback.js';
 import { PDF_FIT_HORIZONTAL_PADDING, PDF_PAGE_BORDER_WIDTH, resolvePdfFitViewportSize, } from './pdfFit.js';
+import { createPdfBoundingBoxController, } from './pdfBboxController.js';
+import { clampPdfScale, normalizePdfRotation, resolvePdfViewStateUpdate, } from './pdfViewState.js';
 import { capturePdfJsWorkerGlobal, scopePdfJsWorkerMessageHandler, } from './pdfWorkerGlobal.js';
 import { readPdfJsWorkerVersion } from './pdfWorkerVersion.js';
 export const DEFAULT_FILE_VIEWER_PDF_WORKER_URL = DEFAULT_FILE_VIEWER_PDF_WORKER_PATH;
@@ -38,6 +40,8 @@ const createStyle = (documentRef) => {
 .pdf-page-thumb--thumbnail{width:46px;height:60px;overflow:hidden;background:#fff}
 .pdf-page-thumb--thumbnail img{display:block;width:100%;height:100%;object-fit:contain}
 .pdf-page-thumb--thumbnail span{display:inline-flex;align-items:center;justify-content:center;width:100%;height:100%}
+.pdf-bbox-layer{position:absolute;inset:0;z-index:20;pointer-events:none;overflow:hidden}
+.pdf-bbox-highlight{position:absolute;box-sizing:border-box;border:2px solid var(--pdf-bbox-color,#f97316);border-radius:3px;background:rgba(249,115,22,.16);background:color-mix(in srgb,var(--pdf-bbox-color,#f97316) 18%,transparent);box-shadow:0 0 0 1px rgba(255,255,255,.8),0 2px 8px rgba(15,23,42,.16)}
 [data-viewer-theme='dark'] .pdf-shell{background:#101820;color:#e5eef8}
 [data-viewer-theme='dark'] .pdf-toolbar,[data-viewer-theme='dark'] .pdf-nav-pane,[data-viewer-theme='dark'] .pdf-nav-head,[data-viewer-theme='dark'] .pdf-nav-tabs{border-color:rgba(148,163,184,.18);background:#111827;box-shadow:none}
 [data-viewer-theme='dark'] .pdf-toolbar-group,[data-viewer-theme='dark'] .pdf-page-button,[data-viewer-theme='dark'] .pdf-outline-empty,[data-viewer-theme='dark'] .pdf-state{border-color:rgba(148,163,184,.18);background:#151f2b;color:#cbd5e1}
@@ -86,11 +90,8 @@ const createButton = (documentRef, className, title, label) => {
     }
     return button;
 };
-const normalizeRotation = (rotation) => {
-    const normalized = ((Math.round(rotation / 90) * 90) % 360 + 360) % 360;
-    return (normalized === 90 || normalized === 180 || normalized === 270 ? normalized : 0);
-};
-const clampScale = (scale) => Number(Math.min(MAX_SCALE, Math.max(MIN_SCALE, scale)).toFixed(2));
+const normalizeRotation = normalizePdfRotation;
+const clampScale = (scale) => clampPdfScale(scale, MIN_SCALE, MAX_SCALE);
 const createPdfSearchState = (query = '') => ({
     query,
     total: 0,
@@ -340,6 +341,8 @@ export default async function renderPdf(buffer, target, context) {
     let suppressScrollEventUntil = 0;
     let userScrollIntentUntil = 0;
     let scrollStateFrame = 0;
+    let rotationOperationVersion = 0;
+    let pendingUserRotationAnchor = null;
     let pdfSearchState = createPdfSearchState();
     let pdfMatchesCount = { current: 0, total: 0 };
     let pdfSearchOptions;
@@ -456,9 +459,22 @@ export default async function renderPdf(buffer, target, context) {
         visit(outlineItems, 0);
         return result;
     };
+    const navScrollTopByMode = {
+        pages: 0,
+        outline: 0,
+    };
     const renderNavList = () => {
+        if (navList.classList.contains('pdf-page-list')) {
+            navScrollTopByMode.pages = navList.scrollTop;
+        }
+        else if (navList.classList.contains('pdf-outline-list')) {
+            navScrollTopByMode.outline = navList.scrollTop;
+        }
         navList.replaceChildren();
         navList.className = navMode === 'pages' ? 'pdf-page-list' : 'pdf-outline-list';
+        const restoreNavScrollTop = () => {
+            navList.scrollTop = navScrollTopByMode[navMode];
+        };
         if (navMode === 'pages') {
             thumbnailObserver === null || thumbnailObserver === void 0 ? void 0 : thumbnailObserver.disconnect();
             for (let page = 1; page <= pageCount; page += 1) {
@@ -478,6 +494,7 @@ export default async function renderPdf(buffer, target, context) {
                 button.addEventListener('click', () => goToPage(page, 'page-click', 'user'));
                 navList.append(button);
             }
+            restoreNavScrollTop();
             return;
         }
         const entries = flattenedOutlineItems();
@@ -500,6 +517,7 @@ export default async function renderPdf(buffer, target, context) {
         if (!entries.length) {
             navList.append(createElement(documentRef, 'div', 'pdf-outline-empty', t('pdf.nav.outlineEmpty')));
         }
+        restoreNavScrollTop();
     };
     const paintPdfThumbnail = (pageNumber, thumb) => {
         const imageUrl = pdfThumbnails.get(pageNumber);
@@ -957,6 +975,7 @@ export default async function renderPdf(buffer, target, context) {
     };
     const getPdfViewState = () => {
         const zoom = getPdfZoomState();
+        const bbox = pdfBoundingBoxController.getStateValue();
         return {
             renderer: 'pdf',
             page: currentPage,
@@ -969,6 +988,7 @@ export default async function renderPdf(buffer, target, context) {
                 visible: navigationEnabled ? navVisible : false,
                 mode: navMode,
             },
+            extra: bbox ? { bbox } : undefined,
         };
     };
     const emitViewStateChange = (action, source = 'viewer') => {
@@ -993,6 +1013,20 @@ export default async function renderPdf(buffer, target, context) {
     const suppressProgrammaticScrollEvents = () => {
         suppressScrollEventUntil = Math.max(suppressScrollEventUntil, Date.now() + 180);
     };
+    const pdfBoundingBoxController = createPdfBoundingBoxController({
+        documentRef,
+        targetWindow,
+        viewerRoot: pdfViewerRoot,
+        scrollContainer: container,
+        initial: options === null || options === void 0 ? void 0 : options.bbox,
+        getDocument: () => pdfContext.document,
+        getPageCount: () => pageCount,
+        getCurrentPage: () => currentPage,
+        getRotation: () => currentRotation,
+        goToPage: (page, source) => goToPage(page, 'bbox-focus', source, false),
+        suppressProgrammaticScrollEvents,
+        waitForPaint,
+    });
     const markFitInteraction = (source) => {
         if (source !== 'user' && source !== 'api') {
             return;
@@ -1003,7 +1037,83 @@ export default async function renderPdf(buffer, target, context) {
         autoFitWidth = false;
         activeFitRequest = null;
     };
+    const getPdfPageElement = (pageNumber) => {
+        var _a;
+        const pageView = (_a = pdfContext.viewer) === null || _a === void 0 ? void 0 : _a.getPageView(pageNumber - 1);
+        return (pageView === null || pageView === void 0 ? void 0 : pageView.div) ||
+            pdfViewerRoot.querySelector(`.page[data-page-number="${pageNumber}"]`);
+    };
+    const captureCurrentPdfPageAnchor = () => {
+        const pageElement = getPdfPageElement(currentPage);
+        if (!pageElement) {
+            return null;
+        }
+        const containerRect = container.getBoundingClientRect();
+        const pageRect = pageElement.getBoundingClientRect();
+        const pageHeight = pageElement.offsetHeight || pageRect.height;
+        if (pageHeight <= 0) {
+            return null;
+        }
+        const pageTop = pageRect.top - containerRect.top + container.scrollTop;
+        const inPageRatio = (container.scrollTop - pageTop) / pageHeight;
+        return {
+            page: currentPage,
+            inPageRatio: Math.max(0, Math.min(1, inPageRatio)),
+        };
+    };
+    const cancelPendingUserRotationRestore = () => {
+        if (!pendingUserRotationAnchor) {
+            return;
+        }
+        pendingUserRotationAnchor = null;
+        rotationOperationVersion += 1;
+    };
+    const restoreUserRotationAnchor = (anchor, operationVersion) => {
+        const apply = () => {
+            if (destroyed ||
+                operationVersion !== rotationOperationVersion ||
+                pendingUserRotationAnchor !== anchor) {
+                return false;
+            }
+            const pageElement = getPdfPageElement(anchor.page);
+            if (!pageElement) {
+                return false;
+            }
+            const containerRect = container.getBoundingClientRect();
+            const pageRect = pageElement.getBoundingClientRect();
+            const pageHeight = pageElement.offsetHeight || pageRect.height;
+            if (pageHeight <= 0) {
+                return false;
+            }
+            const pageTop = pageRect.top - containerRect.top + container.scrollTop;
+            const maxTop = Math.max(0, container.scrollHeight - container.clientHeight);
+            suppressProgrammaticScrollEvents();
+            container.scrollTop = Math.max(0, Math.min(maxTop, pageTop + anchor.inPageRatio * pageHeight));
+            currentPage = anchor.page;
+            syncUi();
+            return true;
+        };
+        apply();
+        void waitForPaint(targetWindow)
+            .then(() => {
+            apply();
+            return waitForPaint(targetWindow);
+        })
+            .then(apply);
+        targetWindow.requestAnimationFrame(() => {
+            apply();
+            targetWindow.requestAnimationFrame(apply);
+        });
+        targetWindow.setTimeout(() => {
+            apply();
+            if (operationVersion === rotationOperationVersion &&
+                pendingUserRotationAnchor === anchor) {
+                pendingUserRotationAnchor = null;
+            }
+        }, 180);
+    };
     const recordUserScrollIntent = () => {
+        cancelPendingUserRotationRestore();
         userScrollIntentUntil = Date.now() + 750;
         suppressScrollEventUntil = 0;
         markFitInteraction('user');
@@ -1027,7 +1137,7 @@ export default async function renderPdf(buffer, target, context) {
         }
     };
     const applyPdfViewState = async (state, applyOptions = {}) => {
-        var _a, _b;
+        var _a;
         if (!pdfContext.viewer || loadStatus !== 'ready') {
             pendingInitialViewState = state;
             return getPdfViewState();
@@ -1039,29 +1149,46 @@ export default async function renderPdf(buffer, target, context) {
         const applyVersion = ++viewStateApplyVersion;
         activeViewStateApplyVersion = applyVersion;
         suppressProgrammaticScrollEvents();
-        const nextRotation = Number(state.rotation);
-        const nextScale = Number((_a = state.scale) !== null && _a !== void 0 ? _a : (_b = state.zoom) === null || _b === void 0 ? void 0 : _b.scale);
-        const nextPage = Number(state.page);
+        const update = resolvePdfViewStateUpdate(state, {
+            rotation: currentRotation,
+            scale: currentScale,
+            page: currentPage,
+            pageCount,
+        }, {
+            minScale: MIN_SCALE,
+            maxScale: MAX_SCALE,
+        });
+        const hasBboxUpdate = !!state.extra && Object.prototype.hasOwnProperty.call(state.extra, 'bbox');
+        const bboxUpdate = hasBboxUpdate ? (_a = state.extra) === null || _a === void 0 ? void 0 : _a.bbox : undefined;
         try {
             if (state.navigation) {
+                let navigationChanged = false;
                 if (navigationEnabled && typeof state.navigation.visible === 'boolean') {
+                    navigationChanged = navVisible !== state.navigation.visible;
                     navVisible = state.navigation.visible;
                 }
                 if (state.navigation.mode === 'pages' || state.navigation.mode === 'outline') {
+                    navigationChanged = navigationChanged || navMode !== state.navigation.mode;
                     navMode = state.navigation.mode;
                 }
-                syncUi();
+                if (navigationChanged) {
+                    syncUi();
+                }
             }
-            if (Number.isFinite(nextRotation)) {
-                applyRotation(nextRotation, 'rotation-change', source, false);
+            if (update.rotation !== undefined) {
+                applyRotation(update.rotation, 'rotation-change', source, false);
             }
-            if (Number.isFinite(nextScale)) {
+            if (update.scale !== undefined) {
                 autoFitWidth = false;
-                setScale(nextScale, 'zoom-change', source, false);
+                setScale(update.scale, 'zoom-change', source, false);
             }
-            if (Number.isFinite(nextPage)) {
-                goToPage(nextPage, 'page-change', source, false);
+            if (update.page !== undefined) {
+                goToPage(update.page, 'page-change', source, false);
             }
+            // A remote presenter can send scroll snapshots faster than one animation
+            // frame. Apply the latest offset before yielding so superseded promises
+            // cannot starve the projected screen until the presenter stops scrolling.
+            restoreScrollState(state.scroll, false);
             await waitForPaint(targetWindow);
             if (applyVersion !== viewStateApplyVersion) {
                 return getPdfViewState();
@@ -1072,6 +1199,9 @@ export default async function renderPdf(buffer, target, context) {
                 return getPdfViewState();
             }
             restoreScrollState(state.scroll, false);
+            if (hasBboxUpdate) {
+                await pdfBoundingBoxController.set(bboxUpdate, { focus: true, source });
+            }
             syncUi();
             if (notify && applyVersion === viewStateApplyVersion) {
                 emitViewStateChange(action, source);
@@ -1276,6 +1406,18 @@ export default async function renderPdf(buffer, target, context) {
     const applyRotation = (rotation, action = 'rotation-change', source = 'viewer', notifyViewState = true) => {
         markFitInteraction(source);
         const normalized = normalizeRotation(rotation);
+        if (source === 'user' && pdfContext.viewer) {
+            pendingUserRotationAnchor || (pendingUserRotationAnchor = captureCurrentPdfPageAnchor());
+        }
+        else {
+            cancelPendingUserRotationRestore();
+        }
+        const pageAnchor = source === 'user' ? pendingUserRotationAnchor : null;
+        const operationVersion = ++rotationOperationVersion;
+        if (pageAnchor) {
+            suppressProgrammaticScrollEvents();
+            currentPage = pageAnchor.page;
+        }
         currentRotation = normalized;
         pdfThumbnails.clear();
         pendingPdfThumbnails.clear();
@@ -1286,18 +1428,36 @@ export default async function renderPdf(buffer, target, context) {
         pdfContext.viewer.pagesRotation = normalized;
         void waitForPaint(targetWindow).then(() => {
             var _a;
+            if (operationVersion !== rotationOperationVersion) {
+                return;
+            }
+            const refocusBoundingBoxes = () => {
+                if (pdfBoundingBoxController.hasBoxes()) {
+                    void waitForPaint(targetWindow)
+                        .then(() => waitForPaint(targetWindow))
+                        .then(() => pdfBoundingBoxController.render({ focus: true, source }));
+                }
+            };
             if (reapplyFitAfterLayout(source, notifyViewState)) {
+                if (pageAnchor) {
+                    restoreUserRotationAnchor(pageAnchor, operationVersion);
+                }
                 if (notifyViewState) {
                     emitViewStateChange(action, source);
                 }
+                refocusBoundingBoxes();
                 return;
             }
             (_a = pdfContext.viewer) === null || _a === void 0 ? void 0 : _a.update();
             scheduleLegacyPageDimensionPatch();
             syncUi();
+            if (pageAnchor) {
+                restoreUserRotationAnchor(pageAnchor, operationVersion);
+            }
             if (notifyViewState) {
                 emitViewStateChange(action, source);
             }
+            refocusBoundingBoxes();
         });
     };
     const runWithStableHorizontalScroll = (action) => {
@@ -1312,6 +1472,9 @@ export default async function renderPdf(buffer, target, context) {
         if (!pdfContext.viewer || !pageCount) {
             return;
         }
+        if (source === 'user') {
+            cancelPendingUserRotationRestore();
+        }
         markFitInteraction(source);
         const nextPage = Math.min(pageCount, Math.max(1, pageNumber));
         runWithStableHorizontalScroll(() => {
@@ -1550,8 +1713,19 @@ export default async function renderPdf(buffer, target, context) {
                 if (pdfContext.search) {
                     eventBus.dispatch('find', { type: '', query: pdfContext.search });
                 }
+                if (pdfBoundingBoxController.hasBoxes()) {
+                    void waitForPaint(targetWindow).then(() => pdfBoundingBoxController.render({
+                        focus: true,
+                        source: 'initial',
+                    }));
+                }
             });
             eventBus.on('pagechanging', ({ pageNumber }) => {
+                if (pendingUserRotationAnchor && pageNumber !== pendingUserRotationAnchor.page) {
+                    currentPage = pendingUserRotationAnchor.page;
+                    syncUi();
+                    return;
+                }
                 const previousPage = currentPage;
                 currentPage = pageNumber;
                 syncUi();
@@ -1571,6 +1745,9 @@ export default async function renderPdf(buffer, target, context) {
             });
             eventBus.on('pagerendered', ({ pageNumber }) => {
                 scheduleLegacyPageDimensionPatch();
+                if (pdfBoundingBoxController.hasBoxes()) {
+                    void pdfBoundingBoxController.render({ pageNumber, source: 'viewer' });
+                }
                 if (!pdfCjkFontFallbackManager ||
                     pdfCjkFontFallbackRenderHandledPages.has(pageNumber)) {
                     return;
@@ -1839,6 +2016,7 @@ export default async function renderPdf(buffer, target, context) {
             unregisterFileViewerSearchProvider(root);
             unregisterFileViewerZoomProvider(root);
             unregisterFileViewerViewStateProvider(root);
+            pdfBoundingBoxController.destroy();
             outlineItems = [];
             (_a = context === null || context === void 0 ? void 0 : context.registerExportAdapter) === null || _a === void 0 ? void 0 : _a.call(context, null);
             (_b = context === null || context === void 0 ? void 0 : context.registerThumbnailAdapter) === null || _b === void 0 ? void 0 : _b.call(context, null);

package/dist/pdfBbox.d.ts

@@ -0,0 +1,21 @@
+import type { FileViewerPdfBoundingBox } from '@file-viewer/core';
+export interface NormalizedPdfBoundingBox {
+    id?: string;
+    page: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    color?: string;
+    label?: string;
+}
+export interface PdfPageBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export declare const normalizePdfBoundingBoxInput: (input: unknown) => FileViewerPdfBoundingBox[];
+export declare const normalizePdfBoundingBox: (input: FileViewerPdfBoundingBox, pageBox: PdfPageBox, fallbackPage?: number) => NormalizedPdfBoundingBox | null;
+export declare const rotateNormalizedPdfBoundingBox: (box: NormalizedPdfBoundingBox, rotation: number) => NormalizedPdfBoundingBox;
+export declare const serializePdfBoundingBoxes: (input: unknown) => string;

package/dist/pdfBbox.js

@@ -0,0 +1,93 @@
+const clamp = (value, min = 0, max = 1) => Math.min(max, Math.max(min, value));
+const finitePositive = (value) => Number.isFinite(value) && Number(value) > 0;
+export const normalizePdfBoundingBoxInput = (input) => {
+    const values = input ? (Array.isArray(input) ? input : [input]) : [];
+    return values.filter(value => !!value && typeof value === 'object');
+};
+export const normalizePdfBoundingBox = (input, pageBox, fallbackPage = 1) => {
+    if (!Number.isFinite(input.x) ||
+        !Number.isFinite(input.y) ||
+        !finitePositive(input.width) ||
+        !finitePositive(input.height) ||
+        !finitePositive(pageBox.width) ||
+        !finitePositive(pageBox.height)) {
+        return null;
+    }
+    const unit = input.unit || 'pdf-point';
+    let x = input.x;
+    let y = input.y;
+    let width = input.width;
+    let height = input.height;
+    if (unit === 'percent') {
+        x /= 100;
+        y /= 100;
+        width /= 100;
+        height /= 100;
+    }
+    else if (unit === 'pixel') {
+        if (!finitePositive(input.sourceWidth) || !finitePositive(input.sourceHeight)) {
+            return null;
+        }
+        x /= Number(input.sourceWidth);
+        y /= Number(input.sourceHeight);
+        width /= Number(input.sourceWidth);
+        height /= Number(input.sourceHeight);
+    }
+    else if (unit === 'pdf-point') {
+        x = (x - pageBox.x) / pageBox.width;
+        y = (y - pageBox.y) / pageBox.height;
+        width /= pageBox.width;
+        height /= pageBox.height;
+    }
+    const origin = input.origin || (unit === 'pdf-point' ? 'bottom-left' : 'top-left');
+    if (origin === 'bottom-left') {
+        y = 1 - y - height;
+    }
+    const left = clamp(x);
+    const top = clamp(y);
+    const right = clamp(x + width);
+    const bottom = clamp(y + height);
+    if (right <= left || bottom <= top) {
+        return null;
+    }
+    return {
+        id: input.id,
+        page: Math.max(1, Math.round(Number(input.page) || fallbackPage || 1)),
+        x: left,
+        y: top,
+        width: right - left,
+        height: bottom - top,
+        color: input.color,
+        label: input.label,
+    };
+};
+export const rotateNormalizedPdfBoundingBox = (box, rotation) => {
+    const normalizedRotation = ((Math.round(rotation / 90) * 90) % 360 + 360) % 360;
+    if (normalizedRotation === 90) {
+        return {
+            ...box,
+            x: 1 - box.y - box.height,
+            y: box.x,
+            width: box.height,
+            height: box.width,
+        };
+    }
+    if (normalizedRotation === 180) {
+        return {
+            ...box,
+            x: 1 - box.x - box.width,
+            y: 1 - box.y - box.height,
+        };
+    }
+    if (normalizedRotation === 270) {
+        return {
+            ...box,
+            x: box.y,
+            y: 1 - box.x - box.width,
+            width: box.height,
+            height: box.width,
+        };
+    }
+    return { ...box };
+};
+export const serializePdfBoundingBoxes = (input) => JSON.stringify(normalizePdfBoundingBoxInput(input));

package/dist/pdfBboxController.d.ts

@@ -0,0 +1,42 @@
+import type { FileViewerPdfBoundingBox, FileViewerViewStateChangeSource } from '@file-viewer/core';
+interface PdfBoundingBoxPage {
+    view?: number[];
+    getViewport: (options: {
+        scale: number;
+        rotation: number;
+    }) => {
+        width: number;
+        height: number;
+    };
+}
+interface PdfBoundingBoxDocument {
+    getPage: (pageNumber: number) => Promise<PdfBoundingBoxPage>;
+}
+export interface CreatePdfBoundingBoxControllerOptions {
+    documentRef: Document;
+    targetWindow: Window;
+    viewerRoot: HTMLElement;
+    scrollContainer: HTMLElement;
+    initial?: FileViewerPdfBoundingBox | readonly FileViewerPdfBoundingBox[];
+    getDocument: () => PdfBoundingBoxDocument | null;
+    getPageCount: () => number;
+    getCurrentPage: () => number;
+    getRotation: () => number;
+    goToPage: (page: number, source: FileViewerViewStateChangeSource) => void;
+    suppressProgrammaticScrollEvents: () => void;
+    waitForPaint: (view?: Window | null) => Promise<void>;
+}
+export interface PdfBoundingBoxRenderOptions {
+    focus?: boolean;
+    pageNumber?: number;
+    source?: FileViewerViewStateChangeSource;
+}
+export interface PdfBoundingBoxController {
+    hasBoxes(): boolean;
+    getStateValue(): FileViewerPdfBoundingBox | FileViewerPdfBoundingBox[] | null;
+    set(input: unknown, options?: Pick<PdfBoundingBoxRenderOptions, 'focus' | 'source'>): Promise<boolean>;
+    render(options?: PdfBoundingBoxRenderOptions): Promise<void>;
+    destroy(): void;
+}
+export declare const createPdfBoundingBoxController: ({ documentRef, targetWindow, viewerRoot, scrollContainer, initial, getDocument, getPageCount, getCurrentPage, getRotation, goToPage, suppressProgrammaticScrollEvents, waitForPaint, }: CreatePdfBoundingBoxControllerOptions) => PdfBoundingBoxController;
+export {};

package/dist/pdfBboxController.js

@@ -0,0 +1,159 @@
+import { normalizePdfBoundingBox, normalizePdfBoundingBoxInput, rotateNormalizedPdfBoundingBox, serializePdfBoundingBoxes, } from './pdfBbox.js';
+export const createPdfBoundingBoxController = ({ documentRef, targetWindow, viewerRoot, scrollContainer, initial, getDocument, getPageCount, getCurrentPage, getRotation, goToPage, suppressProgrammaticScrollEvents, waitForPaint, }) => {
+    let renderVersion = 0;
+    let destroyed = false;
+    let active = normalizePdfBoundingBoxInput(initial);
+    let fingerprint = serializePdfBoundingBoxes(active);
+    const removeLayers = (pageNumber) => {
+        const selector = pageNumber
+            ? `.page[data-page-number="${pageNumber}"] > .pdf-bbox-layer`
+            : '.pdf-bbox-layer';
+        viewerRoot.querySelectorAll(selector).forEach(layer => layer.remove());
+    };
+    const getPageBox = async (pageNumber) => {
+        const document = getDocument();
+        if (!document) {
+            return null;
+        }
+        const page = await document.getPage(pageNumber);
+        const view = page.view;
+        if (Array.isArray(view) && view.length >= 4) {
+            return {
+                x: Number(view[0]) || 0,
+                y: Number(view[1]) || 0,
+                width: Math.abs(Number(view[2]) - Number(view[0])),
+                height: Math.abs(Number(view[3]) - Number(view[1])),
+            };
+        }
+        const viewport = page.getViewport({ scale: 1, rotation: 0 });
+        return { x: 0, y: 0, width: viewport.width, height: viewport.height };
+    };
+    const focusNodes = (pageNode, nodes) => {
+        if (!nodes.length) {
+            return;
+        }
+        const pageRect = pageNode.getBoundingClientRect();
+        const containerRect = scrollContainer.getBoundingClientRect();
+        const nodeRects = nodes.map(node => node.getBoundingClientRect());
+        const left = Math.min(...nodeRects.map(rect => rect.left));
+        const top = Math.min(...nodeRects.map(rect => rect.top));
+        const right = Math.max(...nodeRects.map(rect => rect.right));
+        const bottom = Math.max(...nodeRects.map(rect => rect.bottom));
+        suppressProgrammaticScrollEvents();
+        scrollContainer.scrollTop = Math.max(0, scrollContainer.scrollTop + (top + bottom) / 2 - (containerRect.top + containerRect.bottom) / 2);
+        if (pageRect.width > containerRect.width) {
+            scrollContainer.scrollLeft = Math.max(0, scrollContainer.scrollLeft + (left + right) / 2 - (containerRect.left + containerRect.right) / 2);
+        }
+    };
+    const render = async ({ focus = false, pageNumber, source = 'api', } = {}) => {
+        var _a;
+        const currentVersion = pageNumber ? renderVersion : ++renderVersion;
+        removeLayers(pageNumber);
+        const document = getDocument();
+        if (!active.length || !document || destroyed) {
+            return;
+        }
+        const fallbackPage = getCurrentPage() || 1;
+        const pageCount = getPageCount();
+        const grouped = new Map();
+        active.forEach(box => {
+            const page = Math.min(pageCount || Number.MAX_SAFE_INTEGER, Math.max(1, Math.round(Number(box.page) || fallbackPage)));
+            if (pageNumber && page !== pageNumber) {
+                return;
+            }
+            const boxes = grouped.get(page) || [];
+            boxes.push(box);
+            grouped.set(page, boxes);
+        });
+        const focusPage = Math.min(...grouped.keys());
+        if (focus && Number.isFinite(focusPage)) {
+            goToPage(focusPage, source);
+            await waitForPaint(targetWindow);
+        }
+        for (const [page, boxes] of grouped) {
+            if (currentVersion !== renderVersion || destroyed) {
+                return;
+            }
+            const pageNode = viewerRoot.querySelector(`.page[data-page-number="${page}"]`);
+            const pageBox = await getPageBox(page);
+            if (!pageNode || !pageBox || currentVersion !== renderVersion || destroyed) {
+                continue;
+            }
+            (_a = pageNode.querySelector(':scope > .pdf-bbox-layer')) === null || _a === void 0 ? void 0 : _a.remove();
+            const layer = documentRef.createElement('div');
+            layer.className = 'pdf-bbox-layer';
+            layer.dataset.pdfBboxPage = String(page);
+            const nodes = [];
+            boxes.forEach((box, index) => {
+                const normalized = normalizePdfBoundingBox(box, pageBox, fallbackPage);
+                if (!normalized) {
+                    return;
+                }
+                const rotated = rotateNormalizedPdfBoundingBox(normalized, getRotation());
+                const node = documentRef.createElement('div');
+                node.className = 'pdf-bbox-highlight';
+                node.dataset.pdfBboxId = box.id || `${page}-${index}`;
+                node.style.left = `${rotated.x * 100}%`;
+                node.style.top = `${rotated.y * 100}%`;
+                node.style.width = `${rotated.width * 100}%`;
+                node.style.height = `${rotated.height * 100}%`;
+                if (box.color) {
+                    node.style.setProperty('--pdf-bbox-color', box.color);
+                }
+                if (box.label) {
+                    node.setAttribute('role', 'note');
+                    node.setAttribute('aria-label', box.label);
+                }
+                else {
+                    node.setAttribute('aria-hidden', 'true');
+                }
+                layer.append(node);
+                nodes.push(node);
+            });
+            if (!nodes.length) {
+                continue;
+            }
+            pageNode.append(layer);
+            if (focus && page === focusPage) {
+                await waitForPaint(targetWindow);
+                focusNodes(pageNode, nodes);
+                // PDF.js can settle dimensions one frame after fit or rotation.
+                await waitForPaint(targetWindow);
+                focusNodes(pageNode, nodes);
+            }
+        }
+    };
+    return {
+        hasBoxes: () => active.length > 0,
+        getStateValue: () => {
+            if (!active.length) {
+                return null;
+            }
+            return active.length === 1
+                ? { ...active[0] }
+                : active.map(box => ({ ...box }));
+        },
+        async set(input, options = {}) {
+            var _a;
+            const next = normalizePdfBoundingBoxInput(input);
+            const nextFingerprint = serializePdfBoundingBoxes(next);
+            if (nextFingerprint === fingerprint) {
+                return false;
+            }
+            active = next;
+            fingerprint = nextFingerprint;
+            await render({
+                focus: (_a = options.focus) !== null && _a !== void 0 ? _a : true,
+                source: options.source,
+            });
+            return true;
+        },
+        render,
+        destroy() {
+            destroyed = true;
+            renderVersion += 1;
+            removeLayers();
+            active = [];
+        },
+    };
+};

package/dist/pdfViewState.d.ts

@@ -0,0 +1,17 @@
+import type { FileViewerViewState } from '@file-viewer/core';
+export type PdfRotation = 0 | 90 | 180 | 270;
+export declare const normalizePdfRotation: (rotation: number) => PdfRotation;
+export declare const clampPdfScale: (scale: number, minScale: number, maxScale: number) => number;
+export declare const resolvePdfViewStateUpdate: (state: FileViewerViewState, current: {
+    rotation: number;
+    scale: number;
+    page: number;
+    pageCount: number;
+}, limits: {
+    minScale: number;
+    maxScale: number;
+}) => {
+    rotation: number | undefined;
+    scale: number | undefined;
+    page: number | undefined;
+};

package/dist/pdfViewState.js

@@ -0,0 +1,27 @@
+export const normalizePdfRotation = (rotation) => {
+    const normalized = (((Math.round(rotation / 90) * 90) % 360) + 360) % 360;
+    return (normalized === 90 || normalized === 180 || normalized === 270 ? normalized : 0);
+};
+export const clampPdfScale = (scale, minScale, maxScale) => {
+    return Number(Math.min(maxScale, Math.max(minScale, scale)).toFixed(2));
+};
+export const resolvePdfViewStateUpdate = (state, current, limits) => {
+    var _a, _b;
+    const requestedRotation = Number(state.rotation);
+    const requestedScale = Number((_a = state.scale) !== null && _a !== void 0 ? _a : (_b = state.zoom) === null || _b === void 0 ? void 0 : _b.scale);
+    const requestedPage = Number(state.page);
+    const rotation = Number.isFinite(requestedRotation)
+        ? normalizePdfRotation(requestedRotation)
+        : current.rotation;
+    const scale = Number.isFinite(requestedScale)
+        ? clampPdfScale(requestedScale, limits.minScale, limits.maxScale)
+        : current.scale;
+    const page = Number.isFinite(requestedPage)
+        ? Math.min(current.pageCount, Math.max(1, Math.round(requestedPage)))
+        : current.page;
+    return {
+        rotation: rotation !== current.rotation ? rotation : undefined,
+        scale: Math.abs(scale - current.scale) > 0.001 ? scale : undefined,
+        page: page !== current.page ? page : undefined
+    };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@file-viewer/renderer-pdf",
-  "version": "2.2.4",
+  "version": "2.2.6",
   "private": false,
   "type": "module",
   "description": "Standalone PDF renderer plugin for File Viewer powered by PDF.js.",
@@ -54,7 +54,7 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@file-viewer/core": "2.2.4",
+    "@file-viewer/core": "2.2.6",
     "@fontsource-variable/noto-sans-sc": "5.2.10",
     "pdf-lib": "1.17.1",
     "pdfjs-dist": "5.4.624"