@vue-pdf-viewer/viewer 4.4.0 → 4.5.0-beta.0

package/dist/license.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./VPdfViewer.vue_vue_type_style_index_1_scoped_1bbfb09f_lang-tQybRRWM.cjs");exports.LicenseProduct=e.L;exports.LicenseType=e.a;exports.useLicense=e.u;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./VPdfViewer.vue_vue_type_style_index_1_scoped_268656f1_lang-BK2suzT0.cjs");exports.LicenseProduct=e.P;exports.LicenseType=e.Q;exports.useLicense=e.b3;

package/dist/license.js

@@ -1,6 +1,6 @@
-import { L as a, a as c, u as L } from "./VPdfViewer.vue_vue_type_style_index_1_scoped_1bbfb09f_lang-Db2k8vVi.js";
+import { P as c, Q as a, b3 as i } from "./VPdfViewer.vue_vue_type_style_index_1_scoped_268656f1_lang-B6dm5SQl.js";
 export {
-  a as LicenseProduct,
-  c as LicenseType,
-  L as useLicense
+  c as LicenseProduct,
+  a as LicenseType,
+  i as useLicense
 };

package/dist/types/components/VPdfPage.vue.d.ts

@@ -3,7 +3,12 @@ import type { PDFDocumentProxy } from 'pdfjs-dist';
 import type { CanvasLoadedCallback, AnnotationEventPayload, HighlightEventPayload, HighlightOptions, MatchValue, TextLayerLoadedEventPayload, TextHighlight, CanvasRenderedEventPayload, VisibleArea } from '../utils/types';
 interface BaseProps {
     pageIndex: number;
-    page: PDFPageProxy;
+    /**
+     * `null` while this page's dimensions are still estimated. The component then renders
+     * a correctly sized shell (`.vpv-page` + loader) and mounts no layers, so geometry is
+     * identical to a real page and the scoped `.vpv-page` styles still apply.
+     */
+    page: PDFPageProxy | null;
     viewport: PageViewport;
     document: PDFDocumentProxy;
     afterCanvasLoaded?: CanvasLoadedCallback;

package/dist/types/composables/useLazyPageFetch.d.ts

@@ -0,0 +1,40 @@
+import { type Ref, type ShallowRef } from 'vue';
+import type { PDFDocumentProxy } from 'pdfjs-dist';
+import type { PDFPageProxy } from 'pdfjs-dist/types/web/interfaces';
+import type { ViewerPdfPage } from '@/utils/types';
+/**
+ * pdf.js skips eager page initialisation past this size; beyond it, firing N getPage()
+ * calls costs more than it saves and pages are fetched purely on demand.
+ */
+declare const FORCE_LAZY_PAGE_INIT = 5000;
+export interface LazyFetchState {
+    isActive: boolean;
+    fetchedCount: number;
+    totalPages: number;
+    isComplete: boolean;
+}
+export interface UseLazyPageFetchOptions {
+    rotation: Ref<number>;
+}
+export interface UseLazyPageFetchReturn {
+    ensurePageLoaded: (pageIndex: number) => Promise<PDFPageProxy | null>;
+    startEagerFetch: () => Promise<void>;
+    /** Retry pages whose fetch failed; called when the network comes back. */
+    retryFailedPages: () => void;
+    fetchState: Ref<LazyFetchState>;
+}
+/**
+ * Background and on-demand page fetching for documents whose dimensions started as
+ * estimates.
+ *
+ * Owns three jobs:
+ * - eager background fetch of pages 2..N, batched per animation frame
+ * - on-demand fetch when the viewport (or a thumbnail) reaches an estimated page
+ * - retry of pages whose fetch failed, including when connectivity returns
+ *
+ * Entries are corrected in place; a single shallow replacement per batch keeps the
+ * reactivity cost independent of batch size.
+ */
+export declare function useLazyPageFetch(pdfDocument: ShallowRef<PDFDocumentProxy | undefined>, pdfPages: ShallowRef<ViewerPdfPage[]>, options: UseLazyPageFetchOptions): UseLazyPageFetchReturn;
+export { FORCE_LAZY_PAGE_INIT };
+export default useLazyPageFetch;

package/dist/types/composables/useNetworkRecovery.d.ts

@@ -0,0 +1,24 @@
+import { type Ref } from 'vue';
+import type { PDFDocumentProxy } from 'pdfjs-dist';
+interface UseNetworkRecoveryOptions {
+    /** Open the same source again in a new loading task. Returns false if it cannot. */
+    reopen: () => boolean;
+    /** A reopen failed and is waiting to run again; there is no document meanwhile. */
+    isReopenPending: () => boolean;
+    /** Retry the pages whose fetch failed, in the current document. */
+    retryFailedPages: () => void;
+}
+/**
+ * Bring pages back after the network returns from an offline period.
+ *
+ * pdf.js cannot recover from a failed range request in the same document: its worker keeps
+ * the chunks of the failed request marked as requested (`ChunkedStreamManager._requestsByChunk`
+ * is only cleared when data arrives), so every later read of them waits forever, and the
+ * main thread caches the rejected `getPage()` promise. Pages that failed while offline
+ * therefore stay blank, and retrying them sends nothing (VPV-2590). Until pdf.js handles
+ * this, the only way back is a new loading task for the same source.
+ *
+ * The reopen is skipped once the whole file is in memory, since nothing can fail after that.
+ */
+declare function useNetworkRecovery(pdfDocument: Ref<PDFDocumentProxy | undefined>, { reopen, isReopenPending, retryFailedPages }: UseNetworkRecoveryOptions): void;
+export default useNetworkRecovery;

package/dist/types/composables/usePdf.d.ts

@@ -2,8 +2,27 @@ import type { MaybeRef } from 'vue';
 import { type PDFOptions, type PDFSrc, type PDFDocumentOptions } from '../utils/types';
 import { type PDFDocumentProxy, type PDFPageProxy } from 'pdfjs-dist/types/src/display/api';
 export declare function configWorker(workerSrc?: string, legacy?: boolean): void;
+/**
+ * @typedef {Object} UsePDFParameters
+ * @property {string} password
+ * Document password to unlock content
+ * @property {function} onProgress
+ * Callback to request a password if a wrong or no password was provided. The callback receives two parameters: a function that should be called with the new password, and a reason (see PasswordResponses).
+ * @property {function} onPassword
+ * Callback to be able to monitor the loading progress of the PDF file (necessary to implement e.g. a loading bar). The callback receives an OnProgressParameters argument. if this function is used option.password is ignored
+ * @property {function} onError
+ * Callback to be able to handle errors during loading
+ * */
+/**
+ *
+ * @param {string | URL | TypedArray | PDFDataRangeTransport | DocumentInitParameters} src
+ * Can be a URL where a PDF file is located, a typed array (Uint8Array) already populated with data, or a parameter object.
+ * @param {UsePDFParameters} options
+ * UsePDF object parameters
+ */
 declare function usePdf(src: MaybeRef<PDFSrc>, options?: PDFOptions, workerUrl?: string, documentOptions?: PDFDocumentOptions, wasmUrl?: string): {
     pdfDocLoadingTask: import("vue").ShallowRef<import("pdfjs-dist/types/src/display/api").PDFDocumentLoadingTask | undefined, import("pdfjs-dist/types/src/display/api").PDFDocumentLoadingTask | undefined>;
     getPage: (doc: PDFDocumentProxy, pageIndex: number) => Promise<PDFPageProxy>;
+    reload: () => boolean;
 };
 export default usePdf;

package/dist/types/composables/usePdfActualPages.d.ts

@@ -1,5 +1,20 @@
-import { Reactive } from 'vue';
-import { ViewerPdfPage, ViewerState } from '@/utils/types';
+import { Reactive, Ref } from 'vue';
+import { PDFSrc, ViewerPdfPage, ViewerState } from '@/utils/types';
+/**
+ * Whether a source can be laid out from estimated dimensions.
+ *
+ * Only sources pdf.js fetches incrementally benefit: page 1's metadata can resolve long
+ * before the rest of the file arrives. In-memory sources already hold every byte, so
+ * estimating would add a correction pass for no gain.
+ */
+export declare function isLazyLoadingEligible(source: PDFSrc | undefined): boolean;
+/**
+ * Normalizes rotation to be a valid multiple of 90 degrees between 0-360.
+ *
+ * @param rotation - Rotation angle in degrees
+ * @returns Normalized rotation (0, 90, 180, or 270), or 0 if invalid
+ */
+export declare function normalizeRotation(rotation: number): number;
 /**
  * Composable for managing PDF pages at base scale (100%).
  *
@@ -12,10 +27,12 @@ import { ViewerPdfPage, ViewerState } from '@/utils/types';
  * @param props - The viewer state containing PDF document and rotation settings
  * @returns Object containing pdfPages (all pages) and filteredPages (view-mode filtered)
  */
-declare function usePdfActualPages(props: Reactive<ViewerState>): {
+declare function usePdfActualPages(props: Reactive<ViewerState>, source?: Ref<PDFSrc | undefined>): {
     /** All pages at base scale (100%) */
     pdfPages: import("vue").ShallowRef<ViewerPdfPage[], ViewerPdfPage[]>;
     /** Pages filtered by view mode (for page scroll mode) */
     filteredPages: import("vue").ComputedRef<ViewerPdfPage[]>;
+    /** True while this document is laid out from page-1 estimates */
+    isLazyMode: import("vue").ShallowRef<boolean, boolean>;
 };
 export default usePdfActualPages;

package/dist/types/composables/usePlugins.d.ts

@@ -1,7 +1,7 @@
 import { ComputedRef, type Reactive, type ComponentInternalInstance, type Ref } from 'vue';
 import { type Localization, type PluginItem, type Plugin } from '@vue-pdf-viewer/shared';
 import type { PDFDocumentProxy } from 'pdfjs-dist';
-declare const usePlugins: (instance: ComponentInternalInstance, plugins?: Reactive<Plugin<PDFDocumentProxy>[]>, viewerLocalization?: ComputedRef<Localization>, pdfDocument?: Ref<PDFDocumentProxy | undefined>, originalPdfBytes?: Ref<Uint8Array | null>) => {
+declare const usePlugins: (instance: ComponentInternalInstance, plugins?: Reactive<Plugin<PDFDocumentProxy>[]>, viewerLocalization?: ComputedRef<Localization>, pdfDocument?: Ref<PDFDocumentProxy | undefined>, getOriginalPdfBytes?: () => Promise<Uint8Array | null>) => {
     sidebarItems: Ref<PluginItem[]>;
     annotationMounted: Ref<boolean>;
 };

package/dist/types/composables/useSearch.d.ts

@@ -1,5 +1,5 @@
-import { ShallowRef } from 'vue';
+import { Ref, ShallowRef } from 'vue';
 import type { PDFDocumentProxy } from 'pdfjs-dist';
 import type { SearchControlValue, HighlightOptions } from '@/utils/types';
-declare const useSearch: (pdfDoc: ShallowRef<PDFDocumentProxy | undefined>, initialSearch?: string, options?: ShallowRef<HighlightOptions>) => SearchControlValue;
+declare const useSearch: (pdfDoc: ShallowRef<PDFDocumentProxy | undefined>, initialSearch?: string, options?: ShallowRef<HighlightOptions>, currentPage?: Ref<number>) => SearchControlValue;
 export default useSearch;

package/dist/types/composables/useVirtualPages.d.ts

@@ -39,6 +39,12 @@ export interface UseVirtualListReturn {
      * until the scroll animation settles.
      */
     isScrollSettling: Ref<boolean>;
+    /**
+     * True while a programmatic navigation is still converging on its target page, which
+     * only happens while the document holds estimated dimensions. The viewer shows a loader
+     * instead of pages during this, so intermediate positions are never displayed.
+     */
+    isNavigationSettling: Ref<boolean>;
 }
 interface UseVirtualPagesProps {
     pages: Ref<ViewerPdfPage[]>;
@@ -54,6 +60,11 @@ interface UseVirtualPagesProps {
     cancelAllRenders?: () => void;
     reprioritizeCurrentPage?: () => void;
     pageRotationMap?: Ref<Map<number, number>>;
+    /**
+     * Requests real page data for a page still laid out from an estimate.
+     * Fire-and-forget: it never rejects, and the page corrects itself when it resolves.
+     */
+    ensurePageLoaded?: (pageIndex: number) => Promise<unknown>;
 }
 /**
  * Composable for virtual scrolling of PDF pages with support for multiple view modes.

package/dist/types/const.d.ts

@@ -66,6 +66,12 @@ export declare const EMPTY_KEYWORD_REGEXP: NormalizedKeyword;
 export declare const CURRENT_MATCH_CSS_CLASS = "vpv-highlight__text-current";
 export declare const LATEST_MATCH_POSITION: InjectionKey<Ref<HighlightMatchPosition | undefined, HighlightMatchPosition | undefined>>;
 export declare const GET_PAGE: InjectionKey<(doc: PDFDocumentProxy, pageIndex: number) => Promise<PDFPageProxy>>;
+/**
+ * Requests real page data for a page still laid out from an estimate.
+ * Provided by VPdfViewer so surfaces outside the main scroll area — the thumbnail rail,
+ * for one — can resolve the pages they show.
+ */
+export declare const ENSURE_PAGE_LOADED: InjectionKey<(pageIndex: number) => Promise<unknown>>;
 export declare const RESTRICTED_CUSTOM: InjectionKey<Ref<boolean, boolean>>;
 export declare const VIEWER_STATE: InjectionKey<{
     pdfDocument: {

package/dist/types/utils/boundedConcurrency.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Runs `task` over `items` with at most `limit` tasks in flight, starting them in item order.
+ *
+ * Exists for background work against the pdf.js worker. pdf.js answers requests in the order
+ * they arrive and caches page promises, so a request issued early cannot be overtaken later.
+ * Issuing a whole document's worth at once therefore puts anything the reader asks for next —
+ * the page they navigated to, the page being rendered — behind all of it. Keeping only a few
+ * in flight bounds that wait to `limit` requests.
+ *
+ * Results come back in item order. A task that rejects rejects the whole run, like
+ * `Promise.all`, and no further tasks start — otherwise the remaining lanes would keep the
+ * worker busy with results nobody reads. Once `shouldStop` returns true no further tasks
+ * start either; the ones already running finish, and the skipped slots are left `undefined`.
+ */
+export declare function mapWithConcurrency<T, R>(items: readonly T[], limit: number, task: (item: T, index: number) => Promise<R>, shouldStop?: () => boolean): Promise<Array<R | undefined>>;

package/dist/types/utils/documentLayout.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Pure layout arithmetic for the virtualised page list.
+ *
+ * `useVirtualPages` stacks pages as plain numbers — the unrendered ones never become DOM —
+ * so everything about where a page sits reduces to running totals over a size array. That
+ * arithmetic lives here so it can be tested directly, and so the scroll-anchoring rules
+ * are stated in one place rather than inline among the scroll handlers.
+ *
+ * Naming follows the React PDF Kit `documentLayout` module, which models the same problem.
+ */
+/** A position in the document expressed relative to content rather than pixels. */
+export interface LayoutAnchor {
+    /** Index of the stacking unit (page, row, or column) under the viewport's leading edge. */
+    index: number;
+    /** Distance into that unit, in BASE-SCALE units so the anchor survives zoom. */
+    offset: number;
+}
+/**
+ * Running totals of `sizes`, where entry i is the offset of the END of unit i.
+ * The start of unit i is therefore `totals[i - 1]`, or 0 for the first unit.
+ */
+export declare function buildCumulativeTotals(sizes: number[]): number[];
+/**
+ * Index of the unit containing `position`.
+ *
+ * Binary search over the running totals. A position past the end clamps to the last unit
+ * rather than returning -1, so a scroll beyond the content still anchors to real content.
+ */
+export declare function findUnitAtOffset(totals: number[], position: number): number;
+/** Offset at which unit `index` starts. */
+export declare function getUnitStart(totals: number[], index: number): number;
+/**
+ * Converts a pixel scroll position into a content anchor.
+ *
+ * Dividing by the scale is what makes the anchor survive zoom: the same anchor resolves
+ * correctly at any later scale.
+ */
+export declare function captureLayoutAnchor(totals: number[], position: number, scale: number): LayoutAnchor;
+/**
+ * Converts a content anchor back into a pixel scroll position against the CURRENT totals.
+ *
+ * This is the step that absorbs a dimension correction: the unit index still identifies
+ * the same content, and its start has moved to wherever the corrected sizes put it.
+ * Returns null when there is no layout to resolve against.
+ */
+export declare function resolveLayoutAnchor(totals: number[], anchor: LayoutAnchor, scale: number): number | null;
+/** Minimum a page contributes to wrapped packing: its size at base scale. */
+export interface WrappedPageSize {
+    width: number;
+    height: number;
+}
+/** Rows produced by wrapping pages across a container of a given width. */
+export interface WrappedRows {
+    /** Height of each row: the tallest page in it, at the given scale. */
+    rowHeights: number[];
+    /** Accumulated width of each row at the given scale. */
+    rowWidths: number[];
+    /** Row index each page sits in, by page index. */
+    rowOfPage: number[];
+    /** First page index of each row, by row index. */
+    rowStartPage: number[];
+}
+/**
+ * Packs pages into rows the way the wrapped scroll mode lays them out.
+ *
+ * Rows are filled until the next page would overflow `clientWidth`, so a row holds as many
+ * pages as happen to fit — one for a wide page, several for narrow ones. The page-to-row
+ * mapping is therefore recorded here rather than derived later from an average page count
+ * per row, which is only correct when every page has the same width.
+ */
+export declare function packWrappedRows(pages: WrappedPageSize[], clientWidth: number, scale: number): WrappedRows;
+/** Page index one past the last page of `row`. */
+export declare function getRowEndPage(rowStartPage: number[], row: number, totalPages: number): number;

package/dist/types/utils/highlight.d.ts

@@ -4,6 +4,16 @@ interface MatchWithLines extends Match {
     lines?: any[];
 }
 declare function isMatchEntireWord(content: string, startIdx: number, length: number): boolean;
+/**
+ * Flattens a page's text content into the single string searches run against.
+ *
+ * Exported so callers can cache the string per page and re-run queries without holding
+ * on to the much larger `TextContent` object. Matching must use *this* string, or the
+ * offsets `convertMatches` relies on would not line up.
+ */
+declare function buildSearchText(textContent: TextContent): string;
+/** True if the query occurs at least once in a page string built by `buildSearchText`. */
+declare function hasSearchMatch(text: string, query: string | RegExp, options: HighlightOptions): boolean;
 declare function highlightMatches(matches: Match[], textContent: TextContent, textDivs: HTMLElement[]): void;
 /**
  * Appends highlights without removing existing ones.
@@ -13,4 +23,4 @@ declare function appendHighlightMatches(matches: Match[], textDivs: HTMLElement[
 declare function resetDivs(textContent: TextContent, textDivs: HTMLElement[]): void;
 declare function findMatches(queries: (string | RegExp)[], textContent: TextContent, pageIndex: number, options: HighlightOptions): MatchWithLines[];
 declare function getHighlightOptionsWithDefaults(options?: HighlightOptions): HighlightOptions;
-export { appendHighlightMatches, findMatches, highlightMatches, resetDivs, getHighlightOptionsWithDefaults, isMatchEntireWord };
+export { appendHighlightMatches, buildSearchText, findMatches, hasSearchMatch, highlightMatches, resetDivs, getHighlightOptionsWithDefaults, isMatchEntireWord };

package/dist/types/utils/searchHighlight.d.ts

@@ -1,10 +1,8 @@
 import type { CSSProperties } from 'vue';
-import type { FlagKeyword, HighlightArea, HighlightMatchPosition, NormalizedKeyword, SingleKeyword } from './types';
+import type { FlagKeyword, HighlightArea, NormalizedKeyword, SingleKeyword } from './types';
 export declare const normalizeFlagKeyword: (flagKeyword: FlagKeyword) => NormalizedKeyword;
 export declare const normalizeSingleKeyword: (keyword: SingleKeyword, matchCase?: boolean, wholeWords?: boolean) => NormalizedKeyword;
 export declare const sortHighlightPosition: (a: HighlightArea, b: HighlightArea) => 0 | 1 | -1;
 export declare const getHighlightStyle: (area: HighlightArea) => CSSProperties;
 export declare const unwrap: (ele: Node) => void;
-export declare const getHighlightElement: (layerRef: HTMLElement, query: HighlightMatchPosition, selector?: string) => HTMLElement;
 export declare const getHighlightElements: (layerRef: HTMLElement, querySelector: string) => Promise<NodeListOf<Element>>;
-export declare function scrollHighlightIntoView(highlightEle: HTMLElement, pageContainer: HTMLElement, viewerContainer: HTMLElement): void;

package/dist/types/utils/types.d.ts

@@ -215,17 +215,31 @@ export interface PdfPageSize {
     pageRect: Rect;
 }
 export interface VPVThumbnail {
-    page: PDFPageProxy;
+    /** `null` while the page is still estimated — the thumbnail shows a placeholder. */
+    page: PDFPageProxy | null;
 }
 export interface Offset {
     left: number;
     top: number;
 }
 export interface ViewerPdfPage {
-    page: PDFPageProxy;
+    /**
+     * The pdf.js page proxy, or `null` while the page's dimensions are still estimated.
+     * NEVER dereference without a guard — use `pageNumber` for identity instead.
+     */
+    page: PDFPageProxy | null;
+    /** 1-based page number. Always present, including for estimated entries. */
+    pageNumber: number;
     viewport: PageViewport;
     height: number;
     width: number;
+    /** True until the real page has been fetched and dimensions corrected. */
+    isEstimated: boolean;
+    /**
+     * Inherent page rotation (0/90/180/270). Estimated entries carry page 1's rotate, the
+     * value baked into their cloned viewport, until the real page arrives.
+     */
+    pdfPageRotate: number;
 }
 export interface ItemMeasurement {
     index: number;
@@ -453,6 +467,8 @@ export interface VPdfViewerProps {
     /**
      * A callback function that will be executed after each canvas is loaded.
      * The key is the page number, and the value is the callback function.
+     * During print the callback receives a single scratch canvas that is reused for the next
+     * page, so draw synchronously and do not retain it.
      */
     afterCanvasLoaded?: Record<number, CanvasLoadedCallback>;
     /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vue-pdf-viewer/viewer",
   "private": false,
-  "version": "4.4.0",
+  "version": "4.5.0-beta.0",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
@@ -80,9 +80,10 @@
     "vue": "^3.2.37"
   },
   "devDependencies": {
-    "@laynezh/vite-plugin-lib-assets": "^0.5.24",
     "@esbuild/darwin-arm64": "0.21.5",
     "@esbuild/darwin-x64": "0.21.5",
+    "@laynezh/vite-plugin-lib-assets": "^0.5.24",
+    "@rollup/rollup-darwin-arm64": "^4.60.4",
     "@rollup/rollup-darwin-x64": "^4.60.1",
     "@types/node": "^20.11.30",
     "@types/node-forge": "^1.3.14",