@vue-pdf-viewer/viewer 3.0.0-alpha.3 → 3.0.0-alpha.30

package/dist/types/utils/annotation-display.d.ts

@@ -0,0 +1,28 @@
+import { PDFPageProxy } from 'pdfjs-dist';
+import { Annotation } from './types';
+/**
+ * Scale factors for the canvas, necessary with HiDPI displays.
+ */
+export declare class OutputScale {
+    sx: number;
+    sy: number;
+    constructor();
+    /**
+     * @type {boolean} Returns `true` when scaling is required, `false` otherwise.
+     */
+    get scaled(): boolean;
+    /**
+     * @type {boolean} Returns `true` when scaling is symmetric,
+     *   `false` otherwise.
+     */
+    get symmetric(): boolean;
+    /**
+     * @returns {boolean} Returns `true` if scaling was limited,
+     *   `false` otherwise.
+     */
+    limitCanvas(width: number, height: number, maxPixels: number, maxDim: number, capAreaFactor?: number): boolean;
+    static get pixelRatio(): number;
+    static capPixels(maxPixels: number, capAreaFactor: number): number;
+}
+export declare const getBaseTranslation: (parentDimensions: [number, number], rotation: number, outlineWidth?: number) => [number, number];
+export declare function setAnnotationPosition(page: PDFPageProxy, annotationElement: any, annotation: Annotation): void;

package/dist/types/utils/annotation-free-text.d.ts

@@ -0,0 +1,3 @@
+export declare function getFreeTextFontSize(fontSize: number): string;
+export declare function getFreeTextFontFamily(fontName: string): string;
+export declare function replaceNewlinesWithBackslashN(contentEditableElement: HTMLDivElement): string;

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

@@ -0,0 +1,100 @@
+import type { PageViewport } from 'pdfjs-dist';
+import type { RectBox } from './types';
+export declare function calculateBoundingBox(boxes: RectBox[]): [number, number, number, number];
+export declare function createSVGPathFromQuadPoints(quadPoints: number[], viewport: PageViewport): string;
+declare class HighlightOutline {
+    #private;
+    constructor(outlines: any[], box: Float32Array, lastPoint: any[]);
+    get outlines(): any[];
+    toSVGPath(): string;
+    /**
+     * Serialize the outlines into the PDF page coordinate system.
+     * @param {Array<number>} _bbox - the bounding box of the annotation.
+     * @param {number} _rotation - the rotation of the annotation.
+     * @returns {Array<Array<number>>}
+     */
+    serialize([blX, blY, trX, trY]: [number, number, number, number], _rotation: number): any[][];
+    get box(): Float32Array;
+}
+export declare function getHighlightOutlineCreator(boxes: RectBox[], options?: {
+    borderWidth: number;
+    innerMargin: number;
+    isLTR: boolean;
+}): {
+    box: Float32Array;
+    getOutlines: () => HighlightOutline;
+};
+export declare function quadPointsToBoxes(quadPoints: number[], rect: number[], pageWidth: number, pageHeight: number, pageX?: number, pageY?: number): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}[];
+export declare function quadPointsToBoxesForRect(quadPoints: number[], rect: number[]): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}[];
+/**
+ * Get selection boxes from text layer with proper rotation handling.
+ * Adapted from PDF.js display/editor/tools.js
+ * @param {HTMLElement} textLayer - The text layer element
+ * @returns {Array<{x: number, y: number, width: number, height: number}>|null} Normalized boxes or null
+ */
+export declare function getSelectionBoxes(textLayer: HTMLElement): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}[] | null;
+/**
+ * Convert selection boxes to PDF quadPoints
+ * @param {Array<{x: number, y: number, width: number, height: number}>} boxes - Normalized boxes (0-1 range)
+ * @param {PageViewport} viewport - PDF page viewport
+ * @returns {number[]} Array of quadPoints in PDF coordinate system
+ */
+/**
+ * Convert selection boxes to PDF quadPoints coordinates
+ *
+ * In PDF, quadPoints are used to define the coordinates of a quadrilateral.
+ * Each quadrilateral requires 8 numbers representing 4 points (x,y pairs).
+ * The points MUST be specified in the following order (x,y pairs):
+ * - (x1,y1): left x, bottom y  - bottom left
+ * - (x2,y2): right x, bottom y - bottom right
+ * - (x3,y3): left x, top y    - top left
+ * - (x4,y4): right x, top y   - top right
+ *
+ * This order is based on PDF.js implementation and real-world PDF files,
+ * which differs slightly from the PDF specification (which suggests a different order).
+ *
+ * @param boxes Array of normalized boxes (coordinates in 0-1 range)
+ * @param viewport PDF page viewport for coordinate conversion
+ * @returns Array of quadPoints in PDF coordinate system
+ * @throws Error if boxes array is empty
+ */
+export declare function boxesToQuadPoints(boxes: Array<{
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}>, viewport: PageViewport): number[];
+/**
+ * Convert PDF quadPoints back to viewport boxes
+ * @param {number[]} quadPoints - Array of quadPoints in PDF coordinate system
+ * @param {PageViewport} viewport - PDF page viewport
+ * @returns {Array<{x: number, y: number, width: number, height: number}>} Array of normalized boxes (0-1 range)
+ */
+export declare function quadPointsToBoxesForAnnotation(quadPoints: number[], viewport: PageViewport): Array<{
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}>;
+/**
+ * Calculate the bounding rectangle from quadPoints
+ * @param {number[]} quadPoints - Array of quadPoints coordinates
+ * @returns {number[]} Bounding rectangle [x1, y1, x2, y2] in PDF coordinates
+ */
+export declare function quadPointsToRect(quadPoints: number[]): number[];
+export {};

