react-3d-flipbook 1.1.1

package/dist/index.d.ts

@@ -0,0 +1,1121 @@
+import * as React$1 from 'react';
+import React__default from 'react';
+
+interface FlipbookPage {
+    /** Image source URL for the page */
+    src: string;
+    /** Thumbnail image URL */
+    thumb?: string;
+    /** Page title for table of contents */
+    title?: string;
+    /** HTML content to overlay on the page */
+    htmlContent?: string;
+    /** JSON data associated with the page */
+    json?: Record<string, unknown>;
+    /** Which side of a double page spread */
+    side?: "left" | "right";
+    /** Whether this is an empty/placeholder page */
+    empty?: boolean;
+    /** Page width in pixels (for landscape/portrait support) */
+    width?: number;
+    /** Page height in pixels (for landscape/portrait support) */
+    height?: number;
+    /** Page orientation - auto-detected from width/height if not specified */
+    orientation?: "portrait" | "landscape";
+}
+interface TocItem {
+    title: string;
+    page: number;
+    children?: TocItem[];
+}
+type ViewMode = "webgl";
+type SkinType = "dark" | "light" | "gradient";
+type LayoutType = "1" | "2" | "3" | "4";
+type HAlign = "left" | "center" | "right";
+type VAlign = "top" | "middle" | "bottom";
+interface ButtonConfig {
+    enabled?: boolean;
+    title?: string;
+    iconFA?: string;
+    iconM?: string;
+    iconFA_alt?: string;
+    iconM_alt?: string;
+    hAlign?: HAlign;
+    vAlign?: VAlign;
+    hideOnMobile?: boolean;
+}
+interface DownloadButtonConfig extends ButtonConfig {
+    url?: string;
+    name?: string;
+    forceDownload?: boolean;
+    openInNewWindow?: boolean;
+}
+interface CurrentPageConfig {
+    enabled?: boolean;
+    title?: string;
+    vAlign?: VAlign;
+    hAlign?: HAlign;
+    marginH?: number;
+    marginV?: number;
+    color?: string;
+    background?: string;
+}
+interface CloseButtonConfig extends ButtonConfig {
+    size?: number;
+}
+interface ShareProviderConfig {
+    enabled?: boolean;
+    icon?: string;
+}
+interface ShareConfig {
+    whatsapp?: ShareProviderConfig;
+    twitter?: ShareProviderConfig;
+    facebook?: ShareProviderConfig;
+    pinterest?: ShareProviderConfig;
+    email?: ShareProviderConfig;
+    linkedin?: ShareProviderConfig;
+    digg?: ShareProviderConfig;
+    reddit?: ShareProviderConfig;
+}
+interface PdfConfig {
+    annotationLayer?: boolean;
+}
+interface FillPreloaderConfig {
+    enabled?: boolean;
+    imgEmpty?: string;
+    imgFull?: string;
+}
+interface LocalizationStrings {
+    print?: string;
+    printLeftPage?: string;
+    printRightPage?: string;
+    printCurrentPage?: string;
+    printAllPages?: string;
+    download?: string;
+    downloadLeftPage?: string;
+    downloadRightPage?: string;
+    downloadCurrentPage?: string;
+    downloadAllPages?: string;
+    bookmarks?: string;
+    bookmarkLeftPage?: string;
+    bookmarkRightPage?: string;
+    bookmarkCurrentPage?: string;
+    search?: string;
+    findInDocument?: string;
+    pagesFoundContaining?: string;
+    noMatches?: string;
+    matchesFound?: string;
+    thumbnails?: string;
+    tableOfContent?: string;
+    share?: string;
+    pressEscToClose?: string;
+    password?: string;
+}
+interface MobileConfig {
+    shadows?: boolean;
+    pageSegmentsW?: number;
+}
+interface AssetsConfig {
+    preloader?: string;
+    overlay?: string;
+    flipMp3?: string;
+    spinner?: string;
+    backgroundMp3?: string;
+}
+interface LightboxConfig {
+    enabled?: boolean;
+    opened?: boolean;
+    fullscreen?: boolean;
+    closeOnClick?: boolean;
+    resetOnOpen?: boolean;
+    background?: string;
+    backgroundColor?: string;
+    backgroundPattern?: string;
+    backgroundImage?: string;
+    startPage?: number;
+    marginV?: number;
+    marginH?: number;
+    css?: string;
+    preload?: boolean;
+    showMenu?: boolean;
+    closeOnBack?: boolean;
+}
+interface FlipbookOptions {
+    name?: string;
+    pages?: FlipbookPage[];
+    tableOfContent?: TocItem[];
+    tableOfContentCloseOnClick?: boolean;
+    thumbsCloseOnClick?: boolean;
+    deeplinkingEnabled?: boolean;
+    deeplinkingPrefix?: string;
+    assets?: AssetsConfig;
+    pdfUrl?: string | null;
+    pdfBrowserViewerIfMobile?: boolean;
+    pdfBrowserViewerIfIE?: boolean;
+    pdfBrowserViewerFullscreen?: boolean;
+    pdfBrowserViewerFullscreenTarget?: string;
+    rangeChunkSize?: number;
+    disableRange?: boolean;
+    disableStream?: boolean;
+    disableAutoFetch?: boolean;
+    pdfAutoLinks?: boolean;
+    pdf?: PdfConfig;
+    pdfTextLayer?: boolean;
+    annotationLayer?: boolean;
+    htmlLayer?: boolean;
+    rightToLeft?: boolean;
+    startPage?: number;
+    sound?: boolean;
+    backgroundColor?: string;
+    backgroundImage?: string;
+    backgroundPattern?: string;
+    backgroundTransparent?: boolean;
+    thumbSize?: number;
+    loadAllPages?: boolean;
+    loadPagesF?: number;
+    loadPagesB?: number;
+    autoplayOnStart?: boolean;
+    autoplayInterval?: number;
+    autoplayLoop?: boolean;
+    skin?: SkinType;
+    layout?: LayoutType;
+    skinColor?: string;
+    skinBackground?: string;
+    menuOverBook?: boolean;
+    menuFloating?: boolean;
+    menuBackground?: string;
+    menuShadow?: string;
+    menuMargin?: number;
+    menuPadding?: number;
+    menuTransparent?: boolean;
+    hideMenu?: boolean;
+    menu2OverBook?: boolean;
+    menu2Floating?: boolean;
+    menu2Background?: string;
+    menu2Shadow?: string;
+    menu2Margin?: number;
+    menu2Padding?: number;
+    menu2Transparent?: boolean;
+    btnColor?: string;
+    btnBackground?: string;
+    btnSize?: number;
+    btnRadius?: number;
+    btnMargin?: number;
+    btnPaddingV?: number;
+    btnPaddingH?: number;
+    btnShadow?: string;
+    btnTextShadow?: string;
+    btnBorder?: string;
+    btnColorHover?: string;
+    btnBackgroundHover?: string;
+    sideBtnColor?: string;
+    sideBtnBackground?: string;
+    sideBtnSize?: number;
+    sideBtnRadius?: number;
+    sideBtnMargin?: number;
+    sideBtnPaddingV?: number;
+    sideBtnPaddingH?: number;
+    sideBtnShadow?: string;
+    sideBtnTextShadow?: string;
+    sideBtnBorder?: string;
+    sideBtnColorHover?: string;
+    sideBtnBackgroundHover?: string;
+    floatingBtnColor?: string;
+    floatingBtnColorHover?: string;
+    floatingBtnBackground?: string;
+    floatingBtnBackgroundHover?: string;
+    floatingBtnSize?: number | null;
+    floatingBtnRadius?: number | null;
+    floatingBtnMargin?: number | null;
+    floatingBtnPadding?: number | null;
+    floatingBtnShadow?: string;
+    floatingBtnTextShadow?: string;
+    floatingBtnBorder?: string;
+    currentPage?: CurrentPageConfig;
+    btnFirst?: ButtonConfig;
+    btnPrev?: ButtonConfig;
+    btnNext?: ButtonConfig;
+    btnLast?: ButtonConfig;
+    btnZoomIn?: ButtonConfig;
+    btnZoomOut?: ButtonConfig;
+    btnRotateLeft?: ButtonConfig;
+    btnRotateRight?: ButtonConfig;
+    btnAutoplay?: ButtonConfig;
+    btnSearch?: ButtonConfig;
+    btnSelect?: ButtonConfig;
+    btnBookmark?: ButtonConfig;
+    btnToc?: ButtonConfig;
+    btnThumbs?: ButtonConfig;
+    btnShare?: ButtonConfig;
+    btnPrint?: ButtonConfig;
+    btnDownloadPages?: DownloadButtonConfig;
+    btnDownloadPdf?: DownloadButtonConfig;
+    btnSound?: ButtonConfig;
+    btnExpand?: ButtonConfig;
+    btnClose?: CloseButtonConfig;
+    btnOrder?: string[];
+    btnShareIfMobile?: boolean;
+    btnSoundIfMobile?: boolean;
+    btnPrintIfMobile?: boolean;
+    sideNavigationButtons?: boolean;
+    shareUrl?: string;
+    shareTitle?: string;
+    shareImage?: string;
+    share?: ShareConfig;
+    pageTextureSize?: number;
+    pageTextureSizeSmall?: number;
+    thumbTextureSize?: number;
+    pageTextureSizeMobile?: number;
+    pageTextureSizeMobileSmall?: number;
+    viewMode?: ViewMode;
+    singlePageMode?: boolean;
+    singlePageModeIfMobile?: boolean;
+    zoomMin?: number;
+    zoomMax2?: number;
+    zoomSize?: number;
+    zoomStep?: number;
+    zoomTime?: number;
+    zoomReset?: boolean;
+    zoomResetTime?: number;
+    wheelDisabledNotFullscreen?: boolean;
+    arrowsDisabledNotFullscreen?: boolean;
+    arrowsAlwaysEnabledForNavigation?: boolean;
+    touchSwipeEnabled?: boolean;
+    doubleClickZoomDisabled?: boolean;
+    pageDragDisabled?: boolean;
+    rightClickEnabled?: boolean;
+    responsiveView?: boolean;
+    responsiveViewRatio?: number;
+    responsiveViewTreshold?: number;
+    minPixelRatio?: number;
+    pageFlipDuration?: number;
+    contentOnStart?: boolean;
+    thumbnailsOnStart?: boolean;
+    searchOnStart?: boolean;
+    sideMenuOverBook?: boolean;
+    sideMenuOverMenu?: boolean;
+    sideMenuOverMenu2?: boolean;
+    sideMenuPosition?: "left" | "right";
+    lightBox?: boolean;
+    lightBoxOpened?: boolean;
+    lightBoxFullscreen?: boolean;
+    lightboxCloseOnClick?: boolean;
+    lightboxResetOnOpen?: boolean;
+    lightboxBackground?: string;
+    lightboxBackgroundColor?: string;
+    lightboxBackgroundPattern?: string;
+    lightboxBackgroundImage?: string;
+    lightboxStartPage?: number;
+    lightboxMarginV?: number;
+    lightboxMarginH?: number;
+    lightboxCSS?: string;
+    lightboxPreload?: boolean;
+    lightboxShowMenu?: boolean;
+    lightboxCloseOnBack?: boolean;
+    disableImageResize?: boolean;
+    pan?: number;
+    panMax?: number;
+    panMax2?: number;
+    panMin?: number;
+    panMin2?: number;
+    tilt?: number;
+    tiltMax?: number;
+    tiltMax2?: number;
+    tiltMin?: number;
+    tiltMin2?: number;
+    rotateCameraOnMouseMove?: boolean;
+    rotateCameraOnMouseDrag?: boolean;
+    lights?: boolean;
+    lightColor?: number;
+    lightPositionX?: number;
+    lightPositionZ?: number;
+    lightPositionY?: number;
+    lightIntensity?: number;
+    shadows?: boolean;
+    shadowMapSize?: number;
+    shadowOpacity?: number;
+    shadowDistance?: number;
+    pageRoughness?: number;
+    pageMetalness?: number;
+    pageHardness?: number;
+    coverHardness?: number;
+    pageSegmentsW?: number;
+    pageSegmentsH?: number;
+    pageMiddleShadowSize?: number;
+    pageMiddleShadowColorL?: string;
+    pageMiddleShadowColorR?: string;
+    antialias?: boolean;
+    /** Camera zoom/margin factor - higher values move camera further back (default: 1.35) */
+    cameraZoom?: number;
+    /** Camera vertical position offset (default: 0) */
+    cameraPositionY?: number;
+    /** Camera look-at Y position (default: 0) */
+    cameraLookAtY?: number;
+    /** Field of view in degrees (default: 45) */
+    cameraFov?: number;
+    /** Base page scale in world units - affects overall page size (default: 6) */
+    pageScale?: number;
+    preloaderText?: string;
+    fillPreloader?: FillPreloaderConfig;
+    logoImg?: string;
+    logoUrl?: string;
+    logoCSS?: string;
+    logoHideOnMobile?: boolean;
+    printMenu?: boolean;
+    downloadMenu?: boolean;
+    cover?: boolean;
+    backCover?: boolean;
+    googleAnalyticsTrackingCode?: string;
+    minimumAndroidVersion?: number;
+    linkColor?: string;
+    linkColorHover?: string;
+    linkOpacity?: number;
+    linkTarget?: string;
+    pageNumberOffset?: number;
+    flipSound?: boolean;
+    backgroundMusic?: string;
+    strings?: LocalizationStrings;
+    mobile?: MobileConfig;
+}
+interface FlipbookEventMap {
+    pageFlip: {
+        page: number;
+        direction: "next" | "prev";
+    };
+    pageFlipStart: {
+        page: number;
+        direction: "next" | "prev";
+    };
+    pageFlipEnd: {
+        page: number;
+    };
+    zoomChange: {
+        zoom: number;
+    };
+    ready: void;
+    loadProgress: {
+        progress: number;
+    };
+    pageLoaded: {
+        page: number;
+    };
+    fullscreenChange: {
+        isFullscreen: boolean;
+    };
+    lightboxOpen: void;
+    lightboxClose: void;
+    soundToggle: {
+        enabled: boolean;
+    };
+    autoplayToggle: {
+        enabled: boolean;
+    };
+}
+interface FlipbookInstance {
+    nextPage: () => void;
+    prevPage: () => void;
+    firstPage: () => void;
+    lastPage: () => void;
+    goToPage: (page: number) => void;
+    zoomIn: () => void;
+    zoomOut: () => void;
+    zoomTo: (zoom: number) => void;
+    getCurrentPage: () => number;
+    getNumPages: () => number;
+    getZoom: () => number;
+    isFullscreen: () => boolean;
+    toggleFullscreen: () => void;
+    toggleAutoplay: () => void;
+    toggleSound: () => void;
+    toggleThumbnails: () => void;
+    toggleTableOfContents: () => void;
+    toggleSearch: () => void;
+    openLightbox: () => void;
+    closeLightbox: () => void;
+    bookmarkPage: (page: number) => void;
+    removeBookmark: (page: number) => void;
+    getBookmarkedPages: () => number[];
+    printCurrentPage: () => void;
+    downloadCurrentPage: () => void;
+    destroy: () => void;
+}
+interface FlipbookProps extends Partial<FlipbookOptions> {
+    /** Pages to display in the flipbook */
+    pages: FlipbookPage[];
+    /** Class name for the container element */
+    className?: string;
+    /** Inline styles for the container */
+    style?: React.CSSProperties;
+    /** Width of the flipbook container */
+    width?: number | string;
+    /** Height of the flipbook container */
+    height?: number | string;
+    onPageFlip?: (event: FlipbookEventMap["pageFlip"]) => void;
+    onPageFlipStart?: (event: FlipbookEventMap["pageFlipStart"]) => void;
+    onPageFlipEnd?: (event: FlipbookEventMap["pageFlipEnd"]) => void;
+    onZoomChange?: (event: FlipbookEventMap["zoomChange"]) => void;
+    onReady?: () => void;
+    onLoadProgress?: (event: FlipbookEventMap["loadProgress"]) => void;
+    onPageLoaded?: (event: FlipbookEventMap["pageLoaded"]) => void;
+    onFullscreenChange?: (event: FlipbookEventMap["fullscreenChange"]) => void;
+    onLightboxOpen?: () => void;
+    onLightboxClose?: () => void;
+    onSoundToggle?: (event: FlipbookEventMap["soundToggle"]) => void;
+    onAutoplayToggle?: (event: FlipbookEventMap["autoplayToggle"]) => void;
+}
+interface UseFlipbookReturn$1 {
+    containerRef: React.RefObject<HTMLDivElement>;
+    flipbookRef: React.RefObject<FlipbookInstance>;
+    currentPage: number;
+    numPages: number;
+    zoom: number;
+    isFullscreen: boolean;
+    isLoading: boolean;
+    isReady: boolean;
+}
+interface FlipbookContextValue {
+    options: FlipbookOptions;
+    currentPage: number;
+    numPages: number;
+    zoom: number;
+    isFullscreen: boolean;
+    isLoading: boolean;
+    instance: FlipbookInstance | null;
+}
+
+declare const Flipbook: React__default.ForwardRefExoticComponent<FlipbookProps & React__default.RefAttributes<FlipbookInstance>>;
+
+interface WebGLPageFlipProps {
+    pages: FlipbookPage[];
+    currentPage: number;
+    width: number;
+    height: number;
+    singlePageMode?: boolean;
+    flipDuration?: number;
+    pageHardness?: number;
+    coverHardness?: number;
+    pageSegmentsW?: number;
+    pageSegmentsH?: number;
+    shadows?: boolean;
+    shadowOpacity?: number;
+    lights?: boolean;
+    lightIntensity?: number;
+    lightColor?: number;
+    pageRoughness?: number;
+    pageMetalness?: number;
+    antialias?: boolean;
+    backgroundColor?: string;
+    /** Camera zoom/margin factor - higher values move camera further back (default: 1.35) */
+    cameraZoom?: number;
+    /** Base page scale in world units - affects overall page size (default: 6) */
+    pageScale?: number;
+    /** Camera vertical position offset (default: 0) */
+    cameraPositionY?: number;
+    /** Camera look-at Y position (default: 0) */
+    cameraLookAtY?: number;
+    /** Field of view in degrees (default: 45) */
+    cameraFov?: number;
+    onFlipStart?: (page: number, direction: "next" | "prev") => void;
+    onFlipEnd?: (page: number) => void;
+    onPageChange?: (page: number) => void;
+}
+interface WebGLPageFlipInstance {
+    flipNext: () => void;
+    flipPrev: () => void;
+    flipToPage: (page: number) => void;
+    flipToFirst: () => void;
+    flipToLast: () => void;
+    isFlipping: () => boolean;
+    dispose: () => void;
+}
+declare const WebGLPageFlip: React$1.ForwardRefExoticComponent<WebGLPageFlipProps & React$1.RefAttributes<WebGLPageFlipInstance>>;
+
+interface ThumbnailsPanelProps {
+    pages: FlipbookPage[];
+    currentPage: number;
+    isOpen: boolean;
+    position?: 'left' | 'right';
+    thumbnailSize?: number;
+    showPageNumbers?: boolean;
+    onPageSelect: (page: number) => void;
+    onClose: () => void;
+}
+declare const ThumbnailsPanel: React__default.FC<ThumbnailsPanelProps>;
+
+interface TableOfContentsProps {
+    items: TocItem[];
+    currentPage: number;
+    isOpen: boolean;
+    position?: 'left' | 'right';
+    closeOnClick?: boolean;
+    onPageSelect: (page: number) => void;
+    onClose: () => void;
+}
+declare const TableOfContents: React__default.FC<TableOfContentsProps>;
+
+interface SearchResult {
+    pageNumber: number;
+    pageIndex: number;
+    text: string;
+    matchIndex: number;
+    contextBefore: string;
+    contextAfter: string;
+}
+interface SearchPanelProps {
+    pages: FlipbookPage[];
+    pageTextContent?: Map<number, string>;
+    currentPage: number;
+    isOpen: boolean;
+    position?: "left" | "right";
+    minQueryLength?: number;
+    maxResults?: number;
+    highlightColor?: string;
+    onPageSelect: (page: number) => void;
+    onClose: () => void;
+    onSearchStart?: () => void;
+    onSearchEnd?: (results: SearchResult[]) => void;
+}
+declare const SearchPanel: React__default.FC<SearchPanelProps>;
+
+interface Bookmark {
+    page: number;
+    title?: string;
+    createdAt: Date;
+    note?: string;
+}
+interface BookmarksPanelProps {
+    pages: FlipbookPage[];
+    bookmarks: number[];
+    currentPage: number;
+    isOpen: boolean;
+    position?: 'left' | 'right';
+    showThumbnails?: boolean;
+    onPageSelect: (page: number) => void;
+    onRemoveBookmark: (page: number) => void;
+    onClose: () => void;
+}
+declare const BookmarksPanel: React__default.FC<BookmarksPanelProps>;
+
+interface UseFlipbookOptions extends Partial<FlipbookOptions> {
+    pages: FlipbookPage[];
+    initialPage?: number;
+    onPageChange?: (page: number) => void;
+    onZoomChange?: (zoom: number) => void;
+    onFullscreenChange?: (isFullscreen: boolean) => void;
+}
+interface UseFlipbookReturn {
+    currentPage: number;
+    numPages: number;
+    zoom: number;
+    isFullscreen: boolean;
+    isLoading: boolean;
+    isAnimating: boolean;
+    canGoNext: boolean;
+    canGoPrev: boolean;
+    bookmarkedPages: number[];
+    containerRef: React.RefObject<HTMLDivElement>;
+    nextPage: () => void;
+    prevPage: () => void;
+    firstPage: () => void;
+    lastPage: () => void;
+    goToPage: (page: number) => void;
+    setCurrentPageDirect: (page: number) => void;
+    zoomIn: () => void;
+    zoomOut: () => void;
+    zoomTo: (zoom: number) => void;
+    resetZoom: () => void;
+    toggleFullscreen: () => void;
+    enterFullscreen: () => void;
+    exitFullscreenMode: () => void;
+    toggleBookmark: (page?: number) => void;
+    isPageBookmarked: (page: number) => boolean;
+    preloadPages: (pageIndices: number[]) => Promise<void>;
+    getInstance: () => FlipbookInstance;
+}
+declare function useFlipbook(options: UseFlipbookOptions): UseFlipbookReturn;
+declare function useSwipeGesture(containerRef: React.RefObject<HTMLElement>, onSwipeLeft: () => void, onSwipeRight: () => void, options?: {
+    threshold?: number;
+    enabled?: boolean;
+}): void;
+declare function useWheelZoom(containerRef: React.RefObject<HTMLElement>, onZoom: (delta: number) => void, options?: {
+    enabled?: boolean;
+    sensitivity?: number;
+}): void;
+declare function useResizeObserver(ref: React.RefObject<HTMLElement>, callback: (entry: ResizeObserverEntry) => void): void;
+
+interface UseAutoplayOptions {
+    /** Total number of pages */
+    numPages: number;
+    /** Current page number (1-based) */
+    currentPage: number;
+    /** Interval between page flips in milliseconds */
+    interval?: number;
+    /** Whether to loop back to the first page after the last */
+    loop?: boolean;
+    /** Whether to start autoplay automatically */
+    autoStart?: boolean;
+    /** Number of pages to flip at a time (1 for single, 2 for spread) */
+    pageIncrement?: number;
+    /** Whether the flipbook is in right-to-left mode */
+    rightToLeft?: boolean;
+    /** Callback when page should change */
+    onPageChange: (page: number) => void;
+    /** Callback when autoplay starts */
+    onStart?: () => void;
+    /** Callback when autoplay stops */
+    onStop?: () => void;
+    /** Callback when autoplay pauses */
+    onPause?: () => void;
+    /** Callback when autoplay resumes */
+    onResume?: () => void;
+    /** Callback when autoplay completes (reaches end without loop) */
+    onComplete?: () => void;
+}
+interface UseAutoplayReturn {
+    /** Whether autoplay is currently active */
+    isPlaying: boolean;
+    /** Whether autoplay is paused */
+    isPaused: boolean;
+    /** Current autoplay interval in milliseconds */
+    interval: number;
+    /** Time remaining until next page flip (ms) */
+    timeRemaining: number;
+    /** Progress through current interval (0-1) */
+    progress: number;
+    /** Start autoplay */
+    start: () => void;
+    /** Stop autoplay completely */
+    stop: () => void;
+    /** Pause autoplay (can resume) */
+    pause: () => void;
+    /** Resume paused autoplay */
+    resume: () => void;
+    /** Toggle between play and pause */
+    toggle: () => void;
+    /** Set the autoplay interval */
+    setInterval: (ms: number) => void;
+    /** Skip to next page immediately */
+    skipNext: () => void;
+    /** Reset autoplay to beginning */
+    reset: () => void;
+}
+declare function useAutoplay(options: UseAutoplayOptions): UseAutoplayReturn;
+
+interface PDFDocumentProxy {
+    numPages: number;
+    getPage: (pageNumber: number) => Promise<PDFPageProxy>;
+    destroy: () => Promise<void>;
+}
+interface PDFPageProxy {
+    getViewport: (options: {
+        scale: number;
+        rotation?: number;
+    }) => PDFPageViewport;
+    render: (params: PDFRenderParams) => PDFRenderTask;
+    getTextContent: (params?: {
+        normalizeWhitespace?: boolean;
+    }) => Promise<PDFTextContent>;
+    cleanup: () => void;
+}
+interface PDFPageViewport {
+    width: number;
+    height: number;
+    scale: number;
+    rotation: number;
+    viewBox: number[];
+    transform: number[];
+    clone: (options?: {
+        scale?: number;
+        rotation?: number;
+    }) => PDFPageViewport;
+}
+interface PDFRenderParams {
+    canvasContext: CanvasRenderingContext2D;
+    viewport: PDFPageViewport;
+    enableWebGL?: boolean;
+    renderInteractiveForms?: boolean;
+    transform?: number[];
+}
+interface PDFRenderTask {
+    promise: Promise<void>;
+    cancel: () => void;
+}
+interface PDFTextContent {
+    items: PDFTextItem[];
+    styles: Record<string, unknown>;
+}
+interface PDFTextItem {
+    str: string;
+    dir: string;
+    transform: number[];
+    width: number;
+    height: number;
+    fontName: string;
+}
+interface PDFDocumentLoadingTask {
+    promise: Promise<PDFDocumentProxy>;
+    destroy: () => Promise<void>;
+    onProgress?: (progress: {
+        loaded: number;
+        total: number;
+    }) => void;
+}
+interface PDFJSLib {
+    getDocument: (src: string | {
+        url: string;
+        [key: string]: unknown;
+    } | ArrayBuffer | Uint8Array) => PDFDocumentLoadingTask;
+    GlobalWorkerOptions: {
+        workerSrc: string;
+    };
+    version: string;
+}
+declare global {
+    interface Window {
+        pdfjsLib?: PDFJSLib;
+    }
+}
+interface UsePdfLoaderOptions {
+    /** PDF file URL or ArrayBuffer */
+    source: string | ArrayBuffer | Uint8Array | null;
+    /** PDF.js worker source URL (required for PDF.js to work) */
+    workerSrc?: string;
+    /** Scale factor for rendering pages (default: 1.5) */
+    scale?: number;
+    /** Whether to extract text content for search */
+    extractText?: boolean;
+    /** Maximum texture size for page rendering */
+    maxTextureSize?: number;
+    /** Callback when loading starts */
+    onLoadStart?: () => void;
+    /** Callback for loading progress */
+    onLoadProgress?: (progress: number) => void;
+    /** Callback when loading completes */
+    onLoadComplete?: (numPages: number) => void;
+    /** Callback when loading fails */
+    onLoadError?: (error: Error) => void;
+    /** Callback when a page is rendered */
+    onPageRendered?: (pageNumber: number, dataUrl: string) => void;
+}
+interface UsePdfLoaderReturn {
+    /** Whether PDF.js is available */
+    isAvailable: boolean;
+    /** Whether the PDF is currently loading */
+    isLoading: boolean;
+    /** Loading progress (0-1) */
+    progress: number;
+    /** Any error that occurred during loading */
+    error: Error | null;
+    /** Number of pages in the PDF */
+    numPages: number;
+    /** Generated flipbook pages */
+    pages: FlipbookPage[];
+    /** Text content extracted from pages (for search) */
+    textContent: Map<number, string>;
+    /** Load a PDF from a source */
+    loadPdf: (source: string | ArrayBuffer | Uint8Array) => Promise<void>;
+    /** Render a specific page to canvas/image */
+    renderPage: (pageNumber: number, options?: {
+        scale?: number;
+        format?: "png" | "jpeg";
+        quality?: number;
+    }) => Promise<string>;
+    /** Get text content from a specific page */
+    getPageText: (pageNumber: number) => Promise<string>;
+    /** Cleanup and destroy the PDF document */
+    destroy: () => void;
+}
+declare function usePdfLoader(options?: UsePdfLoaderOptions): UsePdfLoaderReturn;
+
+interface FlipbookSizeOptions {
+    /** Maximum width constraint for the container (default: 1200) */
+    maxWidth?: number;
+    /** Maximum height constraint for the container (default: 900) */
+    maxHeight?: number;
+    /** Whether the flipbook is in single-page mode (default: false) */
+    singlePageMode?: boolean;
+}
+interface FlipbookSize {
+    /** Calculated container width in pixels */
+    width: number;
+    /** Calculated container height in pixels */
+    height: number;
+    /** The aspect ratio of the container (width / height) */
+    aspectRatio: number;
+    /** Whether the page is landscape orientation */
+    isLandscape: boolean;
+}
+/**
+ * Calculate optimal flipbook container size based on page dimensions
+ *
+ * This function calculates the best container size that:
+ * - Maintains the PDF page aspect ratio
+ * - Fits within the specified max width/height constraints
+ * - Accounts for single-page vs two-page spread modes
+ *
+ * @param pageWidth - The PDF page width (in points or pixels)
+ * @param pageHeight - The PDF page height (in points or pixels)
+ * @param options - Sizing options
+ * @returns Calculated container dimensions
+ *
+ * @example
+ * ```typescript
+ * // Get first page info from PDF
+ * const pdfInfo = await getPdfInfo('document.pdf');
+ * const firstPage = pdfInfo.pageInfos[0];
+ *
+ * // Calculate optimal size for single-page mode
+ * const size = calculateFlipbookSize(firstPage.width, firstPage.height, {
+ *   singlePageMode: true,
+ *   maxWidth: 800,
+ *   maxHeight: 600,
+ * });
+ *
+ * // Use with Flipbook component
+ * <Flipbook pages={pages} width={size.width} height={size.height} singlePageMode />
+ * ```
+ */
+declare function calculateFlipbookSize(pageWidth: number, pageHeight: number, options?: FlipbookSizeOptions): FlipbookSize;
+/**
+ * Calculate optimal flipbook size from a FlipbookPage array
+ * Uses the first page's dimensions for calculation
+ *
+ * @param pages - Array of FlipbookPage objects (must have at least one page with width/height)
+ * @param options - Sizing options
+ * @returns Calculated container dimensions, or null if pages don't have size info
+ *
+ * @example
+ * ```typescript
+ * const pages = await pdfToFlipbookPages('document.pdf');
+ * const size = calculateFlipbookSizeFromPages(pages, { singlePageMode: true });
+ *
+ * if (size) {
+ *   <Flipbook pages={pages} width={size.width} height={size.height} />
+ * }
+ * ```
+ */
+declare function calculateFlipbookSizeFromPages(pages: FlipbookPage[], options?: FlipbookSizeOptions): FlipbookSize | null;
+/**
+ * Set the PDF.js worker source URL
+ * Must be called before using any PDF functions
+ *
+ * @example
+ * // For Vite
+ * import workerSrc from 'pdfjs-dist/build/pdf.worker.mjs?url';
+ * setPdfWorkerSrc(workerSrc);
+ *
+ * // For CDN
+ * setPdfWorkerSrc('https://unpkg.com/pdfjs-dist@4.0.379/build/pdf.worker.mjs');
+ */
+declare function setPdfWorkerSrc(workerSrc: string): void;
+interface PdfToImagesOptions {
+    /** Scale factor for rendering (default: 2 for high DPI) */
+    scale?: number;
+    /** Image format: 'png' or 'jpeg' (default: 'png') */
+    format?: "png" | "jpeg";
+    /** JPEG quality 0-1 (default: 0.92) */
+    quality?: number;
+    /** Callback for progress updates */
+    onProgress?: (current: number, total: number) => void;
+    /** Specific page numbers to render (1-indexed). If not provided, renders all pages */
+    pageNumbers?: number[];
+}
+interface PdfPageInfo {
+    /** Page number (1-indexed) */
+    pageNumber: number;
+    /** Original PDF page width in points */
+    width: number;
+    /** Original PDF page height in points */
+    height: number;
+    /** Detected orientation */
+    orientation: "portrait" | "landscape";
+    /** Data URL of the rendered image */
+    dataUrl: string;
+}
+/**
+ * Load a PDF and convert pages to images
+ *
+ * @param source - PDF source: URL string, ArrayBuffer, or Uint8Array
+ * @param options - Conversion options
+ * @returns Promise resolving to array of FlipbookPage objects
+ *
+ * @example
+ * ```typescript
+ * import { pdfToFlipbookPages, setPdfWorkerSrc } from 'react-3d-flipbook/utils';
+ *
+ * // Set up worker first
+ * setPdfWorkerSrc('https://unpkg.com/pdfjs-dist@4.0.379/build/pdf.worker.mjs');
+ *
+ * // Convert PDF to flipbook pages
+ * const pages = await pdfToFlipbookPages('https://example.com/document.pdf', {
+ *   scale: 2,
+ *   onProgress: (current, total) => console.log(`Rendering page ${current}/${total}`)
+ * });
+ *
+ * // Use with Flipbook component
+ * <Flipbook pages={pages} width={800} height={600} />
+ * ```
+ */
+declare function pdfToFlipbookPages(source: string | ArrayBuffer | Uint8Array, options?: PdfToImagesOptions): Promise<FlipbookPage[]>;
+/**
+ * Get PDF document info without rendering pages
+ */
+declare function getPdfInfo(source: string | ArrayBuffer | Uint8Array): Promise<{
+    numPages: number;
+    pageInfos: Array<{
+        pageNumber: number;
+        width: number;
+        height: number;
+        orientation: "portrait" | "landscape";
+    }>;
+}>;
+/**
+ * Load PDF pages lazily (one at a time) for memory efficiency
+ * Returns an async generator that yields pages one by one
+ *
+ * @example
+ * ```typescript
+ * const pages: FlipbookPage[] = [];
+ * for await (const page of pdfToFlipbookPagesLazy(pdfUrl)) {
+ *   pages.push(page);
+ *   // Update UI progressively
+ *   setPages([...pages]);
+ * }
+ * ```
+ */
+declare function pdfToFlipbookPagesLazy(source: string | ArrayBuffer | Uint8Array, options?: PdfToImagesOptions): AsyncGenerator<FlipbookPage, void, unknown>;
+
+/**
+ * Clamp a value between min and max
+ */
+declare function clamp(value: number, min: number, max: number): number;
+/**
+ * Linear interpolation between two values
+ */
+declare function lerp(start: number, end: number, t: number): number;
+/**
+ * Convert degrees to radians
+ */
+declare function degToRad(degrees: number): number;
+/**
+ * Convert radians to degrees
+ */
+declare function radToDeg(radians: number): number;
+/**
+ * Debounce a function
+ */
+declare function debounce<T extends (...args: never[]) => void>(func: T, wait: number): (...args: Parameters<T>) => void;
+/**
+ * Throttle a function
+ */
+declare function throttle<T extends (...args: unknown[]) => unknown>(func: T, limit: number): (...args: Parameters<T>) => void;
+/**
+ * Check if a value is a number
+ */
+declare function isNumber(value: unknown): value is number;
+/**
+ * Check if running on mobile device
+ */
+declare function isMobile(): boolean;
+/**
+ * Check if touch device
+ */
+declare function isTouchDevice(): boolean;
+/**
+ * Check if WebGL is supported
+ */
+declare function isWebGLSupported(): boolean;
+/**
+ * Get the aspect ratio of an image
+ */
+declare function getImageAspectRatio(width: number, height: number): number;
+/**
+ * Calculate page dimensions based on container and aspect ratio
+ */
+declare function calculatePageDimensions(containerWidth: number, containerHeight: number, pageAspectRatio: number, isDoublePage?: boolean): {
+    width: number;
+    height: number;
+};
+/**
+ * Preload an image
+ */
+declare function preloadImage(src: string): Promise<HTMLImageElement>;
+/**
+ * Preload multiple images
+ */
+declare function preloadImages(srcs: string[], onProgress?: (loaded: number, total: number) => void): Promise<HTMLImageElement[]>;
+/**
+ * Generate a unique ID
+ */
+declare function generateId(prefix?: string): string;
+/**
+ * Get element offset relative to document
+ */
+declare function getElementOffset(element: HTMLElement): {
+    top: number;
+    left: number;
+};
+/**
+ * Request fullscreen for an element
+ */
+declare function requestFullscreen(element: HTMLElement): Promise<void>;
+/**
+ * Exit fullscreen
+ */
+declare function exitFullscreen(): Promise<void>;
+/**
+ * Check if currently in fullscreen mode
+ */
+declare function isFullscreen(): boolean;
+/**
+ * Get fullscreen element
+ */
+declare function getFullscreenElement(): Element | null;
+/**
+ * Format page number for display
+ */
+declare function formatPageNumber(page: number, totalPages: number, offset?: number): string;
+/**
+ * Parse page number from URL hash
+ */
+declare function getPageFromHash(prefix?: string): number | null;
+/**
+ * Set page number in URL hash
+ */
+declare function setPageHash(page: number, prefix?: string): void;
+/**
+ * Clear URL hash
+ */
+declare function clearHash(): void;
+/**
+ * Local storage helpers
+ */
+declare const storage: {
+    get<T>(key: string, defaultValue: T): T;
+    set<T>(key: string, value: T): void;
+    remove(key: string): void;
+};
+/**
+ * Easing functions for animations
+ */
+declare const easing: {
+    linear: (t: number) => number;
+    easeInQuad: (t: number) => number;
+    easeOutQuad: (t: number) => number;
+    easeInOutQuad: (t: number) => number;
+    easeInCubic: (t: number) => number;
+    easeOutCubic: (t: number) => number;
+    easeInOutCubic: (t: number) => number;
+    easeInQuart: (t: number) => number;
+    easeOutQuart: (t: number) => number;
+    easeInOutQuart: (t: number) => number;
+    easeInSine: (t: number) => number;
+    easeOutSine: (t: number) => number;
+    easeInOutSine: (t: number) => number;
+    easeInExpo: (t: number) => number;
+    easeOutExpo: (t: number) => number;
+    easeInOutExpo: (t: number) => number;
+};
+
+export { BookmarksPanel, Flipbook, SearchPanel, TableOfContents, ThumbnailsPanel, WebGLPageFlip, calculateFlipbookSize, calculateFlipbookSizeFromPages, calculatePageDimensions, clamp, clearHash, debounce, degToRad, easing, exitFullscreen, formatPageNumber, generateId, getElementOffset, getFullscreenElement, getImageAspectRatio, getPageFromHash, getPdfInfo, isFullscreen, isMobile, isNumber, isTouchDevice, isWebGLSupported, lerp, pdfToFlipbookPages, pdfToFlipbookPagesLazy, preloadImage, preloadImages, radToDeg, requestFullscreen, setPageHash, setPdfWorkerSrc, storage, throttle, useAutoplay, useFlipbook, usePdfLoader, useResizeObserver, useSwipeGesture, useWheelZoom };
+export type { AssetsConfig, Bookmark, BookmarksPanelProps, ButtonConfig, CloseButtonConfig, CurrentPageConfig, DownloadButtonConfig, FillPreloaderConfig, FlipbookContextValue, FlipbookEventMap, FlipbookInstance, FlipbookOptions, FlipbookPage, FlipbookProps, FlipbookSize, FlipbookSizeOptions, HAlign, LayoutType, LightboxConfig, LocalizationStrings, MobileConfig, PdfConfig, PdfPageInfo, PdfToImagesOptions, SearchPanelProps, SearchResult, ShareConfig, ShareProviderConfig, SkinType, TableOfContentsProps, ThumbnailsPanelProps, TocItem, UseAutoplayOptions, UseAutoplayReturn, UseFlipbookReturn$1 as UseFlipbookReturn, UsePdfLoaderOptions, UsePdfLoaderReturn, VAlign, ViewMode, WebGLPageFlipInstance, WebGLPageFlipProps };