react-3d-flipbook 1.1.1

package/dist/components/BookmarksPanel.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+import type { FlipbookPage } from '../types';
+export interface Bookmark {
+    page: number;
+    title?: string;
+    createdAt: Date;
+    note?: string;
+}
+export 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.FC<BookmarksPanelProps>;
+export default BookmarksPanel;

package/dist/components/Flipbook.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+import type { FlipbookProps, FlipbookInstance } from "../types";
+import "../styles/flipbook.css";
+declare const Flipbook: React.ForwardRefExoticComponent<FlipbookProps & React.RefAttributes<FlipbookInstance>>;
+export default Flipbook;

package/dist/components/SearchPanel.d.ts

@@ -0,0 +1,26 @@
+import React from "react";
+import type { FlipbookPage } from "../types";
+export interface SearchResult {
+    pageNumber: number;
+    pageIndex: number;
+    text: string;
+    matchIndex: number;
+    contextBefore: string;
+    contextAfter: string;
+}
+export 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.FC<SearchPanelProps>;
+export default SearchPanel;

package/dist/components/TableOfContents.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import type { TocItem } from '../types';
+export interface TableOfContentsProps {
+    items: TocItem[];
+    currentPage: number;
+    isOpen: boolean;
+    position?: 'left' | 'right';
+    closeOnClick?: boolean;
+    onPageSelect: (page: number) => void;
+    onClose: () => void;
+}
+declare const TableOfContents: React.FC<TableOfContentsProps>;
+export default TableOfContents;

package/dist/components/ThumbnailsPanel.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import type { FlipbookPage } from '../types';
+export 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.FC<ThumbnailsPanelProps>;
+export default ThumbnailsPanel;

package/dist/components/WebGLPageFlip.d.ts

@@ -0,0 +1,46 @@
+import type { FlipbookPage } from "../types";
+export 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;
+}
+export interface WebGLPageFlipInstance {
+    flipNext: () => void;
+    flipPrev: () => void;
+    flipToPage: (page: number) => void;
+    flipToFirst: () => void;
+    flipToLast: () => void;
+    isFlipping: () => boolean;
+    dispose: () => void;
+}
+declare const WebGLPageFlip: import("react").ForwardRefExoticComponent<WebGLPageFlipProps & import("react").RefAttributes<WebGLPageFlipInstance>>;
+export default WebGLPageFlip;

package/dist/components/index.d.ts

@@ -0,0 +1,12 @@
+export { default as Flipbook } from "./Flipbook";
+export type { default as FlipbookComponent } from "./Flipbook";
+export { default as WebGLPageFlip } from "./WebGLPageFlip";
+export type { WebGLPageFlipProps, WebGLPageFlipInstance, } from "./WebGLPageFlip";
+export { default as ThumbnailsPanel } from "./ThumbnailsPanel";
+export type { ThumbnailsPanelProps } from "./ThumbnailsPanel";
+export { default as TableOfContents } from "./TableOfContents";
+export type { TableOfContentsProps } from "./TableOfContents";
+export { default as SearchPanel } from "./SearchPanel";
+export type { SearchPanelProps, SearchResult } from "./SearchPanel";
+export { default as BookmarksPanel } from "./BookmarksPanel";
+export type { BookmarksPanelProps, Bookmark } from "./BookmarksPanel";

package/dist/hooks/index.d.ts

@@ -0,0 +1,5 @@
+export { useFlipbook, useSwipeGesture, useWheelZoom, useResizeObserver, } from "./useFlipbook";
+export { useAutoplay } from "./useAutoplay";
+export type { UseAutoplayOptions, UseAutoplayReturn } from "./useAutoplay";
+export { usePdfLoader } from "./usePdfLoader";
+export type { UsePdfLoaderOptions, UsePdfLoaderReturn } from "./usePdfLoader";

package/dist/hooks/useAutoplay.d.ts

@@ -0,0 +1,58 @@
+export 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;
+}
+export 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;
+}
+export declare function useAutoplay(options: UseAutoplayOptions): UseAutoplayReturn;
+export default useAutoplay;

package/dist/hooks/useFlipbook.d.ts

@@ -0,0 +1,48 @@
+import type { FlipbookInstance, FlipbookOptions, FlipbookPage } from "../types";
+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;
+}
+export declare function useFlipbook(options: UseFlipbookOptions): UseFlipbookReturn;
+export declare function useSwipeGesture(containerRef: React.RefObject<HTMLElement>, onSwipeLeft: () => void, onSwipeRight: () => void, options?: {
+    threshold?: number;
+    enabled?: boolean;
+}): void;
+export declare function useWheelZoom(containerRef: React.RefObject<HTMLElement>, onZoom: (delta: number) => void, options?: {
+    enabled?: boolean;
+    sensitivity?: number;
+}): void;
+export declare function useResizeObserver(ref: React.RefObject<HTMLElement>, callback: (entry: ResizeObserverEntry) => void): void;
+export {};

package/dist/hooks/usePdfLoader.d.ts

@@ -0,0 +1,127 @@
+import type { FlipbookPage } from "../types";
+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;
+    }
+}
+export 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;
+}
+export 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;
+}
+export declare function usePdfLoader(options?: UsePdfLoaderOptions): UsePdfLoaderReturn;
+export default usePdfLoader;