package/dist/types/utils/annotation-image.d.ts

@@ -0,0 +1,111 @@
+/**
+ * AnnotationImageManager - Based on PDF.js ImageManager
+ *
+ * Manages images used by annotation editors with memory optimization.
+ * Features:
+ * - Caching with reference counting
+ * - Memory management (converts to blob when not in use)
+ * - Multiple image sources: File, URL, Blob, Canvas
+ * - SVG support with aspect ratio preservation
+ * - Unique ID generation and validation
+ */
+export interface ImageData {
+    bitmap: ImageBitmap | HTMLImageElement;
+    id: string;
+    refCounter: number;
+    isSvg: boolean;
+    url?: string;
+    file?: File;
+    blobPromise?: Promise<Blob>;
+    svgUrl?: string;
+}
+export interface ImageManagerOptions {
+    baseId?: string;
+}
+/**
+ * Utility function to generate unique IDs
+ */
+declare function generateUuid(): string;
+/**
+ * Utility function to fetch data from URL
+ */
+declare function fetchImageData(url: string): Promise<Blob>;
+declare function validateFileSize(file: File, maxSize?: number): boolean;
+declare function validateFileMimeType(file: File, mimeTypes?: string[]): boolean;
+declare function isSVGFittingCanvas(): Promise<boolean>;
+export declare class AnnotationImageManager {
+    private readonly baseId;
+    private idCounter;
+    private cache;
+    constructor(options?: ImageManagerOptions);
+    /**
+     * Get image data from cache or create new entry
+     */
+    private get;
+    /**
+     * Handle SVG image loading with aspect ratio preservation
+     */
+    private handleSvgImage;
+    /**
+     * Get image from File object
+     */
+    getFromFile(file: File): Promise<ImageData | null>;
+    /**
+     * Get image from URL
+     */
+    getFromUrl(url: string): Promise<ImageData | null>;
+    /**
+     * Get image from Blob with custom ID
+     */
+    getFromBlob(id: string, blobPromise: Promise<Blob>): Promise<ImageData | null>;
+    /**
+     * Get image by ID (restore from cache)
+     */
+    getFromId(id: string): Promise<ImageData | null>;
+    /**
+     * Get image from Canvas element
+     */
+    getFromCanvas(id: string, canvas: HTMLCanvasElement): ImageData;
+    /**
+     * Get SVG URL by ID
+     */
+    getSvgUrl(id: string): string | null;
+    /**
+     * Delete image by ID (decrement reference counter)
+     */
+    deleteId(id: string): void;
+    /**
+     * Check if ID belongs to this manager
+     */
+    isValidId(id: string): boolean;
+    /**
+     * Get all cached image IDs
+     */
+    getCachedIds(): string[];
+    /**
+     * Get cache statistics
+     */
+    getCacheStats(): {
+        totalImages: number;
+        loadedImages: number;
+        totalMemory: number;
+    };
+    /**
+     * Clear all cached images
+     */
+    clear(): void;
+    /**
+     * Convert ImageBitmap to data URL (for export/clipboard)
+     */
+    bitmapToDataUrl(imageData: ImageData): Promise<string>;
+    /**
+     * Create ImageBitmap from existing ImageData for serialization
+     */
+    serializeBitmap(imageData: ImageData, options?: {
+        width?: number;
+        height?: number;
+        preserveAspectRatio?: boolean;
+    }): Promise<ImageBitmap>;
+}
+export declare const annotationImageManager: AnnotationImageManager;
+export { generateUuid, fetchImageData, isSVGFittingCanvas, validateFileSize, validateFileMimeType };

