4e:I[707087,["/_next/static/immutable/chunks/3arlv5bvukoo2.js","/_next/static/immutable/chunks/39v64hmfyo-sr.js","/_next/static/immutable/chunks/2nvof3-29tvc3.js","/_next/static/immutable/chunks/3tjobt77z_9dj.js","/_next/static/immutable/chunks/04j_o97cgxn2x.js","/_next/static/immutable/chunks/3upr08c9vtj8w.js","/_next/static/immutable/chunks/1ww0328si-u8x.js","/_next/static/immutable/chunks/11mfl5ymqld9-.js","/_next/static/immutable/chunks/2xxcqy6ppds3l.js","/_next/static/immutable/chunks/3j06ow7w40nxu.js","/_next/static/immutable/chunks/31nn7jwsjvqii.js","/_next/static/immutable/chunks/43_s7jweyypoh.js","/_next/static/immutable/chunks/0p6vao205o1jc.js","/_next/static/immutable/chunks/1_kyvgkyokw92.js","/_next/static/immutable/chunks/1lo-zn37dolb5.js","/_next/static/immutable/chunks/1v8k6yxw1rg0u.js"],"RegistryDependencies"] 4f:I[314491,["/_next/static/immutable/chunks/3arlv5bvukoo2.js","/_next/static/immutable/chunks/39v64hmfyo-sr.js","/_next/static/immutable/chunks/2nvof3-29tvc3.js","/_next/static/immutable/chunks/3tjobt77z_9dj.js","/_next/static/immutable/chunks/04j_o97cgxn2x.js","/_next/static/immutable/chunks/3upr08c9vtj8w.js","/_next/static/immutable/chunks/1ww0328si-u8x.js","/_next/static/immutable/chunks/11mfl5ymqld9-.js","/_next/static/immutable/chunks/2xxcqy6ppds3l.js","/_next/static/immutable/chunks/3j06ow7w40nxu.js","/_next/static/immutable/chunks/31nn7jwsjvqii.js","/_next/static/immutable/chunks/43_s7jweyypoh.js","/_next/static/immutable/chunks/0p6vao205o1jc.js","/_next/static/immutable/chunks/1_kyvgkyokw92.js","/_next/static/immutable/chunks/1lo-zn37dolb5.js","/_next/static/immutable/chunks/1v8k6yxw1rg0u.js"],"FilesView"] 50:T4b03,"use client"; import "react-pdf/dist/Page/AnnotationLayer.css"; import "react-pdf/dist/Page/TextLayer.css"; import { forwardRef, useEffect, useImperativeHandle, useMemo, useRef, useState, } from "react"; import { Document } from "react-pdf"; import type { PDFDocumentProxy } from "pdfjs-dist"; import { cn } from "@/lib/utils"; import { PdfViewerContext } from "./hooks/use-pdf-viewer-context"; import { usePdfDocument } from "./hooks/use-pdf-document"; import { usePdfDrop } from "./hooks/use-pdf-drop"; import { usePdfKeyboard } from "./hooks/use-pdf-keyboard"; import { usePdfPageTracker } from "./hooks/use-pdf-page-tracker"; import { usePdfPrint } from "./hooks/use-pdf-print"; import { usePdfSelection } from "./hooks/use-pdf-selection"; import { usePdfZoom } from "./hooks/use-pdf-zoom"; import { resolveVisiblePages } from "./hooks/use-pdf-virtualization"; import { PdfContextMenu } from "./parts/pdf-context-menu"; import { PdfDropOverlay } from "./parts/pdf-drop-overlay"; import { PdfEmptyState } from "./parts/pdf-empty-state"; import { PdfErrorState } from "./parts/pdf-error-state"; import { PdfLoadingState } from "./parts/pdf-loading-state"; import { PdfPage } from "./parts/pdf-page"; import { PdfPasswordPrompt } from "./parts/pdf-password-prompt"; import { PdfToolbar } from "./parts/pdf-toolbar"; import { downloadAsFile } from "./lib/download"; import { getSourceFilename, normalizeSource } from "./lib/normalize-source"; import { ensureWorkerConfigured } from "./lib/worker-config"; import { DEFAULT_PDF_VIEWER_LABELS, type PdfActions, type PdfDocumentState, type PdfFitMode, type PdfRotation, type PdfSource, type PdfStatus, type PdfViewerHandle, type PdfViewerLabels, type PdfViewerProps, type ResolvedPdfViewerLabels, } from "./types"; const COMPACT_BREAKPOINT_PX = 480; function resolveLabels( override: PdfViewerLabels | undefined, ): ResolvedPdfViewerLabels { if (!override) return DEFAULT_PDF_VIEWER_LABELS; return { ...DEFAULT_PDF_VIEWER_LABELS, ...override }; } export const PdfViewer = forwardRef( function PdfViewer(props, ref) { const { source, toolbar = true, renderToolbar, enableDragDrop = true, dragDropOverlay = true, initialPage = 1, initialScale = "fit-width", initialRotation = 0, virtualize = "auto", virtualizeThreshold = 50, enableContextMenu = true, renderContextMenu, onSearchSelection, password, renderPasswordPrompt, workerSrc, allowDownload = true, allowPrint = true, downloadFilename = "document.pdf", onLoad, onError, onPageChange, onScaleChange, onRotationChange, onSelection, onSourceChange, className, style, scrollContainerClassName, pageClassName, labels: labelsProp, ariaLabel, } = props; const labels = useMemo(() => resolveLabels(labelsProp), [labelsProp]); // Worker config useEffect(() => { ensureWorkerConfigured(workerSrc); }, [workerSrc]); // Internal source state — driven by `source` prop, mutated by drop. const [internalSource, setInternalSource] = useState( source ?? null, ); const lastPropSourceRef = useRef(source); useEffect(() => { if (lastPropSourceRef.current !== source) { lastPropSourceRef.current = source; setInternalSource(source ?? null); onSourceChange?.({ source: source ?? null, reason: "prop" }); } }, [source, onSourceChange]); // Notify on dropped-source change (when user drops a file) const replaceSource = ( next: PdfSource | null, reason: "prop" | "drop", ) => { setInternalSource(next); onSourceChange?.({ source: next, reason }); }; const normalizedSource = useMemo( () => normalizeSource(internalSource), [internalSource], ); // Document loading lifecycle const documentState = usePdfDocument({ source: normalizedSource, password, }); // Page sizes for virtualization placeholders + fit-scale. const [pageSizes, setPageSizes] = useState< Array<{ width: number; height: number } | null> >([]); useEffect(() => { const pdf = documentState.pdfDocument; if (!pdf) { setPageSizes([]); return; } let cancelled = false; const N = pdf.numPages; const sizes: Array<{ width: number; height: number } | null> = new Array( N, ).fill(null); (async () => { const concurrency = 8; for (let start = 0; start < N; start += concurrency) { if (cancelled) return; const batch: Promise[] = []; for (let i = start; i < Math.min(start + concurrency, N); i++) { batch.push( pdf.getPage(i + 1).then((page) => { if (cancelled) return; const vp = page.getViewport({ scale: 1, rotation: 0 }); sizes[i] = { width: vp.width, height: vp.height }; }), ); } await Promise.all(batch); if (!cancelled) setPageSizes([...sizes]); } })(); return () => { cancelled = true; }; }, [documentState.pdfDocument]); // Refs const rootRef = useRef(null); const scrollContainerRef = useRef(null); // Compact mode tracking via ResizeObserver const [compact, setCompact] = useState(false); /* * v0.3.1 — open-state + anchor point for the `renderContextMenu` slot. * `null` means closed; the built-in Radix menu does not use this (it owns * its own positioning), so this is purely the consumer-slot path. */ const [customMenuPos, setCustomMenuPos] = useState<{ x: number; y: number; } | null>(null); /* * Escape closes the custom context menu. * * Review finding: this started as `onKeyDown` on the scroll container, which * only fires while THAT element has focus — and a context menu almost always * takes focus itself the moment it opens, so the handler could not fire in * the one situation it existed for. Listening at the document is what makes * the documented behaviour actually true. */ useEffect(() => { if (!customMenuPos) return; const onKey = (event: KeyboardEvent) => { if (event.key === "Escape") setCustomMenuPos(null); }; document.addEventListener("keydown", onKey); return () => document.removeEventListener("keydown", onKey); }, [customMenuPos]); useEffect(() => { const root = rootRef.current; if (!root) return; const ro = new ResizeObserver(() => { setCompact(root.clientWidth < COMPACT_BREAKPOINT_PX); }); ro.observe(root); setCompact(root.clientWidth < COMPACT_BREAKPOINT_PX); return () => ro.disconnect(); }, []); // Page state const [page, setPage] = useState(Math.max(1, initialPage)); const [rotation, setRotation] = useState(initialRotation); // Reset page + rotation on document change useEffect(() => { setPage(Math.max(1, initialPage)); setRotation(initialRotation); // eslint-disable-next-line react-hooks/exhaustive-deps }, [documentState.pdfDocument]); // Base page dimensions for fit-scale (use first page) const basePage = pageSizes[0] ?? null; // Zoom hook const zoom = usePdfZoom({ containerRef: scrollContainerRef, basePageWidth: basePage?.width ?? 612, basePageHeight: basePage?.height ?? 792, rotation, initialScale, onScaleChange, }); // Page tracker const pageTracker = usePdfPageTracker({ containerRef: scrollContainerRef, numPages: documentState.numPages, ready: documentState.status === "ready", onPageChange: (next) => { setPage((prev) => { if (prev !== next) { onPageChange?.({ page: next, source: internalSource }); } return next; }); }, }); // Print const printer = usePdfPrint({ pdfDocument: documentState.pdfDocument, rotation, }); // Selection const selectedText = usePdfSelection({ rootRef: rootRef as unknown as { current: HTMLElement | null }, onSelection, }); // Drop const drop = usePdfDrop({ enabled: enableDragDrop, onPdfDropped: (file) => { replaceSource(file, "drop"); }, onNonPdfDropped: () => { // Hook into a future toast — for now, no-op (label is exposed via ctx). }, }); // Status (drives UI surface) const status: PdfStatus = useMemo(() => { if (documentState.status === "idle") return "empty"; if (documentState.status === "loading") return "loading"; if (documentState.status === "password") return "password"; if (documentState.status === "ready") return "ready"; return "error"; }, [documentState.status]); // Notify load + error const lastLoadedRef = useRef(null); useEffect(() => { if ( documentState.status === "ready" && documentState.pdfDocument && lastLoadedRef.current !== documentState.pdfDocument ) { lastLoadedRef.current = documentState.pdfDocument; onLoad?.({ numPages: documentState.numPages, pdfDocument: documentState.pdfDocument, }); } if (documentState.status === "error" && documentState.error) { onError?.({ error: documentState.error, source: internalSource, }); } // eslint-disable-next-line react-hooks/exhaustive-deps }, [documentState.status, documentState.pdfDocument, documentState.error]); // Notify rotation change useEffect(() => { onRotationChange?.({ rotation }); // eslint-disable-next-line react-hooks/exhaustive-deps }, [rotation]); // Build actions const actions = useMemo( () => ({ goToPage: (n: number) => { const total = documentState.numPages; const clamped = Math.max( 1, Math.min(total > 0 ? total : n, Math.floor(n)), ); pageTracker.scrollToPage(clamped); }, goToNextPage: () => { const total = documentState.numPages; if (page < total) pageTracker.scrollToPage(page + 1); }, goToPrevPage: () => { if (page > 1) pageTracker.scrollToPage(page - 1); }, setScale: (s) => zoom.setScale(s), zoomIn: () => zoom.zoomIn(), zoomOut: () => zoom.zoomOut(), resetZoom: () => zoom.resetZoom(), rotate: (delta = 90) => { setRotation((current) => { const next = (((current + delta) % 360) + 360) % 360; const snapped = (Math.round(next / 90) * 90) % 360; return snapped as PdfRotation; }); }, setRotation: (r) => setRotation(r), download: () => { const filename = getSourceFilename(internalSource) ?? downloadFilename; void downloadAsFile(internalSource, filename); }, print: () => { if (!allowPrint) return; void printer.print(); }, }), [ documentState.numPages, page, zoom, pageTracker, internalSource, downloadFilename, allowPrint, printer, ], ); // Keyboard usePdfKeyboard({ containerRef: scrollContainerRef, rootRef: rootRef as unknown as { current: HTMLElement | null }, actions, status, allowDownload, allowPrint, }); // Document state for context const docState: PdfDocumentState = useMemo( () => ({ page, numPages: documentState.numPages, scale: zoom.scale, fitMode: zoom.fitMode as PdfFitMode, rotation, loading: status === "loading", ready: status === "ready", error: documentState.error, source: internalSource, selectedText, status, }), [ page, documentState.numPages, zoom.scale, zoom.fitMode, rotation, status, documentState.error, internalSource, selectedText, ], ); // Imperative handle useImperativeHandle( ref, () => ({ actions, state: docState, pdfDocument: documentState.pdfDocument, }), [actions, docState, documentState.pdfDocument], ); // Context value const contextValue = { ...docState, actions, labels, allowDownload, allowPrint, compact, pdfDocument: documentState.pdfDocument, }; // Visible pages for rendering const visiblePages = useMemo( () => resolveVisiblePages({ numPages: documentState.numPages, currentPage: page, mode: virtualize, threshold: virtualizeThreshold, }), [documentState.numPages, page, virtualize, virtualizeThreshold], ); // Toolbar slot context const toolbarCtx = { ...docState, actions, allowDownload, allowPrint, compact, }; // Password prompt slot context const passwordCtx = { submit: documentState.submitPassword, cancel: documentState.cancelPassword, error: documentState.error, attempts: documentState.passwordAttempts, }; // Context menu slot context const contextMenuCtx = { ...docState, actions, /* * v0.3.1 — real position + a close that closes. * * The custom slot used to render UNCONDITIONALLY at `{x:0, y:0}` with an * empty-bodied `closeMenu`, which made it unusable as a context menu: it * was always on screen, always in the corner, and could not be dismissed. * The built-in menu never hit this because Radix owns its own positioning * — only the consumer-facing slot was broken. */ position: customMenuPos ?? { x: 0, y: 0 }, closeMenu: () => setCustomMenuPos(null), onSearch: onSearchSelection ? (text: string) => onSearchSelection({ text }) : null, }; return (

} aria-label={ariaLabel ?? labels.viewerAriaLabel} className={cn( "relative flex h-full w-full flex-col overflow-hidden rounded-lg border border-border bg-background", className, )} style={style} data-pdf-viewer-root > {toolbar ? (renderToolbar?.(toolbarCtx) ?? ) : null}

{ event.preventDefault(); setCustomMenuPos({ x: event.clientX, y: event.clientY }); } : undefined } className={cn( "relative flex-1 overflow-auto bg-muted/30 [touch-action:pan-x_pan-y]", "[&_.react-pdf__Page__textContent]:select-text", scrollContainerClassName, )} tabIndex={0} > {status === "empty" ? ( ) : null} {status === "loading" ? : null} {status === "error" && documentState.error ? ( ) : null} {/* Document wraps the page list so AnnotationLayer/TextLayer can read `pdf` from DocumentContext. `className="contents"` keeps its wrapper div transparent to layout. */} {normalizedSource ? ( {status === "ready" && documentState.pdfDocument ? ( onSearchSelection({ text }) : undefined } className="flex flex-col items-center gap-3 p-4" > {Array.from( { length: documentState.numPages }, (_, i) => { const pageNumber = i + 1; const isVisible = visiblePages.has(pageNumber); return ( ); }, )} ) : null} ) : null}

