@vue-pdf-viewer/viewer 1.2.0-rc.0 → 1.3.0-beta.0

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

@@ -1,18 +1,63 @@
-import type { VPdfViewerProps, AnnotationEventPayload, HighlightEventPayload, TextLayerLoadedEventPayload, RotateEvent, ToolbarOptions } from './types';
+import { type AnnotationEventPayload, type HighlightEventPayload, type TextLayerLoadedEventPayload, type RotateEvent, type ToolbarOptions, type Localization } from '@/utils/types';
+import { ScrollMode, ViewMode, ZoomLevel } from '@/utils/enumerators';
 import '../style.scss';
 declare const _default: {
-    new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<VPdfViewerProps>, {
-        textLayer: boolean;
-        initialPage: number;
-        initialRotation: number;
-        intent: string;
-        annotationLayer: boolean;
-        toolbarOptions: () => ToolbarOptions;
-    }>>> & {
-        onHighlight?: ((payload: HighlightEventPayload) => any) | undefined;
-        onTextLoaded?: ((payload: TextLayerLoadedEventPayload) => any) | undefined;
+    new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{
+        readonly src: {
+            readonly type: import("vue").PropType<string | import("@/utils/types").VPVSrc>;
+            readonly required: true;
+        };
+        readonly workerUrl: {
+            readonly type: import("vue").PropType<string>;
+            readonly default: undefined;
+        };
+        readonly initialPage: {
+            readonly type: import("vue").PropType<number>;
+            readonly default: () => number;
+        };
+        readonly initialScale: {
+            readonly type: import("vue").PropType<number | ZoomLevel>;
+            readonly default: () => ZoomLevel;
+        };
+        readonly initialScrollMode: {
+            readonly type: import("vue").PropType<ScrollMode>;
+            readonly default: () => ScrollMode;
+            readonly validator: (initialScrollMode: ScrollMode, args: unknown) => boolean;
+        };
+        readonly initialViewMode: {
+            readonly type: import("vue").PropType<ViewMode>;
+            readonly default: () => ViewMode;
+            readonly validator: (initialViewMode: ViewMode, args: unknown) => boolean;
+        };
+        readonly initialRotation: {
+            readonly type: import("vue").PropType<number>;
+            readonly default: () => number;
+        };
+        readonly initialThumbnailsVisible: {
+            readonly type: import("vue").PropType<boolean>;
+            readonly default: undefined;
+        };
+        readonly textLayer: {
+            readonly type: import("vue").PropType<boolean>;
+            readonly default: () => boolean;
+        };
+        readonly characterMap: {
+            readonly type: import("vue").PropType<import("@/utils/types").CharacterMap>;
+            readonly default: undefined;
+        };
+        readonly toolbarOptions: {
+            readonly type: import("vue").PropType<false | Partial<ToolbarOptions>>;
+            readonly default: () => ToolbarOptions;
+        };
+        readonly localization: {
+            readonly type: import("vue").PropType<Record<string, Localization>>;
+            readonly default: () => Record<string, Localization>;
+        };
+    }>> & {
         onAnnotation?: ((payload: AnnotationEventPayload) => any) | undefined;
         onAnnotationLoaded?: ((payload: any[]) => any) | undefined;
+        onHighlight?: ((payload: HighlightEventPayload) => any) | undefined;
+        onTextLoaded?: ((payload: TextLayerLoadedEventPayload) => any) | undefined;
         onLoaded?: (() => any) | undefined;
         onRotate?: ((payload: RotateEvent) => any) | undefined;
         onLoadProgress?: ((payload: number) => any) | undefined;
@@ -35,27 +80,78 @@ declare const _default: {
         xfaLoaded: () => void;
     } & {
         rotate: (payload: RotateEvent) => void;
-    }, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<VPdfViewerProps>, {
-        textLayer: boolean;
-        initialPage: number;
-        initialRotation: number;
-        intent: string;
-        annotationLayer: boolean;
-        toolbarOptions: () => ToolbarOptions;
-    }>>> & {
-        onHighlight?: ((payload: HighlightEventPayload) => any) | undefined;
-        onTextLoaded?: ((payload: TextLayerLoadedEventPayload) => any) | undefined;
+    }, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
+        readonly src: {
+            readonly type: import("vue").PropType<string | import("@/utils/types").VPVSrc>;
+            readonly required: true;
+        };
+        readonly workerUrl: {
+            readonly type: import("vue").PropType<string>;
+            readonly default: undefined;
+        };
+        readonly initialPage: {
+            readonly type: import("vue").PropType<number>;
+            readonly default: () => number;
+        };
+        readonly initialScale: {
+            readonly type: import("vue").PropType<number | ZoomLevel>;
+            readonly default: () => ZoomLevel;
+        };
+        readonly initialScrollMode: {
+            readonly type: import("vue").PropType<ScrollMode>;
+            readonly default: () => ScrollMode;
+            readonly validator: (initialScrollMode: ScrollMode, args: unknown) => boolean;
+        };
+        readonly initialViewMode: {
+            readonly type: import("vue").PropType<ViewMode>;
+            readonly default: () => ViewMode;
+            readonly validator: (initialViewMode: ViewMode, args: unknown) => boolean;
+        };
+        readonly initialRotation: {
+            readonly type: import("vue").PropType<number>;
+            readonly default: () => number;
+        };
+        readonly initialThumbnailsVisible: {
+            readonly type: import("vue").PropType<boolean>;
+            readonly default: undefined;
+        };
+        readonly textLayer: {
+            readonly type: import("vue").PropType<boolean>;
+            readonly default: () => boolean;
+        };
+        readonly characterMap: {
+            readonly type: import("vue").PropType<import("@/utils/types").CharacterMap>;
+            readonly default: undefined;
+        };
+        readonly toolbarOptions: {
+            readonly type: import("vue").PropType<false | Partial<ToolbarOptions>>;
+            readonly default: () => ToolbarOptions;
+        };
+        readonly localization: {
+            readonly type: import("vue").PropType<Record<string, Localization>>;
+            readonly default: () => Record<string, Localization>;
+        };
+    }>> & {
         onAnnotation?: ((payload: AnnotationEventPayload) => any) | undefined;
         onAnnotationLoaded?: ((payload: any[]) => any) | undefined;
+        onHighlight?: ((payload: HighlightEventPayload) => any) | undefined;
+        onTextLoaded?: ((payload: TextLayerLoadedEventPayload) => any) | undefined;
         onLoaded?: (() => any) | undefined;
         onRotate?: ((payload: RotateEvent) => any) | undefined;
         onLoadProgress?: ((payload: number) => any) | undefined;
         onXfaLoaded?: (() => any) | undefined;
     }, {
-        initialPage: number;
-        initialRotation: number;
-        textLayer: boolean;
-        toolbarOptions: false | Partial<ToolbarOptions>;
+        readonly initialViewMode: ViewMode;
+        readonly initialScrollMode: ScrollMode;
+        readonly workerUrl: string;
+        readonly initialPage: number;
+        readonly initialScale: number | ZoomLevel;
+        readonly initialRotation: number;
+        readonly initialThumbnailsVisible: boolean;
+        readonly textLayer: boolean;
+        readonly characterMap: import("@/utils/types").CharacterMap;
+        readonly toolbarOptions: false | Partial<ToolbarOptions>;
+        readonly localization: Record<string, Localization>;
     }, true, {}, {}, {
         P: {};
         B: {};
@@ -63,18 +159,62 @@ declare const _default: {
         C: {};
         M: {};
         Defaults: {};
-    }, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<VPdfViewerProps>, {
-        textLayer: boolean;
-        initialPage: number;
-        initialRotation: number;
-        intent: string;
-        annotationLayer: boolean;
-        toolbarOptions: () => ToolbarOptions;
-    }>>> & {
-        onHighlight?: ((payload: HighlightEventPayload) => any) | undefined;
-        onTextLoaded?: ((payload: TextLayerLoadedEventPayload) => any) | undefined;
+    }, Readonly<import("vue").ExtractPropTypes<{
+        readonly src: {
+            readonly type: import("vue").PropType<string | import("@/utils/types").VPVSrc>;
+            readonly required: true;
+        };
+        readonly workerUrl: {
+            readonly type: import("vue").PropType<string>;
+            readonly default: undefined;
+        };
+        readonly initialPage: {
+            readonly type: import("vue").PropType<number>;
+            readonly default: () => number;
+        };
+        readonly initialScale: {
+            readonly type: import("vue").PropType<number | ZoomLevel>;
+            readonly default: () => ZoomLevel;
+        };
+        readonly initialScrollMode: {
+            readonly type: import("vue").PropType<ScrollMode>;
+            readonly default: () => ScrollMode;
+            readonly validator: (initialScrollMode: ScrollMode, args: unknown) => boolean;
+        };
+        readonly initialViewMode: {
+            readonly type: import("vue").PropType<ViewMode>;
+            readonly default: () => ViewMode;
+            readonly validator: (initialViewMode: ViewMode, args: unknown) => boolean;
+        };
+        readonly initialRotation: {
+            readonly type: import("vue").PropType<number>;
+            readonly default: () => number;
+        };
+        readonly initialThumbnailsVisible: {
+            readonly type: import("vue").PropType<boolean>;
+            readonly default: undefined;
+        };
+        readonly textLayer: {
+            readonly type: import("vue").PropType<boolean>;
+            readonly default: () => boolean;
+        };
+        readonly characterMap: {
+            readonly type: import("vue").PropType<import("@/utils/types").CharacterMap>;
+            readonly default: undefined;
+        };
+        readonly toolbarOptions: {
+            readonly type: import("vue").PropType<false | Partial<ToolbarOptions>>;
+            readonly default: () => ToolbarOptions;
+        };
+        readonly localization: {
+            readonly type: import("vue").PropType<Record<string, Localization>>;
+            readonly default: () => Record<string, Localization>;
+        };
+    }>> & {
         onAnnotation?: ((payload: AnnotationEventPayload) => any) | undefined;
         onAnnotationLoaded?: ((payload: any[]) => any) | undefined;
+        onHighlight?: ((payload: HighlightEventPayload) => any) | undefined;
+        onTextLoaded?: ((payload: TextLayerLoadedEventPayload) => any) | undefined;
         onLoaded?: (() => any) | undefined;
         onRotate?: ((payload: RotateEvent) => any) | undefined;
         onLoadProgress?: ((payload: number) => any) | undefined;
@@ -82,26 +222,77 @@ declare const _default: {
     }, {
         goToPage: (page: number) => void;
     }, {}, {}, {}, {
-        initialPage: number;
-        initialRotation: number;
-        textLayer: boolean;
-        toolbarOptions: false | Partial<ToolbarOptions>;
+        readonly initialViewMode: ViewMode;
+        readonly initialScrollMode: ScrollMode;
+        readonly workerUrl: string;
+        readonly initialPage: number;
+        readonly initialScale: number | ZoomLevel;
+        readonly initialRotation: number;
+        readonly initialThumbnailsVisible: boolean;
+        readonly textLayer: boolean;
+        readonly characterMap: import("@/utils/types").CharacterMap;
+        readonly toolbarOptions: false | Partial<ToolbarOptions>;
+        readonly localization: Record<string, Localization>;
     }>;
     __isFragment?: undefined;
     __isTeleport?: undefined;
     __isSuspense?: undefined;
-} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<VPdfViewerProps>, {
-    textLayer: boolean;
-    initialPage: number;
-    initialRotation: number;
-    intent: string;
-    annotationLayer: boolean;
-    toolbarOptions: () => ToolbarOptions;
-}>>> & {
-    onHighlight?: ((payload: HighlightEventPayload) => any) | undefined;
-    onTextLoaded?: ((payload: TextLayerLoadedEventPayload) => any) | undefined;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    readonly src: {
+        readonly type: import("vue").PropType<string | import("@/utils/types").VPVSrc>;
+        readonly required: true;
+    };
+    readonly workerUrl: {
+        readonly type: import("vue").PropType<string>;
+        readonly default: undefined;
+    };
+    readonly initialPage: {
+        readonly type: import("vue").PropType<number>;
+        readonly default: () => number;
+    };
+    readonly initialScale: {
+        readonly type: import("vue").PropType<number | ZoomLevel>;
+        readonly default: () => ZoomLevel;
+    };
+    readonly initialScrollMode: {
+        readonly type: import("vue").PropType<ScrollMode>;
+        readonly default: () => ScrollMode;
+        readonly validator: (initialScrollMode: ScrollMode, args: unknown) => boolean;
+    };
+    readonly initialViewMode: {
+        readonly type: import("vue").PropType<ViewMode>;
+        readonly default: () => ViewMode;
+        readonly validator: (initialViewMode: ViewMode, args: unknown) => boolean;
+    };
+    readonly initialRotation: {
+        readonly type: import("vue").PropType<number>;
+        readonly default: () => number;
+    };
+    readonly initialThumbnailsVisible: {
+        readonly type: import("vue").PropType<boolean>;
+        readonly default: undefined;
+    };
+    readonly textLayer: {
+        readonly type: import("vue").PropType<boolean>;
+        readonly default: () => boolean;
+    };
+    readonly characterMap: {
+        readonly type: import("vue").PropType<import("@/utils/types").CharacterMap>;
+        readonly default: undefined;
+    };
+    readonly toolbarOptions: {
+        readonly type: import("vue").PropType<false | Partial<ToolbarOptions>>;
+        readonly default: () => ToolbarOptions;
+    };
+    readonly localization: {
+        readonly type: import("vue").PropType<Record<string, Localization>>;
+        readonly default: () => Record<string, Localization>;
+    };
+}>> & {
     onAnnotation?: ((payload: AnnotationEventPayload) => any) | undefined;
     onAnnotationLoaded?: ((payload: any[]) => any) | undefined;
+    onHighlight?: ((payload: HighlightEventPayload) => any) | undefined;
+    onTextLoaded?: ((payload: TextLayerLoadedEventPayload) => any) | undefined;
     onLoaded?: (() => any) | undefined;
     onRotate?: ((payload: RotateEvent) => any) | undefined;
     onLoadProgress?: ((payload: number) => any) | undefined;
@@ -125,10 +316,17 @@ declare const _default: {
 } & {
     rotate: (payload: RotateEvent) => void;
 }, string, {
-    initialPage: number;
-    initialRotation: number;
-    textLayer: boolean;
-    toolbarOptions: false | Partial<ToolbarOptions>;
+    readonly initialViewMode: ViewMode;
+    readonly initialScrollMode: ScrollMode;
+    readonly workerUrl: string;
+    readonly initialPage: number;
+    readonly initialScale: number | ZoomLevel;
+    readonly initialRotation: number;
+    readonly initialThumbnailsVisible: boolean;
+    readonly textLayer: boolean;
+    readonly characterMap: import("@/utils/types").CharacterMap;
+    readonly toolbarOptions: false | Partial<ToolbarOptions>;
+    readonly localization: Record<string, Localization>;
 }, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
     $slots: {
         dropFileZone: (_: {
@@ -192,21 +390,13 @@ declare const _default: {
         iconRotateCounterClockwise: (_: {}) => any;
         iconTextSelection: (_: {}) => any;
         iconHandMode: (_: {}) => any;
+        iconScrollingPage: (_: {}) => any;
+        iconScrollingVertical: (_: {}) => any;
+        iconScrollingHorizontal: (_: {}) => any;
+        iconScrollingWrapped: (_: {}) => any;
+        iconPageViewSingle: (_: {}) => any;
+        iconPageViewDual: (_: {}) => any;
         iconDocProperties: (_: {}) => any;
     };
 });
 export default _default;
-type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToRuntimeProps<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? {
-        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
-    } : {
-        type: import('vue').PropType<T[K]>;
-        required: true;
-    };
-};
-type __VLS_WithDefaults<P, D> = {
-    [K in keyof Pick<P, keyof P>]: K extends keyof D ? P[K] & {
-        default: D[K];
-    } : P[K];
-};

package/dist/types/components/index.d.ts

@@ -1,4 +1,5 @@
-export * from './types';
+export * from '../utils/types';
+export * from '../utils/enumerators';
 export * from '../composables/usePDF';
 export * from '../composables/useLicense';
 export { default as VPdfViewer } from './VPdfViewer.vue';

package/dist/types/components/layers/AnnotationLayer.vue.d.ts

@@ -1,4 +1,4 @@
-import type { AnnotationEventPayload } from '../types';
+import type { AnnotationEventPayload } from '../../utils/types';
 declare const _default: import("vue").DefineComponent<__VLS_TypePropsToRuntimeProps<{
     page?: import("pdfjs-dist/types/src/display/api").PDFPageProxy | undefined;
     viewport?: import("pdfjs-dist/types/src/display/display_utils").PageViewport | undefined;

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

@@ -1,15 +1,5 @@
 import type { PDFDocumentProxy } from 'pdfjs-dist';
-import { type AnnotationEventPayload } from '../types';
-export declare enum VPVAnnotationType {
-    INTERNAL_LINK = "internal-link",
-    LINK = "link",
-    FILE_ATTACHMENT = "file-attachment",
-    FORM_TEXT = "form-text",
-    FORM_SELECT = "form-select",
-    FORM_CHECKBOX = "form-checkbox",
-    FORM_RADIO = "form-radio",
-    FORM_BUTTON = "form-button"
-}
+import { type AnnotationEventPayload } from '@/utils/types';
 declare const EVENTS_TO_HANDLER: string[];
 declare function annotationEventsHandler(evt: Event, PDFDoc: PDFDocumentProxy, Annotations: Object[]): AnnotationEventPayload | Promise<AnnotationEventPayload | undefined> | undefined;
 export { EVENTS_TO_HANDLER, annotationEventsHandler };

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

@@ -1,5 +1,5 @@
 import type { PDFDocumentProxy, RefProxy } from 'pdfjs-dist/types/src/display/api';
-import type { PDFLocation } from '../types';
+import type { PDFLocation } from '../../utils/types';
 declare function getDestinationArray(doc: PDFDocumentProxy, dest: string | any[] | null): Promise<any[] | null>;
 declare function getDestinationRef(doc: PDFDocumentProxy, destArray: any[] | null): Promise<RefProxy | null>;
 declare function getLocation(type: string, spec: number[]): PDFLocation | null;

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

@@ -1,5 +1,5 @@
 import type { TextContent } from 'pdfjs-dist/types/src/display/text_layer';
-import type { HighlightOptions, Match } from '../types';
+import type { HighlightOptions, Match } from '../../utils/types';
 declare function highlightMatches(matches: Match[], textContent: TextContent, textDivs: HTMLElement[], className?: string): void;
 declare function resetDivs(textContent: TextContent, textDivs: HTMLElement[]): void;
 declare function findMatches(query: string, textContent: TextContent, options: HighlightOptions): Match[];

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

@@ -6,5 +6,5 @@ type UseLicenseProps = {
 export declare const useLicense: (props?: UseLicenseProps) => {
     license: import("vue").ShallowRef<License | undefined>;
 };
-export declare function useInjectedLicense(pagesContainer: Ref<HTMLDivElement | null>): import("vue").ShallowRef<License | undefined>;
+export declare function useInjectedLicense(pagesContainer: Ref<HTMLDivElement | undefined>): import("vue").ShallowRef<License | undefined>;
 export {};

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

@@ -1,5 +1,6 @@
 import type { MaybeRef } from 'vue';
-import type { PDFDestination, PDFInfo, PDFOptions, PDFSrc } from '../components/types';
+import type { PDFDestination, PDFInfo, PDFOptions, PDFSrc } from '../utils/types';
+import type { PDFDocumentProxy, PDFPageProxy } from 'pdfjs-dist/types/src/display/api';
 /**
  * @typedef {Object} UsePDFParameters
  * @property {string} password
@@ -22,5 +23,6 @@ export declare function usePDF(src: MaybeRef<PDFSrc>, options?: PDFOptions, work
     pdf: import("vue").ShallowRef<import("pdfjs-dist/types/src/display/api").PDFDocumentLoadingTask | undefined>;
     totalPages: import("vue").ShallowRef<number>;
     info: import("vue").ShallowRef<{}> | import("vue").ShallowRef<PDFInfo>;
+    getPage: (doc: PDFDocumentProxy, pageIndex: number) => Promise<PDFPageProxy>;
     getPDFDestination: (destination: string | any[] | null) => Promise<PDFDestination | null>;
 };

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

@@ -0,0 +1,8 @@
+import { MaybeRef, UnwrapRef } from 'vue';
+import { ViewerPdfPage, ViewerState } from '@/utils/types';
+import { ZoomLevel } from '@/utils/enumerators';
+export declare function usePdfPageSizes(props: UnwrapRef<ViewerState>, initialScale: MaybeRef<number | ZoomLevel>): {
+    pdfPages: import("vue").ShallowRef<ViewerPdfPage[]>;
+    actualPdfPages: import("vue").ShallowRef<ViewerPdfPage[]>;
+    defaultScale: import("vue").Ref<number, number>;
+};

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

@@ -0,0 +1,13 @@
+import { PDFDocumentProxy } from 'pdfjs-dist/types/src/display/api';
+import { MaybeRef } from 'vue';
+export interface UseRenderQueueReturn {
+    getHighestPriorityPage: () => number;
+    isInRange: (pageIndex: number) => boolean;
+    markNotRendered: () => void;
+    markRendered: (pageIndex: number) => void;
+    markRendering: (pageIndex: number) => void;
+    setOutOfRange: (pageIndex: number) => void;
+    setRange: (startIndex: number, endIndex: number) => void;
+    setVisibility: (pageIndex: number, visibility: number) => void;
+}
+export declare const useRenderQueue: (doc: MaybeRef<PDFDocumentProxy | undefined>) => UseRenderQueueReturn;

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

@@ -0,0 +1 @@
+export declare const useRequestAnimationFrame: <T extends unknown[]>(callback: (...args: T) => void, recurring?: boolean) => (...args: T) => void;

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

@@ -1,6 +1,6 @@
+import { Ref } from 'vue';
 import { RotateEvent } from '..';
-export declare const useRotation: (initialRotate: number, rotateCallback?: ((event: RotateEvent) => void) | undefined) => {
-    pageRotate: import("vue").Ref<number, number>;
+export declare const useRotation: (currentRotation: Ref<number>, rotateCallback?: ((event: RotateEvent) => void) | undefined) => {
     onRotateClockwise: () => void;
     onRotateCounterclockwise: () => void;
 };

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

@@ -1,13 +1,15 @@
-import { Match } from '@/components';
-import { ShallowRef } from 'vue';
+import { Match, PdfPageSize } from '@/components';
+import { MaybeRef, Ref, ShallowRef } from 'vue';
 import type { PDFDocumentProxy } from 'pdfjs-dist';
 interface MatchValue extends Match {
     page: number;
+    pageMatchIdx: number;
 }
-export declare const useSearch: (pdfDoc: ShallowRef<PDFDocumentProxy | undefined>) => {
-    searchValue: import("vue").Ref<string, string>;
-    matches: import("vue").Ref<{
+export declare const useSearch: (pdfDoc: ShallowRef<PDFDocumentProxy | undefined>, pageSizes: Ref<PdfPageSize[] | undefined>, elementRef: MaybeRef<HTMLElement | undefined>) => {
+    searchValue: Ref<string, string>;
+    matches: Ref<{
         page: number;
+        pageMatchIdx: number;
         start: {
             idx: number;
             offset: number;
@@ -20,6 +22,7 @@ export declare const useSearch: (pdfDoc: ShallowRef<PDFDocumentProxy | undefined
         oIndex: number;
     }[], MatchValue[] | {
         page: number;
+        pageMatchIdx: number;
         start: {
             idx: number;
             offset: number;
@@ -32,22 +35,10 @@ export declare const useSearch: (pdfDoc: ShallowRef<PDFDocumentProxy | undefined
         oIndex: number;
     }[]>;
     matchCount: import("vue").ComputedRef<number>;
-    currentMatchIndex: import("vue").Ref<number | undefined, number | undefined>;
-    currentMatch: import("vue").ComputedRef<{
-        page: number;
-        start: {
-            idx: number;
-            offset: number;
-        };
-        end: {
-            idx: number;
-            offset: number;
-        };
-        str: string;
-        oIndex: number;
-    } | undefined>;
-    searching: import("vue").Ref<boolean, boolean>;
-    openSearch: import("vue").Ref<boolean, boolean>;
+    currentMatchIndex: Ref<number | undefined, number | undefined>;
+    currentMatch: import("vue").ComputedRef<MatchValue | undefined>;
+    searching: Ref<boolean, boolean>;
+    openSearch: Ref<boolean, boolean>;
     onOpenSearch: () => void;
     onCloseSearch: () => void;
     handleSelectNext: () => void;

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

@@ -0,0 +1,36 @@
+import { Ref, UnwrapRef, CSSProperties } from 'vue';
+import { ScrollMode, ViewMode } from '@/utils/enumerators';
+import { VirtualItem, Offset, ViewerPdfPage } from '@/utils/types';
+export interface VisiblePagesRange {
+    endPage: number;
+    numPages: number;
+    startPage: number;
+}
+export type SetRenderRange = (visiblePagesRange: VisiblePagesRange) => {
+    endPage: number;
+    startPage: number;
+};
+interface UseVirtualProps {
+    pages: Ref<ViewerPdfPage[]>;
+    viewerRef: Ref<HTMLElement | undefined>;
+    scrollMode: Ref<ScrollMode>;
+    viewMode: Ref<ViewMode>;
+    isRtl: boolean;
+    smoothScroll: Ref<boolean>;
+}
+export declare const useVirtual: (props: UnwrapRef<UseVirtualProps>) => {
+    visibilities: import("vue").WritableComputedRef<any[]>;
+    virtualItems: import("vue").ComputedRef<VirtualItem[]>;
+    getContainerStyles: () => CSSProperties;
+    getItemContainerStyles: (item: VirtualItem) => CSSProperties;
+    getItemStyles: (item: VirtualItem) => CSSProperties;
+    virtualRangeState: import("vue").ComputedRef<{
+        startPage: number;
+        endPage: number;
+        maxVisibilityIndex: number;
+    } | undefined>;
+    isScrolling: Ref<boolean, boolean>;
+    scrollToItem: (index: number, offset?: Offset) => void;
+    zoom: (scale: number, index: number) => void;
+};
+export {};

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

@@ -0,0 +1,29 @@
+import type { ComputedRef, CSSProperties, Ref, StyleValue, UnwrapRef } from 'vue';
+import { ViewerPdfPage, ScrollMode, ViewMode } from '..';
+export interface UseVirtualListItem<T> {
+    data: T;
+    index: number;
+}
+export interface UseVirtualListReturn {
+    list: Ref<UseVirtualListItem<ViewerPdfPage>[]>;
+    scrollTo: (index: number) => void;
+    pageGroups: ComputedRef<Array<UseVirtualListItem<ViewerPdfPage>[]> | undefined>;
+    containerProps: {
+        ref: Ref<HTMLElement | null>;
+        onScroll: () => void;
+        style: StyleValue;
+    };
+    wrapperProps: ComputedRef<{
+        style: CSSProperties;
+    }>;
+}
+interface UseVirtualPagesProps {
+    pages: Ref<ViewerPdfPage[]>;
+    viewerRef: Ref<HTMLElement | undefined>;
+    scrollMode: Ref<ScrollMode>;
+    viewMode: Ref<ViewMode>;
+    isRtl: boolean;
+    smoothScroll: Ref<boolean>;
+}
+export declare function useVirtualPages(props: UnwrapRef<UseVirtualPagesProps>): UseVirtualListReturn;
+export {};

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

@@ -0,0 +1,18 @@
+import { Ref, UnwrapRef } from 'vue';
+import { Offset } from '../utils/types';
+import { ScrollDirection, ScrollMode, ViewMode } from '../utils/enumerators';
+interface UseScrollReturn {
+    scrollOffset: Ref<Offset>;
+    scrollDirection: Ref<ScrollDirection>;
+    isScrolling: Ref<boolean>;
+    scrollTo: (target: Offset, smooth?: boolean) => void;
+}
+interface UseScrollProps {
+    viewerRef: Ref<HTMLElement | undefined>;
+    scrollMode: Ref<ScrollMode>;
+    viewMode: Ref<ViewMode>;
+    isRtl: boolean;
+    smooth: Ref<boolean>;
+}
+export declare const useVirtualScroll: (props: UnwrapRef<UseScrollProps>) => UseScrollReturn;
+export {};