package/dist/types/utils/annotation-pdf.d.ts

@@ -0,0 +1,35 @@
+import { PDFDocumentProxy } from 'pdfjs-dist';
+export declare function updatePdfAnnotations(pdfDocument: PDFDocumentProxy): Promise<void>;
+/**
+ * Calculate the proper rect for highlight annotation serialization
+ *
+ * This method replicates the getRect logic from PDF.js AnnotationEditor to ensure
+ * that outlines are properly serialized when saving documents. The issue was that
+ * the original rect was not being calculated in the same coordinate system that
+ * PDF.js uses for outline serialization.
+ *
+ * In PDF.js, the HighlightEditor.serialize() method calls:
+ * 1. const rect = this.getRect(0, 0) - to get the rect in page coordinates
+ * 2. outlines: this.#serializeOutlines(rect) - to serialize outlines using that rect
+ *
+ * The #serializeOutlines method then calls:
+ * return this.#highlightOutlines.serialize(rect, this.#getRotation())
+ *
+ * This ensures that the outlines are properly transformed from normalized coordinates
+ * (0-1 range) to actual page coordinates, taking into account page translation and rotation.
+ *
+ * Since we use dontFlip: true in getViewport, the coordinates are already in PDF
+ * coordinate system (Y=0 at bottom), so we don't need to flip Y coordinates again.
+ *
+ * @param {number[]} quadPoints - The quad points of the annotation in page coordinates
+ * @param {Object} pageDimensions - Page dimensions and translation from viewport.rawDims
+ * @param {number} rotation - Page rotation in degrees (0, 90, 180, 270)
+ * @param {boolean} isDontFlip - Whether the viewport was created with dontFlip: true (default: true)
+ * @returns {number[]} The calculated rect [x1, y1, x2, y2] in page coordinates
+ */
+export declare const getAnnotationRect: (quadPoints: number[], pageDimensions: {
+    width: number;
+    height: number;
+    pageX: number;
+    pageY: number;
+}, rotation?: number, isDontFlip?: boolean) => number[];

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

@@ -0,0 +1,24 @@
+export declare class Console {
+    private static instance;
+    private isProduction;
+    private constructor();
+    static getInstance(): Console;
+    /**
+     * Debug level logging - stripped in production
+     */
+    debug(...args: any[]): void;
+    /**
+     * Info level logging
+     */
+    info(...args: any[]): void;
+    /**
+     * Warning level logging
+     */
+    warn(...args: any[]): void;
+    /**
+     * Error level logging
+     */
+    error(...args: any[]): void;
+}
+declare const _default: Console;
+export default _default;

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

@@ -0,0 +1,16 @@
+declare enum CharacterType {
+    SPACE = 0,
+    ALPHA_LETTER = 1,
+    PUNCTUATION = 2,
+    HAN_LETTER = 3,
+    KATAKANA_LETTER = 4,
+    HIRAGANA_LETTER = 5,
+    HALF_WIDTH_KATAKANA_LETTER = 6,
+    THAI_LETTER = 7
+}
+/**
+ * This function is based on the word-break detection implemented in:
+ * https://hg.mozilla.org/mozilla-central/file/tip/intl/lwbrk/WordBreaker.cpp
+ */
+declare function getCharacterType(charCode: number): CharacterType;
+export { CharacterType, getCharacterType };

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

@@ -0,0 +1,4 @@
+export declare const makeHexColor: (r: number, g: number, b: number) => string;
+export declare const uint8ClampedArrayToRgb: (color: Uint8ClampedArray | number[]) => number[];
+export declare function rgbToUint8ClampedArray(hexColor: string): number[];
+export declare function hexToUint8ClampedArray(hexColor: string): Uint8ClampedArray;

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

@@ -0,0 +1 @@
+export declare const convertPDFDate: (input: string) => Date | null;

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