{status === "password" ? (renderPasswordPrompt?.(passwordCtx) ?? ( )) : null} {/* Custom context-menu slot (when consumer overrides) */} {status === "ready" && enableContextMenu && renderContextMenu && customMenuPos ? renderContextMenu(contextMenuCtx) : null} {drop.isDragging && enableDragDrop && dragDropOverlay ? ( ) : null}

); }, ); export default PdfViewer; 51:T16ef,import type { CSSProperties, ReactNode } from "react"; import type { PDFDocumentProxy } from "pdfjs-dist"; export type PdfSource = string | File | Blob | ArrayBuffer | Uint8Array; export type PdfInitialScale = "fit-width" | "fit-page" | number; export type PdfRotation = 0 | 90 | 180 | 270; export type PdfFitMode = "fit-width" | "fit-page" | null; export type PdfVirtualizeMode = "auto" | "always" | "never"; export type PdfStatus = | "empty" | "loading" | "password" | "ready" | "error"; export interface PdfActions { goToPage: (page: number) => void; goToNextPage: () => void; goToPrevPage: () => void; setScale: (scale: number | "fit-width" | "fit-page") => void; zoomIn: () => void; zoomOut: () => void; resetZoom: () => void; rotate: (deltaDegrees?: number) => void; setRotation: (rotation: PdfRotation) => void; download: () => void; print: () => void; } export interface PdfDocumentState { page: number; numPages: number; scale: number; fitMode: PdfFitMode; rotation: PdfRotation; loading: boolean; ready: boolean; error: Error | null; source: PdfSource | null; selectedText: string; status: PdfStatus; } export interface PdfToolbarContext extends PdfDocumentState { actions: PdfActions; allowDownload: boolean; allowPrint: boolean; compact: boolean; } export interface PdfContextMenuContext extends PdfDocumentState { actions: PdfActions; position: { x: number; y: number }; closeMenu: () => void; onSearch: ((text: string) => void) | null; } export interface PdfPasswordPromptContext { submit: (password: string) => void; cancel: () => void; error: Error | null; attempts: number; } export interface PdfViewerHandle { actions: PdfActions; state: PdfDocumentState; pdfDocument: PDFDocumentProxy | null; } export interface PdfViewerLabels { prevPage?: ReactNode; nextPage?: ReactNode; zoomIn?: ReactNode; zoomOut?: ReactNode; fitWidth?: ReactNode; fitPage?: ReactNode; resetZoom?: ReactNode; rotate?: ReactNode; download?: ReactNode; print?: ReactNode; pageOfTotal?: (page: number, total: number) => string; scalePercent?: (scale: number) => string; more?: ReactNode; jumpToPage?: ReactNode; loading?: ReactNode; emptyTitle?: ReactNode; emptyHint?: ReactNode; errorTitle?: ReactNode; errorRetry?: ReactNode; dropPdfHere?: ReactNode; notAPdfFile?: ReactNode; passwordTitle?: ReactNode; passwordHint?: ReactNode; passwordPlaceholder?: string; passwordSubmit?: ReactNode; passwordCancel?: ReactNode; passwordError?: ReactNode; copyText?: ReactNode; searchSelection?: ReactNode; contextNextPage?: ReactNode; contextPrevPage?: ReactNode; contextZoomIn?: ReactNode; contextZoomOut?: ReactNode; contextRotate?: ReactNode; contextDownload?: ReactNode; contextPrint?: ReactNode; toolbarAriaLabel?: string; viewerAriaLabel?: string; } export type ResolvedPdfViewerLabels = Omit< Required, "pageOfTotal" | "scalePercent" > & { pageOfTotal: (page: number, total: number) => string; scalePercent: (scale: number) => string; }; export const DEFAULT_PDF_VIEWER_LABELS: ResolvedPdfViewerLabels = { prevPage: "Previous page", nextPage: "Next page", zoomIn: "Zoom in", zoomOut: "Zoom out", fitWidth: "Fit width", fitPage: "Fit page", resetZoom: "Reset zoom", rotate: "Rotate", download: "Download", print: "Print", pageOfTotal: (page, total) => `Page ${page} of ${total}`, scalePercent: (scale) => `${Math.round(scale * 100)}%`, more: "More actions", jumpToPage: "Jump to page", loading: "Loading PDF…", emptyTitle: "No document loaded", emptyHint: "Drop a PDF here, or pass a `source` prop.", errorTitle: "Couldn't load this PDF", errorRetry: "Try again", dropPdfHere: "Drop PDF here", notAPdfFile: "Only PDF files are supported.", passwordTitle: "This PDF is password-protected", passwordHint: "Enter the password to view it.", passwordPlaceholder: "Password", passwordSubmit: "Unlock", passwordCancel: "Cancel", passwordError: "Wrong password. Try again.", copyText: "Copy text", searchSelection: "Search selection", contextNextPage: "Next page", contextPrevPage: "Previous page", contextZoomIn: "Zoom in", contextZoomOut: "Zoom out", contextRotate: "Rotate", contextDownload: "Download", contextPrint: "Print", toolbarAriaLabel: "PDF viewer controls", viewerAriaLabel: "PDF document viewer", }; export interface PdfViewerProps { source?: PdfSource | null; toolbar?: boolean; renderToolbar?: (ctx: PdfToolbarContext) => ReactNode; enableDragDrop?: boolean; dragDropOverlay?: boolean; initialPage?: number; initialScale?: PdfInitialScale; initialRotation?: PdfRotation; virtualize?: PdfVirtualizeMode; virtualizeThreshold?: number; enableContextMenu?: boolean; renderContextMenu?: (ctx: PdfContextMenuContext) => ReactNode; onSearchSelection?: (args: { text: string }) => void; password?: string; renderPasswordPrompt?: (ctx: PdfPasswordPromptContext) => ReactNode; workerSrc?: string; allowDownload?: boolean; allowPrint?: boolean; downloadFilename?: string; onLoad?: (args: { numPages: number; pdfDocument: PDFDocumentProxy }) => void; onError?: (args: { error: Error; source: PdfSource | null }) => void; onPageChange?: (args: { page: number; source: PdfSource | null }) => void; onScaleChange?: (args: { scale: number; fitMode: PdfFitMode }) => void; onRotationChange?: (args: { rotation: PdfRotation }) => void; onSelection?: (args: { text: string }) => void; onSourceChange?: (args: { source: PdfSource | null; reason: "prop" | "drop"; }) => void; className?: string; style?: CSSProperties; scrollContainerClassName?: string; pageClassName?: string; labels?: PdfViewerLabels; ariaLabel?: string; } 52:T11d9,"use client"; import { useCallback, useEffect, useRef, useState } from "react"; import type { PDFDocumentProxy } from "pdfjs-dist"; import type { NormalizedPdfSource } from "../lib/normalize-source"; export type PdfDocumentStatus = | "idle" | "loading" | "password" | "ready" | "error"; export interface UsePdfDocumentArgs { source: NormalizedPdfSource | null; password?: string; } export interface PdfDocumentCallbacks { onLoadSuccess: (pdf: PDFDocumentProxy) => void; onLoadError: (error: Error) => void; onSourceError: (error: Error) => void; onPassword: (callback: (password: string) => void, reason: number) => void; } export interface UsePdfDocumentReturn { status: PdfDocumentStatus; pdfDocument: PDFDocumentProxy | null; error: Error | null; numPages: number; passwordAttempts: number; documentCallbacks: PdfDocumentCallbacks; submitPassword: (password: string) => void; cancelPassword: () => void; retry: () => void; } /** * Tracks the load lifecycle of a PDF document. The actual loading is done by * react-pdf's component (which natively handles all source shapes * — string URL / File / Blob / ArrayBuffer / { data } / { url } objects). * This hook returns callbacks to wire into and exposes the * resulting status as a discriminated state. */ export function usePdfDocument(args: UsePdfDocumentArgs): UsePdfDocumentReturn { const { source, password } = args; const [status, setStatus] = useState( source == null ? "idle" : "loading", ); const [pdfDocument, setPdfDocument] = useState(null); const [error, setError] = useState(null); const [passwordAttempts, setPasswordAttempts] = useState(0); const [retryToken, setRetryToken] = useState(0); const passwordCallbackRef = useRef<((password: string) => void) | null>(null); // React 19 pattern — reset state when source or retryToken changes. // setState during render is the recommended way to derive state from props. // See https://react.dev/learn/you-might-not-need-an-effect#adjusting-some-state-when-a-prop-changes const [trackedKey, setTrackedKey] = useState<{ source: NormalizedPdfSource | null; retryToken: number; }>({ source, retryToken }); if (trackedKey.source !== source || trackedKey.retryToken !== retryToken) { setTrackedKey({ source, retryToken }); setPdfDocument(null); setError(null); setPasswordAttempts(0); setStatus(source == null ? "idle" : "loading"); } // Clear the password callback ref when the tracked key changes — the old // callback belongs to a stale loadingTask and should not be invoked. useEffect(() => { passwordCallbackRef.current = null; }, [trackedKey]); const handleLoadSuccess = useCallback((pdf: PDFDocumentProxy) => { setPdfDocument(pdf); setError(null); setStatus("ready"); }, []); const handleLoadError = useCallback((err: Error) => { setError(err); setStatus("error"); }, []); const handleSourceError = useCallback((err: Error) => { setError(err); setStatus("error"); }, []); const handlePassword = useCallback( (callback: (password: string) => void, reason: number) => { passwordCallbackRef.current = callback; // pdf.js PasswordResponses: NEED_PASSWORD = 1, INCORRECT_PASSWORD = 2 const isIncorrect = reason === 2; if (password && !isIncorrect) { callback(password); passwordCallbackRef.current = null; return; } if (isIncorrect) { setPasswordAttempts((n) => n + 1); setError(new Error("Incorrect password")); } else { setError(null); } setStatus("password"); }, [password], ); const submitPassword = useCallback((p: string) => { const cb = passwordCallbackRef.current; if (cb) { cb(p); passwordCallbackRef.current = null; } }, []); const cancelPassword = useCallback(() => { passwordCallbackRef.current = null; setError(new Error("Password required to view this PDF.")); setStatus("error"); }, []); const retry = useCallback(() => { setRetryToken((n) => n + 1); }, []); return { status, pdfDocument, error, numPages: pdfDocument?.numPages ?? 0, passwordAttempts, documentCallbacks: { onLoadSuccess: handleLoadSuccess, onLoadError: handleLoadError, onSourceError: handleSourceError, onPassword: handlePassword, }, submitPassword, cancelPassword, retry, }; } 53:T21b0,"use client"; import { useCallback, useEffect, useLayoutEffect, useRef, useState } from "react"; import { PDF_VIEWER_MAX_SCALE, PDF_VIEWER_MIN_SCALE, clampScale, nextZoomIn, nextZoomOut, } from "../lib/clamp-scale"; import { computeFitPageScale, computeFitWidthScale, } from "../lib/compute-fit-scale"; import type { PdfFitMode, PdfRotation } from "../types"; export interface UsePdfZoomArgs { containerRef: { current: HTMLElement | null }; basePageWidth: number; basePageHeight: number; rotation: PdfRotation; initialScale: number | "fit-width" | "fit-page"; onScaleChange?: (args: { scale: number; fitMode: PdfFitMode }) => void; } export interface UsePdfZoomReturn { scale: number; fitMode: PdfFitMode; setScale: (next: number | "fit-width" | "fit-page") => void; zoomIn: () => void; zoomOut: () => void; resetZoom: () => void; } interface PendingZoomTarget { cursorX: number; cursorY: number; docX: number; docY: number; oldScale: number; } /** * Manages numeric scale + fit-mode for the viewer. Handles ctrl/cmd + wheel * zoom (cursor-anchored) and 2-finger pinch zoom (midpoint-anchored). */ export function usePdfZoom(args: UsePdfZoomArgs): UsePdfZoomReturn { const { containerRef, basePageWidth, basePageHeight, rotation, initialScale, onScaleChange, } = args; const [fitMode, setFitMode] = useState( initialScale === "fit-width" || initialScale === "fit-page" ? initialScale : null, ); const [scale, setScaleState] = useState( typeof initialScale === "number" ? clampScale(initialScale) : 1, ); const pendingTargetRef = useRef(null); const onScaleChangeRef = useRef(onScaleChange); useEffect(() => { onScaleChangeRef.current = onScaleChange; }, [onScaleChange]); const recomputeFitScale = useCallback( (mode: "fit-width" | "fit-page"): number => { const container = containerRef.current; if (!container || basePageWidth <= 0 || basePageHeight <= 0) return 1; const inputs = { containerWidth: container.clientWidth, containerHeight: container.clientHeight, pageWidth: basePageWidth, pageHeight: basePageHeight, rotation, }; return mode === "fit-width" ? computeFitWidthScale(inputs) : computeFitPageScale(inputs); }, [containerRef, basePageWidth, basePageHeight, rotation], ); // Apply fit-mode scale on mount, on rotation change, and on container resize. useEffect(() => { if (!fitMode) return; const container = containerRef.current; if (!container) return; const apply = () => { const next = recomputeFitScale(fitMode); setScaleState(next); }; apply(); const ro = new ResizeObserver(apply); ro.observe(container); return () => ro.disconnect(); }, [fitMode, recomputeFitScale, containerRef]); // Notify parent when scale or fitMode actually changes. const lastNotifiedRef = useRef<{ scale: number; fitMode: PdfFitMode }>({ scale, fitMode, }); useEffect(() => { if ( lastNotifiedRef.current.scale !== scale || lastNotifiedRef.current.fitMode !== fitMode ) { lastNotifiedRef.current = { scale, fitMode }; onScaleChangeRef.current?.({ scale, fitMode }); } }, [scale, fitMode]); // After scale change from a cursor-anchored zoom, restore scroll so the // cursor stays over the same point in the document. useLayoutEffect(() => { const target = pendingTargetRef.current; if (!target) return; pendingTargetRef.current = null; const container = containerRef.current; if (!container) return; const factor = scale / target.oldScale; container.scrollLeft = target.docX * factor - target.cursorX; container.scrollTop = target.docY * factor - target.cursorY; }, [scale, containerRef]); const setScale = useCallback( (next: number | "fit-width" | "fit-page") => { if (next === "fit-width" || next === "fit-page") { setFitMode(next); // recompute via effect return; } setFitMode(null); setScaleState(clampScale(next)); }, [], ); const zoomIn = useCallback(() => { setFitMode(null); setScaleState((s) => nextZoomIn(s)); }, []); const zoomOut = useCallback(() => { setFitMode(null); setScaleState((s) => nextZoomOut(s)); }, []); const resetZoom = useCallback(() => { setFitMode(null); setScaleState(1); }, []); // Wheel-zoom (Ctrl/Cmd + wheel). Cursor-anchored. useEffect(() => { const container = containerRef.current; if (!container) return; const onWheel = (e: WheelEvent) => { if (!(e.ctrlKey || e.metaKey)) return; e.preventDefault(); const rect = container.getBoundingClientRect(); const cursorX = e.clientX - rect.left; const cursorY = e.clientY - rect.top; const docX = container.scrollLeft + cursorX; const docY = container.scrollTop + cursorY; pendingTargetRef.current = { cursorX, cursorY, docX, docY, oldScale: scale, }; setFitMode(null); setScaleState((current) => { const target = e.deltaY > 0 ? nextZoomOut(current) : nextZoomIn(current); return target; }); }; container.addEventListener("wheel", onWheel, { passive: false }); return () => container.removeEventListener("wheel", onWheel); }, [containerRef, scale]); // Pinch-zoom on touch devices via Pointer Events. useEffect(() => { const container = containerRef.current; if (!container) return; const pointers = new Map(); let initialDistance = 0; let initialScale = scale; let initialMid = { x: 0, y: 0 }; let initialDocPoint = { x: 0, y: 0 }; const distance = () => { const pts = Array.from(pointers.values()); if (pts.length < 2) return 0; const dx = pts[0].x - pts[1].x; const dy = pts[0].y - pts[1].y; return Math.hypot(dx, dy); }; const midpoint = () => { const pts = Array.from(pointers.values()); if (pts.length < 2) return { x: 0, y: 0 }; return { x: (pts[0].x + pts[1].x) / 2, y: (pts[0].y + pts[1].y) / 2 }; }; const onPointerDown = (e: PointerEvent) => { if (e.pointerType !== "touch") return; pointers.set(e.pointerId, { x: e.clientX, y: e.clientY }); if (pointers.size === 2) { initialDistance = distance(); initialScale = scale; const rect = container.getBoundingClientRect(); const mid = midpoint(); initialMid = { x: mid.x - rect.left, y: mid.y - rect.top, }; initialDocPoint = { x: container.scrollLeft + initialMid.x, y: container.scrollTop + initialMid.y, }; } }; const onPointerMove = (e: PointerEvent) => { if (e.pointerType !== "touch") return; if (!pointers.has(e.pointerId)) return; pointers.set(e.pointerId, { x: e.clientX, y: e.clientY }); if (pointers.size === 2 && initialDistance > 0) { e.preventDefault(); const newDistance = distance(); const ratio = newDistance / initialDistance; const next = clampScale(initialScale * ratio); pendingTargetRef.current = { cursorX: initialMid.x, cursorY: initialMid.y, docX: initialDocPoint.x, docY: initialDocPoint.y, oldScale: initialScale, }; setFitMode(null); setScaleState(next); } }; const onPointerUp = (e: PointerEvent) => { if (e.pointerType !== "touch") return; pointers.delete(e.pointerId); if (pointers.size < 2) { initialDistance = 0; } }; container.addEventListener("pointerdown", onPointerDown); container.addEventListener("pointermove", onPointerMove, { passive: false }); container.addEventListener("pointerup", onPointerUp); container.addEventListener("pointercancel", onPointerUp); return () => { container.removeEventListener("pointerdown", onPointerDown); container.removeEventListener("pointermove", onPointerMove); container.removeEventListener("pointerup", onPointerUp); container.removeEventListener("pointercancel", onPointerUp); }; }, [containerRef, scale]); return { scale, fitMode, setScale, zoomIn, zoomOut, resetZoom, }; } export const PDF_VIEWER_SCALE_BOUNDS = { min: PDF_VIEWER_MIN_SCALE, max: PDF_VIEWER_MAX_SCALE, }; 54:Tb3a,"use client"; import { useCallback, useEffect } from "react"; interface UsePdfPageTrackerArgs { containerRef: { current: HTMLElement | null }; numPages: number; ready: boolean; onPageChange: (page: number) => void; } export interface UsePdfPageTrackerReturn { scrollToPage: (page: number, behavior?: ScrollBehavior) => void; } /** * Tracks which page is "current" based on which page element is closest to * the top of the scroll container. Uses IntersectionObserver with a tight * top-band root margin so the active page = the topmost intersecting page. */ export function usePdfPageTracker( args: UsePdfPageTrackerArgs, ): UsePdfPageTrackerReturn { const { containerRef, numPages, ready, onPageChange } = args; useEffect(() => { if (!ready) return; const container = containerRef.current; if (!container) return; if (numPages <= 0) return; let frame: number | null = null; const update = () => { frame = null; const pageEls = container.querySelectorAll( "[data-pdf-page]", ); if (pageEls.length === 0) return; const containerTop = container.getBoundingClientRect().top; const probeY = containerTop + 80; let activePage = 1; for (const el of Array.from(pageEls)) { const rect = el.getBoundingClientRect(); if (rect.top <= probeY && rect.bottom > probeY) { const n = Number(el.dataset.pdfPage); if (Number.isFinite(n) && n > 0) { activePage = n; break; } } if (rect.top > probeY) break; const n = Number(el.dataset.pdfPage); if (Number.isFinite(n) && n > 0) { activePage = n; } } onPageChange(activePage); }; const onScroll = () => { if (frame != null) return; frame = requestAnimationFrame(update); }; update(); container.addEventListener("scroll", onScroll, { passive: true }); const ro = new ResizeObserver(onScroll); ro.observe(container); return () => { container.removeEventListener("scroll", onScroll); ro.disconnect(); if (frame != null) cancelAnimationFrame(frame); }; }, [containerRef, numPages, ready, onPageChange]); const scrollToPage = useCallback( (page: number, behavior: ScrollBehavior = "smooth") => { const container = containerRef.current; if (!container) return; const target = container.querySelector( `[data-pdf-page="${page}"]`, ); if (!target) return; const containerRect = container.getBoundingClientRect(); const targetRect = target.getBoundingClientRect(); const top = container.scrollTop + (targetRect.top - containerRect.top) - 8; container.scrollTo({ top, behavior }); }, [containerRef], ); return { scrollToPage }; } 55:T509,"use client"; import type { PdfVirtualizeMode } from "../types"; interface ResolveArgs { numPages: number; currentPage: number; mode: PdfVirtualizeMode; threshold: number; /** Pages to render before the current page. */ bufferAbove?: number; /** Pages to render after the current page. */ bufferBelow?: number; } /** * Resolves which 1-based page numbers should be rendered as full * components. Other pages are rendered as height-locked placeholders. * * Rules: * - 'never' OR ('auto' && numPages < threshold) → render all pages * - 'always' OR ('auto' && numPages >= threshold) → window around current */ export function resolveVisiblePages({ numPages, currentPage, mode, threshold, bufferAbove = 1, bufferBelow = 2, }: ResolveArgs): Set { if (numPages <= 0) return new Set(); const useVirtual = mode === "always" || (mode === "auto" && numPages >= threshold); if (!useVirtual) { const all = new Set(); for (let i = 1; i <= numPages; i++) all.add(i); return all; } const start = Math.max(1, currentPage - bufferAbove); const end = Math.min(numPages, currentPage + bufferBelow); const visible = new Set(); for (let i = start; i <= end; i++) visible.add(i); return visible; } 56:Tb6f,"use client"; import { useEffect } from "react"; import type { PdfActions, PdfStatus } from "../types"; interface UsePdfKeyboardArgs { containerRef: { current: HTMLElement | null }; rootRef: { current: HTMLElement | null }; actions: PdfActions; status: PdfStatus; allowDownload: boolean; allowPrint: boolean; } /** * Wires keyboard shortcuts on the viewer root: PgUp/PgDn for page nav, * Cmd/Ctrl ± for zoom, Cmd/Ctrl + 0 for reset, Cmd/Ctrl + P for print, * Cmd/Ctrl + S for download. Listener attaches to document but only fires * when focus is inside the viewer's root. */ export function usePdfKeyboard(args: UsePdfKeyboardArgs): void { const { rootRef, actions, status, allowDownload, allowPrint } = args; useEffect(() => { if (status !== "ready") return; const onKeyDown = (e: KeyboardEvent) => { const root = rootRef.current; if (!root) return; const target = e.target as Node | null; if (target && !(root === target || root.contains(target))) return; // Skip when typing in inputs / textareas / contenteditable. if ( target instanceof HTMLElement && (target.tagName === "INPUT" || target.tagName === "TEXTAREA" || target.isContentEditable) ) { return; } const meta = e.ctrlKey || e.metaKey; if (meta && (e.key === "+" || e.key === "=")) { e.preventDefault(); actions.zoomIn(); return; } if (meta && e.key === "-") { e.preventDefault(); actions.zoomOut(); return; } if (meta && e.key === "0") { e.preventDefault(); actions.resetZoom(); return; } if (meta && (e.key === "p" || e.key === "P")) { if (!allowPrint) return; e.preventDefault(); actions.print(); return; } if (meta && (e.key === "s" || e.key === "S")) { if (!allowDownload) return; e.preventDefault(); actions.download(); return; } if (e.key === "PageDown") { e.preventDefault(); actions.goToNextPage(); return; } if (e.key === "PageUp") { e.preventDefault(); actions.goToPrevPage(); return; } if (e.key === "Home" && !meta) { // bare Home — scroll to first page if (target instanceof HTMLElement && target.tagName === "INPUT") return; e.preventDefault(); actions.goToPage(1); return; } if (e.key === "End" && !meta) { if (target instanceof HTMLElement && target.tagName === "INPUT") return; e.preventDefault(); actions.goToPage(Number.MAX_SAFE_INTEGER); return; } }; document.addEventListener("keydown", onKeyDown); return () => document.removeEventListener("keydown", onKeyDown); }, [rootRef, actions, status, allowDownload, allowPrint]); } 57:Ta48,"use client"; import { useCallback, useMemo, useRef, useState, type DragEvent as ReactDragEvent, type HTMLAttributes, } from "react"; import { isPdfFile } from "../lib/normalize-source"; interface UsePdfDropArgs { enabled: boolean; onPdfDropped: (file: File) => void; onNonPdfDropped?: () => void; } export interface UsePdfDropReturn { isDragging: boolean; dropProps: Pick< HTMLAttributes, "onDragEnter" | "onDragOver" | "onDragLeave" | "onDrop" >; } /** * Drag-drop a PDF onto the viewer. Tracks an `isDragging` flag with * counter-based dragenter/leave so nested children don't flicker the overlay. * * `isDragging` is gated by `enabled` at read time, so flipping `enabled` to * false while a drag is in progress hides the overlay without needing to * imperatively reset state in an effect. */ export function usePdfDrop(args: UsePdfDropArgs): UsePdfDropReturn { const { enabled, onPdfDropped, onNonPdfDropped } = args; const [isDraggingState, setIsDragging] = useState(false); const counterRef = useRef(0); const isDragging = enabled && isDraggingState; const onDragEnter = useCallback( (e: ReactDragEvent) => { if (!enabled) return; if (!e.dataTransfer.types.includes("Files")) return; counterRef.current += 1; if (counterRef.current === 1) setIsDragging(true); }, [enabled], ); const onDragOver = useCallback( (e: ReactDragEvent) => { if (!enabled) return; if (!e.dataTransfer.types.includes("Files")) return; e.preventDefault(); e.dataTransfer.dropEffect = "copy"; }, [enabled], ); const onDragLeave = useCallback( (e: ReactDragEvent) => { if (!enabled) return; if (!e.dataTransfer.types.includes("Files")) return; counterRef.current = Math.max(0, counterRef.current - 1); if (counterRef.current === 0) setIsDragging(false); }, [enabled], ); const onDrop = useCallback( (e: ReactDragEvent) => { if (!enabled) return; e.preventDefault(); counterRef.current = 0; setIsDragging(false); const files = Array.from(e.dataTransfer.files ?? []); const pdf = files.find(isPdfFile); if (pdf) { onPdfDropped(pdf); } else if (files.length > 0) { onNonPdfDropped?.(); } }, [enabled, onPdfDropped, onNonPdfDropped], ); return useMemo( () => ({ isDragging, dropProps: { onDragEnter, onDragOver, onDragLeave, onDrop }, }), [isDragging, onDragEnter, onDragOver, onDragLeave, onDrop], ); } 58:T6d7,"use client"; import { useEffect, useState } from "react"; interface UsePdfSelectionArgs { rootRef: { current: HTMLElement | null }; onSelection?: (args: { text: string }) => void; } /** * Tracks selected text inside the viewer. Debounced 150ms so we don't * fire on every mousemove during drag-select. */ export function usePdfSelection(args: UsePdfSelectionArgs): string { const { rootRef, onSelection } = args; const [selectedText, setSelectedText] = useState(""); useEffect(() => { const root = rootRef.current; if (!root) return; let timeout: ReturnType | null = null; const onSelectionChange = () => { if (timeout != null) clearTimeout(timeout); timeout = setTimeout(() => { const sel = typeof window !== "undefined" ? window.getSelection() : null; if (!sel || sel.rangeCount === 0) { if (selectedText !== "") { setSelectedText(""); onSelection?.({ text: "" }); } return; } const range = sel.getRangeAt(0); const inViewer = root === range.commonAncestorContainer || (range.commonAncestorContainer instanceof Node && root.contains(range.commonAncestorContainer)); if (!inViewer) return; const text = sel.toString(); setSelectedText(text); onSelection?.({ text }); }, 150); }; document.addEventListener("selectionchange", onSelectionChange); return () => { document.removeEventListener("selectionchange", onSelectionChange); if (timeout != null) clearTimeout(timeout); }; // eslint-disable-next-line react-hooks/exhaustive-deps }, [rootRef, onSelection]); return selectedText; } 59:Te95,"use client"; import { useCallback, useState } from "react"; import type { PDFDocumentProxy } from "pdfjs-dist"; import type { PdfRotation } from "../types"; interface UsePdfPrintArgs { pdfDocument: PDFDocumentProxy | null; rotation: PdfRotation; /** Render scale for print. Higher = sharper output, more memory. Default: 2. */ printScale?: number; } export interface UsePdfPrintReturn { print: () => Promise; isPrinting: boolean; } /** * Print the loaded document by rendering each page to a high-DPI canvas, * embedding them in a hidden iframe as images, and triggering print() on * that iframe. Sharper output than printing the live viewer canvas. */ export function usePdfPrint(args: UsePdfPrintArgs): UsePdfPrintReturn { const { pdfDocument, rotation, printScale = 2 } = args; const [isPrinting, setIsPrinting] = useState(false); const print = useCallback(async () => { if (isPrinting) return; if (!pdfDocument) return; setIsPrinting(true); const iframe = document.createElement("iframe"); iframe.setAttribute("aria-hidden", "true"); iframe.style.position = "fixed"; iframe.style.right = "0"; iframe.style.bottom = "0"; iframe.style.width = "0"; iframe.style.height = "0"; iframe.style.border = "0"; iframe.style.opacity = "0"; iframe.style.pointerEvents = "none"; document.body.appendChild(iframe); const cleanup = () => { try { if (iframe.parentNode) iframe.parentNode.removeChild(iframe); } catch { // ignore } setIsPrinting(false); }; try { const doc = iframe.contentDocument; const win = iframe.contentWindow; if (!doc || !win) { cleanup(); return; } doc.open(); doc.write( ``, ); doc.close(); const body = doc.body; const numPages = pdfDocument.numPages; for (let i = 1; i <= numPages; i++) { const page = await pdfDocument.getPage(i); const viewport = page.getViewport({ scale: printScale, rotation }); const canvas = document.createElement("canvas"); canvas.width = Math.floor(viewport.width); canvas.height = Math.floor(viewport.height); const ctx = canvas.getContext("2d"); if (!ctx) continue; await page.render({ canvas, canvasContext: ctx, viewport, } as Parameters[0]).promise; const dataUrl = canvas.toDataURL("image/png"); const wrapper = doc.createElement("div"); wrapper.className = "pdf-print-page"; const img = doc.createElement("img"); img.src = dataUrl; wrapper.appendChild(img); body.appendChild(wrapper); canvas.width = 0; canvas.height = 0; } const onAfterPrint = () => { win.removeEventListener("afterprint", onAfterPrint); cleanup(); }; win.addEventListener("afterprint", onAfterPrint); win.focus(); win.print(); // Safety net in case afterprint never fires. setTimeout(cleanup, 60000); } catch (err) { cleanup(); throw err; } }, [pdfDocument, rotation, printScale, isPrinting]); return { print, isPrinting }; } 5a:T632,import { clampScale } from "./clamp-scale"; export interface FitInputs { containerWidth: number; containerHeight: number; pageWidth: number; pageHeight: number; rotation?: 0 | 90 | 180 | 270; /** Horizontal padding to subtract from container width before fitting. */ horizontalPadding?: number; /** Vertical padding to subtract from container height before fitting (toolbar etc). */ verticalPadding?: number; } function rotatedSize( width: number, height: number, rotation: number, ): [number, number] { return rotation % 180 === 0 ? [width, height] : [height, width]; } export function computeFitWidthScale(inputs: FitInputs): number { const rotation = inputs.rotation ?? 0; const [pw] = rotatedSize(inputs.pageWidth, inputs.pageHeight, rotation); const horizontalPadding = inputs.horizontalPadding ?? 32; const usable = Math.max(0, inputs.containerWidth - horizontalPadding); if (pw <= 0 || usable <= 0) return 1; return clampScale(usable / pw); } export function computeFitPageScale(inputs: FitInputs): number { const rotation = inputs.rotation ?? 0; const [pw, ph] = rotatedSize( inputs.pageWidth, inputs.pageHeight, rotation, ); const horizontalPadding = inputs.horizontalPadding ?? 32; const verticalPadding = inputs.verticalPadding ?? 32; const usableW = Math.max(0, inputs.containerWidth - horizontalPadding); const usableH = Math.max(0, inputs.containerHeight - verticalPadding); if (pw <= 0 || ph <= 0 || usableW <= 0 || usableH <= 0) return 1; return clampScale(Math.min(usableW / pw, usableH / ph)); } 5b:T585,import type { PdfSource } from "../types"; /** * react-pdf accepts: * - string (URL or data URI) * - { data: Uint8Array | ArrayBuffer } * - Blob (covers File, since File extends Blob) * * We unify all of those into something the prop accepts. */ export type NormalizedPdfSource = | string | { data: Uint8Array | ArrayBuffer } | Blob; export function normalizeSource( input: PdfSource | null | undefined, ): NormalizedPdfSource | null { if (input == null) return null; if (typeof input === "string") return input; if (input instanceof ArrayBuffer) return { data: input }; if (input instanceof Uint8Array) return { data: input }; if (input instanceof Blob) return input; return null; } export function isPdfFile(file: File): boolean { return ( file.type === "application/pdf" || file.name.toLowerCase().endsWith(".pdf") ); } export function getSourceFilename( source: PdfSource | null | undefined, ): string | null { if (source == null) return null; if (typeof source === "string") { try { const url = new URL(source, "http://placeholder.local"); const name = url.pathname.split("/").pop(); return name && name.length > 0 ? decodeURIComponent(name) : null; } catch { return null; } } if (typeof File !== "undefined" && source instanceof File) { return source.name || null; } return null; } 5c:T74e,import type { PdfSource } from "../types"; function clickAnchor(href: string, filename: string): void { const a = document.createElement("a"); a.href = href; a.download = filename; a.rel = "noopener"; a.style.display = "none"; document.body.appendChild(a); a.click(); document.body.removeChild(a); } async function blobFromUrl(url: string): Promise { const res = await fetch(url, { credentials: "same-origin" }); if (!res.ok) { throw new Error(`Failed to fetch PDF for download (${res.status})`); } return await res.blob(); } export async function downloadAsFile( source: PdfSource | null, filename: string, ): Promise { if (source == null) return; const finalName = filename.toLowerCase().endsWith(".pdf") ? filename : `${filename}.pdf`; if (typeof source === "string") { let isCrossOrigin = false; try { const url = new URL(source, window.location.href); isCrossOrigin = url.origin !== window.location.origin; } catch { isCrossOrigin = false; } if (!isCrossOrigin) { clickAnchor(source, finalName); return; } const blob = await blobFromUrl(source); const objectUrl = URL.createObjectURL(blob); try { clickAnchor(objectUrl, finalName); } finally { setTimeout(() => URL.revokeObjectURL(objectUrl), 5000); } return; } let blob: Blob; if (source instanceof Blob) { blob = source; } else if (source instanceof ArrayBuffer) { blob = new Blob([source], { type: "application/pdf" }); } else if (source instanceof Uint8Array) { blob = new Blob([new Uint8Array(source)], { type: "application/pdf" }); } else { return; } const objectUrl = URL.createObjectURL(blob); try { clickAnchor(objectUrl, finalName); } finally { setTimeout(() => URL.revokeObjectURL(objectUrl), 5000); } } 5d:T7f6,"use client"; import { Page } from "react-pdf"; import type { PDFDocumentProxy } from "pdfjs-dist"; import { cn } from "@/lib/utils"; import type { PdfRotation } from "../types"; interface PdfPageProps { pdfDocument: PDFDocumentProxy; pageNumber: number; scale: number; rotation: PdfRotation; /** Known intrinsic page size at scale=1, used for the placeholder when not visible. */ basePageSize: { width: number; height: number } | null; /** When true, render only a placeholder div with the right height (virtualized away). */ placeholder: boolean; className?: string; } export function PdfPage({ pdfDocument, pageNumber, scale, rotation, basePageSize, placeholder, className, }: PdfPageProps) { if (placeholder) { const rotated = rotation % 180 === 0; const w = basePageSize ? (rotated ? basePageSize.width : basePageSize.height) * scale : 600; const h = basePageSize ? (rotated ? basePageSize.height : basePageSize.width) * scale : 800; return (

); } return (

} className="overflow-hidden rounded-md shadow-sm ring-1 ring-border" />

); } 5e:T4b1,"use client"; import { Separator } from "@/components/ui/separator"; import { TooltipProvider } from "@/components/ui/tooltip"; import { cn } from "@/lib/utils"; import { usePdfViewer } from "../hooks/use-pdf-viewer-context"; import { PdfActionMenu } from "./pdf-action-menu"; import { PdfPageIndicator } from "./pdf-page-indicator"; import { PdfPageNav } from "./pdf-page-nav"; import { PdfZoomControls } from "./pdf-zoom-controls"; interface PdfToolbarProps { className?: string; } export function PdfToolbar({ className }: PdfToolbarProps) { const { labels } = usePdfViewer(); return ( ); } 5f:T6b9,"use client"; import { ChevronLeft, ChevronRight } from "lucide-react"; import { buttonVariants } from "@/components/ui/button"; import { Tooltip, TooltipContent, TooltipTrigger, } from "@/components/ui/tooltip"; import { cn } from "@/lib/utils"; import { usePdfViewer } from "../hooks/use-pdf-viewer-context"; interface PdfPageNavProps { className?: string; } export function PdfPageNav({ className }: PdfPageNavProps) { const { page, numPages, actions, labels, status } = usePdfViewer(); const disabled = status !== "ready" || numPages === 0; // F-cross-13: no `asChild` — triggers render their own ); } 65:T4ff,"use client"; import { AlertCircle, RefreshCcw } from "lucide-react"; import { Button } from "@/components/ui/button"; import { cn } from "@/lib/utils"; import type { ResolvedPdfViewerLabels } from "../types"; interface PdfErrorStateProps { error: Error; labels: ResolvedPdfViewerLabels; onRetry?: () => void; className?: string; } export function PdfErrorState({ error, labels, onRetry, className, }: PdfErrorStateProps) { return (

{labels.errorTitle}

{error.message}

{onRetry ? ( ) : null}

); } 4d:["$","div",null,{"className":"mt-3 flex min-h-0 min-w-0 flex-1 flex-col gap-3","children":[["$","div",null,{"className":"flex shrink-0 items-start gap-3","children":[["$","div",null,{"className":"flex max-h-28 min-w-0 flex-1 flex-wrap items-center gap-2 overflow-y-auto","children":[["$","ul",null,{"className":"flex min-w-0 flex-wrap gap-2","aria-label":"Package dependencies","children":[["$","li","react-pdf",{"className":"min-w-0 max-w-full","children":["$","a",null,{"href":"https://www.npmjs.com/package/react-pdf","target":"_blank","rel":"noopener noreferrer","className":"flex max-w-full min-w-0 items-center gap-1.5 rounded-md border px-2 py-1.5 text-xs","children":[["$","svg",null,{"viewBox":"0 0 24 24","className":"size-3 shrink-0","children":["$","path",null,{"d":"M1.763 0C.786 0 0 .786 0 1.763v20.474C0 23.214.786 24 1.763 24h20.474c.977 0 1.763-.786 1.763-1.763V1.763C24 .786 23.214 0 22.237 0zM5.13 5.323l13.837.019-.009 13.836h-3.464l.01-10.382h-3.456L12.04 19.17H5.113z","fill":"currentColor"}]}],["$","span",null,{"className":"min-w-0 break-all text-xs font-medium","children":"react-pdf"}]]}]}],["$","li","pdfjs-dist@5.4.296",{"className":"min-w-0 max-w-full","children":["$","a",null,{"href":"https://www.npmjs.com/package/pdfjs-dist","target":"_blank","rel":"noopener noreferrer","className":"flex max-w-full min-w-0 items-center gap-1.5 rounded-md border px-2 py-1.5 text-xs","children":[["$","svg",null,{"viewBox":"0 0 24 24","className":"size-3 shrink-0","children":["$","path",null,{"d":"M1.763 0C.786 0 0 .786 0 1.763v20.474C0 23.214.786 24 1.763 24h20.474c.977 0 1.763-.786 1.763-1.763V1.763C24 .786 23.214 0 22.237 0zM5.13 5.323l13.837.019-.009 13.836h-3.464l.01-10.382h-3.456L12.04 19.17H5.113z","fill":"currentColor"}]}],["$","span",null,{"className":"min-w-0 break-all text-xs font-medium","children":"pdfjs-dist@5.4.296"}]]}]}],["$","li","lucide-react",{"className":"min-w-0 max-w-full","children":["$","a",null,{"href":"https://www.npmjs.com/package/lucide-react","target":"_blank","rel":"noopener noreferrer","className":"flex max-w-full min-w-0 items-center gap-1.5 rounded-md border px-2 py-1.5 text-xs","children":[["$","svg",null,{"viewBox":"0 0 24 24","className":"size-3 shrink-0","children":["$","path",null,{"d":"M1.763 0C.786 0 0 .786 0 1.763v20.474C0 23.214.786 24 1.763 24h20.474c.977 0 1.763-.786 1.763-1.763V1.763C24 .786 23.214 0 22.237 0zM5.13 5.323l13.837.019-.009 13.836h-3.464l.01-10.382h-3.456L12.04 19.17H5.113z","fill":"currentColor"}]}],["$","span",null,{"className":"min-w-0 break-all text-xs font-medium","children":"lucide-react"}]]}]}]]}],["$","$L4e",null,{"namespace":"@ilinxa","registryDependencies":["button","context-menu","dialog","dropdown-menu","input","separator","skeleton","tooltip"]}]]}],null]}],["$","$L4f",null,{"files":[{"path":"src/registry/components/media/pdf-viewer/pdf-viewer.tsx","content":"$50","type":"registry:component","target":"components/pdf-viewer/pdf-viewer.tsx"},{"path":"src/registry/components/media/pdf-viewer/index.ts","content":"export { PdfViewer, default } from \"./pdf-viewer\";\n\n// Toolbar parts (reads viewer context internally)\nexport { PdfToolbar } from \"./parts/pdf-toolbar\";\nexport { PdfPageNav } from \"./parts/pdf-page-nav\";\nexport { PdfPageIndicator } from \"./parts/pdf-page-indicator\";\nexport { PdfZoomControls } from \"./parts/pdf-zoom-controls\";\nexport { PdfActionMenu } from \"./parts/pdf-action-menu\";\n\n// Public hook for advanced consumers building bespoke chrome\nexport { usePdfViewer } from \"./hooks/use-pdf-viewer-context\";\n\n// Defaults\nexport { DEFAULT_PDF_VIEWER_LABELS } from \"./types\";\n\nexport type {\n PdfSource,\n PdfInitialScale,\n PdfRotation,\n PdfFitMode,\n PdfVirtualizeMode,\n PdfStatus,\n PdfActions,\n PdfDocumentState,\n PdfToolbarContext,\n PdfContextMenuContext,\n PdfPasswordPromptContext,\n PdfViewerHandle,\n PdfViewerLabels,\n PdfViewerProps,\n} from \"./types\";\n","type":"registry:component","target":"components/pdf-viewer/index.ts"},{"path":"src/registry/components/media/pdf-viewer/types.ts","content":"$51","type":"registry:component","target":"components/pdf-viewer/types.ts"},{"path":"src/registry/components/media/pdf-viewer/hooks/use-pdf-viewer-context.ts","content":"\"use client\";\n\nimport { createContext, useContext } from \"react\";\nimport type { PDFDocumentProxy } from \"pdfjs-dist\";\nimport type {\n PdfActions,\n PdfDocumentState,\n ResolvedPdfViewerLabels,\n} from \"../types\";\n\nexport interface PdfViewerContextValue extends PdfDocumentState {\n actions: PdfActions;\n labels: ResolvedPdfViewerLabels;\n allowDownload: boolean;\n allowPrint: boolean;\n compact: boolean;\n pdfDocument: PDFDocumentProxy | null;\n}\n\nexport const PdfViewerContext = createContext(\n null,\n);\n\nexport function usePdfViewer(): PdfViewerContextValue {\n const ctx = useContext(PdfViewerContext);\n if (ctx == null) {\n throw new Error(\n \"usePdfViewer must be used inside . \" +\n \"Toolbar parts (PdfPageNav, PdfZoomControls, etc.) read state from \" +\n \"the viewer context and only work as descendants of .\",\n );\n }\n return ctx;\n}\n","type":"registry:component","target":"components/pdf-viewer/hooks/use-pdf-viewer-context.ts"},{"path":"src/registry/components/media/pdf-viewer/hooks/use-pdf-document.ts","content":"$52","type":"registry:component","target":"components/pdf-viewer/hooks/use-pdf-document.ts"},{"path":"src/registry/components/media/pdf-viewer/hooks/use-pdf-zoom.ts","content":"$53","type":"registry:component","target":"components/pdf-viewer/hooks/use-pdf-zoom.ts"},{"path":"src/registry/components/media/pdf-viewer/hooks/use-pdf-page-tracker.ts","content":"$54","type":"registry:component","target":"components/pdf-viewer/hooks/use-pdf-page-tracker.ts"},{"path":"src/registry/components/media/pdf-viewer/hooks/use-pdf-virtualization.ts","content":"$55","type":"registry:component","target":"components/pdf-viewer/hooks/use-pdf-virtualization.ts"},{"path":"src/registry/components/media/pdf-viewer/hooks/use-pdf-keyboard.ts","content":"$56","type":"registry:component","target":"components/pdf-viewer/hooks/use-pdf-keyboard.ts"},{"path":"src/registry/components/media/pdf-viewer/hooks/use-pdf-drop.ts","content":"$57","type":"registry:component","target":"components/pdf-viewer/hooks/use-pdf-drop.ts"},{"path":"src/registry/components/media/pdf-viewer/hooks/use-pdf-selection.ts","content":"$58","type":"registry:component","target":"components/pdf-viewer/hooks/use-pdf-selection.ts"},{"path":"src/registry/components/media/pdf-viewer/hooks/use-pdf-print.ts","content":"$59","type":"registry:component","target":"components/pdf-viewer/hooks/use-pdf-print.ts"},{"path":"src/registry/components/media/pdf-viewer/lib/clamp-scale.ts","content":"export const PDF_VIEWER_MIN_SCALE = 0.25;\nexport const PDF_VIEWER_MAX_SCALE = 5;\nexport const PDF_VIEWER_ZOOM_STEP = 1.2;\n\nexport function clampScale(scale: number): number {\n if (Number.isNaN(scale) || !Number.isFinite(scale)) return 1;\n return Math.max(PDF_VIEWER_MIN_SCALE, Math.min(PDF_VIEWER_MAX_SCALE, scale));\n}\n\nexport function nextZoomIn(scale: number): number {\n return clampScale(scale * PDF_VIEWER_ZOOM_STEP);\n}\n\nexport function nextZoomOut(scale: number): number {\n return clampScale(scale / PDF_VIEWER_ZOOM_STEP);\n}\n","type":"registry:component","target":"components/pdf-viewer/lib/clamp-scale.ts"},{"path":"src/registry/components/media/pdf-viewer/lib/compute-fit-scale.ts","content":"$5a","type":"registry:component","target":"components/pdf-viewer/lib/compute-fit-scale.ts"},{"path":"src/registry/components/media/pdf-viewer/lib/normalize-source.ts","content":"$5b","type":"registry:component","target":"components/pdf-viewer/lib/normalize-source.ts"},{"path":"src/registry/components/media/pdf-viewer/lib/download.ts","content":"$5c","type":"registry:component","target":"components/pdf-viewer/lib/download.ts"},{"path":"src/registry/components/media/pdf-viewer/lib/worker-config.ts","content":"import { pdfjs } from \"react-pdf\";\n\nlet appliedSrc: string | null = null;\n\n/**\n * pdf.js's Web Worker. Default: load from the unpkg CDN at the same version\n * react-pdf bundles (`pdfjs.version` is set by react-pdf at module init).\n *\n * For offline-first apps, copy `pdfjs-dist/build/pdf.worker.min.mjs` into\n * your `public/` directory at build time and pass that path via the\n * `workerSrc` prop, e.g. ``.\n *\n * The CDN default keeps the component drop-in without bundler-specific asset\n * imports (which vary across Webpack 5 / Turbopack / Vite / older bundlers).\n */\nfunction defaultWorkerSrc(): string {\n return `https://unpkg.com/pdfjs-dist@${pdfjs.version}/build/pdf.worker.min.mjs`;\n}\n\nexport function ensureWorkerConfigured(override?: string): void {\n const desired = override ?? defaultWorkerSrc();\n if (appliedSrc !== desired) {\n pdfjs.GlobalWorkerOptions.workerSrc = desired;\n appliedSrc = desired;\n }\n}\n","type":"registry:component","target":"components/pdf-viewer/lib/worker-config.ts"},{"path":"src/registry/components/media/pdf-viewer/parts/pdf-page.tsx","content":"$5d","type":"registry:component","target":"components/pdf-viewer/parts/pdf-page.tsx"},{"path":"src/registry/components/media/pdf-viewer/parts/pdf-toolbar.tsx","content":"$5e","type":"registry:component","target":"components/pdf-viewer/parts/pdf-toolbar.tsx"},{"path":"src/registry/components/media/pdf-viewer/parts/pdf-page-nav.tsx","content":"$5f","type":"registry:component","target":"components/pdf-viewer/parts/pdf-page-nav.tsx"},{"path":"src/registry/components/media/pdf-viewer/parts/pdf-page-indicator.tsx","content":"$60","type":"registry:component","target":"components/pdf-viewer/parts/pdf-page-indicator.tsx"},{"path":"src/registry/components/media/pdf-viewer/parts/pdf-zoom-controls.tsx","content":"$61","type":"registry:component","target":"components/pdf-viewer/parts/pdf-zoom-controls.tsx"},{"path":"src/registry/components/media/pdf-viewer/parts/pdf-action-menu.tsx","content":"$62","type":"registry:component","target":"components/pdf-viewer/parts/pdf-action-menu.tsx"},{"path":"src/registry/components/media/pdf-viewer/parts/pdf-context-menu.tsx","content":"$63","type":"registry:component","target":"components/pdf-viewer/parts/pdf-context-menu.tsx"},{"path":"src/registry/components/media/pdf-viewer/parts/pdf-password-prompt.tsx","content":"$64","type":"registry:component","target":"components/pdf-viewer/parts/pdf-password-prompt.tsx"},{"path":"src/registry/components/media/pdf-viewer/parts/pdf-drop-overlay.tsx","content":"\"use client\";\n\nimport { Upload } from \"lucide-react\";\nimport { cn } from \"@/lib/utils\";\nimport type { ResolvedPdfViewerLabels } from \"../types\";\n\ninterface PdfDropOverlayProps {\n labels: ResolvedPdfViewerLabels;\n className?: string;\n}\n\nexport function PdfDropOverlay({ labels, className }: PdfDropOverlayProps) {\n return (\n \n

\n \n \n {labels.dropPdfHere}\n \n

\n );\n}\n","type":"registry:component","target":"components/pdf-viewer/parts/pdf-drop-overlay.tsx"},{"path":"src/registry/components/media/pdf-viewer/parts/pdf-empty-state.tsx","content":"\"use client\";\n\nimport { FileText } from \"lucide-react\";\nimport { cn } from \"@/lib/utils\";\nimport type { ResolvedPdfViewerLabels } from \"../types\";\n\ninterface PdfEmptyStateProps {\n labels: ResolvedPdfViewerLabels;\n enableDragDrop: boolean;\n className?: string;\n}\n\nexport function PdfEmptyState({\n labels,\n enableDragDrop,\n className,\n}: PdfEmptyStateProps) {\n return (\n \n

\n \n

\n {labels.emptyTitle}\n

\n {enableDragDrop ? (\n

{labels.emptyHint}

\n ) : null}\n

\n \n );\n}\n","type":"registry:component","target":"components/pdf-viewer/parts/pdf-empty-state.tsx"},{"path":"src/registry/components/media/pdf-viewer/parts/pdf-error-state.tsx","content":"$65","type":"registry:component","target":"components/pdf-viewer/parts/pdf-error-state.tsx"},{"path":"src/registry/components/media/pdf-viewer/parts/pdf-loading-state.tsx","content":"\"use client\";\n\nimport { Skeleton } from \"@/components/ui/skeleton\";\nimport { cn } from \"@/lib/utils\";\nimport type { ResolvedPdfViewerLabels } from \"../types\";\n\ninterface PdfLoadingStateProps {\n labels: ResolvedPdfViewerLabels;\n className?: string;\n}\n\nexport function PdfLoadingState({ labels, className }: PdfLoadingStateProps) {\n return (\n \n {labels.loading}\n \n \n \n );\n}\n","type":"registry:component","target":"components/pdf-viewer/parts/pdf-loading-state.tsx"}],"className":"h-[70svh] min-h-80"}]]}]