@@ -0,0 +1,81 @@
+export declare enum LicenseType {
+    All = "all",
+    Premium = "premium",
+    Freemium = "freemium",
+    Unlicense = "none",
+    Organization = "organization",
+    Developer = "developer",
+    FreeTrial = "free-trial"
+}
+export declare enum ScrollMode {
+    Vertical = "Vertical",
+    Horizontal = "Horizontal",
+    Page = "Page",
+    Wrapped = "Wrapped"
+}
+export declare enum ViewMode {
+    SinglePage = "Single",
+    DualPage = "Dual"
+}
+export declare enum ZoomLevel {
+    ActualSize = "actualSize",
+    PageFit = "pageFit",
+    PageWidth = "pageWidth"
+}
+export declare enum ScrollDirection {
+    Horizontal = "Horizontal",
+    Vertical = "Vertical",
+    Both = "Both"
+}
+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",
+    BUTTON = "button",
+    NAVIGATION = "navigation"
+}
+export declare enum LayerRenderStatus {
+    PreRender = 0,
+    DidRender = 1
+}
+export declare enum AnnotationType {
+    Text = 1,
+    Link = 2,
+    FreeText = 3,
+    Line = 4,
+    Square = 5,
+    Circle = 6,
+    Polygon = 7,
+    Polyline = 8,
+    Highlight = 9,
+    Underline = 10,
+    Squiggly = 11,
+    StrikeOut = 12,
+    Stamp = 13,
+    Caret = 14,
+    Ink = 15,
+    Popup = 16,
+    FileAttachment = 17,
+    Widget = 20
+}
+export declare enum AnnotationFlag {
+    INVISIBLE = 1,
+    HIDDEN = 2,
+    PRINT = 4,
+    NOZOOM = 8,
+    NOROTATE = 16,
+    NOVIEW = 32,
+    READONLY = 64,
+    LOCKED = 128,
+    TOGGLENOVIEW = 256,
+    LOCKEDCONTENTS = 512
+}
+export declare enum LicenseProduct {
+    Viewer = "viewer",
+    ViewerAndAnnotation = "viewer_and_annotation"
+}

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

@@ -0,0 +1,8 @@
+import type { TextContent } from 'pdfjs-dist/types/src/display/text_layer';
+import type { HighlightOptions, Match } from './types';
+declare function isMatchEntireWord(content: string, startIdx: number, length: number): boolean;
+declare function highlightMatches(matches: Match[], textContent: TextContent, textDivs: HTMLElement[]): void;
+declare function resetDivs(textContent: TextContent, textDivs: HTMLElement[]): void;
+declare function findMatches(queries: (string | RegExp)[], textContent: TextContent, pageIndex: number, options: HighlightOptions): Match[];
+declare function getHighlightOptionsWithDefaults(options?: HighlightOptions): HighlightOptions;
+export { findMatches, highlightMatches, resetDivs, getHighlightOptionsWithDefaults, isMatchEntireWord };

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

@@ -0,0 +1,55 @@
+interface Command extends CommandHistory {
+    mustExec: boolean;
+    overwriteIfSameType?: boolean;
+    keepUndo?: boolean;
+}
+interface CommandHistory {
+    cmd: Function;
+    undo: Function;
+    post: Function;
+    type: number;
+}
+export declare class HistoryManager {
+    commandHistory: CommandHistory[] | null;
+    locked: boolean;
+    maxSize: number;
+    position: number;
+    constructor(maxSize?: number);
+    /**
+     * @typedef {Object} addOptions
+     * @property {function} cmd
+     * @property {function} undo
+     * @property {function} [post]
+     * @property {boolean} mustExec
+     * @property {number} type
+     * @property {boolean} overwriteIfSameType
+     * @property {boolean} keepUndo
+     */
+    /**
+     * Add a new couple of commands to be used in case of redo/undo.
+     * @param {addOptions} options
+     */
+    add({ cmd, undo, post, mustExec, type, overwriteIfSameType, keepUndo }: Command): void;
+    /**
+     * Undo the last command.
+     */
+    undo(): void;
+    /**
+     * Redo the last command.
+     */
+    redo(): void;
+    /**
+     * Check if there is something to undo.
+     * @returns {boolean}
+     */
+    hasSomethingToUndo(): boolean;
+    /**
+     * Check if there is something to redo.
+     * @returns {boolean}
+     */
+    hasSomethingToRedo(): boolean;
+    cleanType(type: number): void;
+    destroy(): void;
+    reset(): void;
+}
+export {};

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

@@ -0,0 +1,7 @@
+type Resolve = (value: unknown) => void;
+export declare function promiseWithResolvers<T = void>(): {
+    promise: Promise<T>;
+    resolve: Resolve;
+    reject: (reason?: any) => void;
+};
+export {};

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

@@ -0,0 +1,10 @@
+import type { CSSProperties } from 'vue';
+import type { FlagKeyword, HighlightArea, HighlightMatchPosition, 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/smoothScroll.d.ts

@@ -0,0 +1,2 @@
+import { ScrollDirection, Offset } from '..';
+export declare const smoothScroll: (ele: HTMLElement, scrollDirection: ScrollDirection, targetPosition: Offset, duration: number, easing?: (t: number) => number, onReachTarget?: () => void) => void;