react-pdfjs-multi 0.5.1 → 1.0.0-rc.1

package/dist/index.mjs

@@ -0,0 +1,826 @@
+import { t as PdfjsLib } from "./pdfjsLib-DgdIcD_k.mjs";
+import React, { Fragment, forwardRef, useCallback, useContext, useEffect, useImperativeHandle, useRef, useState } from "react";
+import "pdfjs-dist/web/pdf_viewer.css";
+import { jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/lib/resizeAutoZoomEvent.ts
+(() => {
+	const throttle = (type, name) => {
+		let running = false;
+		const func = () => {
+			if (running) return;
+			running = true;
+			requestAnimationFrame(() => {
+				window.dispatchEvent(new Event(name));
+				running = false;
+			});
+		};
+		window.addEventListener(type, func);
+	};
+	throttle("resize", "resizeAutoZoom");
+})();
+
+//#endregion
+//#region src/contexts/I18nContext.tsx
+const defaultI18n = {
+	zoom: "Automatic zoom",
+	originalSize: "Original size",
+	scaleUp: "Scale up",
+	scaleDown: "Scale down",
+	rotateLeft: "Rotate left",
+	rotateRight: "Rotate right",
+	download: "Download"
+};
+const I18nContext = React.createContext(defaultI18n);
+
+//#endregion
+//#region src/components/PdfRenderer/ZoomSelectBox.tsx
+const createSelectOptions = ({ originalSize, zoom }) => [
+	{
+		id: "automated",
+		text: `${zoom}`
+	},
+	{
+		id: "50-percent",
+		text: "50%",
+		value: 50
+	},
+	{
+		id: "75-percent",
+		text: "75%",
+		value: 75
+	},
+	{
+		id: "original",
+		text: `${originalSize} (100%)`,
+		value: 100
+	},
+	{
+		id: "125-percent",
+		text: "125%",
+		value: 125
+	},
+	{
+		id: "150-percent",
+		text: "150%",
+		value: 150
+	},
+	{
+		id: "200-percent",
+		text: "200%",
+		value: 200
+	},
+	{
+		id: "300-percent",
+		text: "300%",
+		value: 300
+	},
+	{
+		id: "400-percent",
+		text: "400%",
+		value: 400
+	},
+	{ id: "calculated" }
+];
+const showCalculatedScale = (scale, i18nData) => {
+	return createSelectOptions(i18nData).filter((option) => option.value === scale).length === 0 && scale % 10 === 0 ? scale : 0;
+};
+const ZoomSelectBox = ({ autoZoom, scale, setScale }) => {
+	const i18nData = useContext(I18nContext);
+	return /* @__PURE__ */ jsx("div", {
+		className: "dropdown-toolbar-container",
+		children: /* @__PURE__ */ jsx("span", {
+			className: "dropdown-toolbar",
+			children: /* @__PURE__ */ jsx("select", {
+				value: scale,
+				onChange: (e) => {
+					setScale(parseInt(e.target.value, 10));
+				},
+				children: createSelectOptions(i18nData).map(({ id, text, value }) => {
+					switch (id) {
+						case "calculated": return /* @__PURE__ */ jsx("option", {
+							value: showCalculatedScale(scale, i18nData),
+							hidden: true,
+							disabled: true,
+							children: `${scale}%`
+						}, `${id}-${scale}`);
+						case "automated": return autoZoom && /* @__PURE__ */ jsx("option", {
+							value: -1,
+							children: text
+						}, `${id}-${scale}`);
+						default: return /* @__PURE__ */ jsx("option", {
+							value,
+							children: text
+						}, id);
+					}
+				})
+			})
+		})
+	});
+};
+var ZoomSelectBox_default = ZoomSelectBox;
+
+//#endregion
+//#region src/components/PdfRenderer/PdfRendererControls.tsx
+const PdfControls = ({ autoZoom, downloadBtn, onDownload, onZoomIn, onZoomOut, onRotateRight, onRotateLeft, scale, setScale }) => /* @__PURE__ */ jsx("div", {
+	className: "renderer-controls",
+	children: /* @__PURE__ */ jsxs("div", { children: [
+		/* @__PURE__ */ jsx(I18nContext.Consumer, { children: ({ scaleDown, scaleUp }) => /* @__PURE__ */ jsxs("div", {
+			className: "button-group",
+			children: [
+				/* @__PURE__ */ jsx("button", {
+					className: "renderer-controls-button",
+					type: "button",
+					onClick: onZoomOut,
+					"aria-label": scaleDown,
+					children: /* @__PURE__ */ jsx("span", {
+						className: "zoom-out-label",
+						"aria-hidden": "true"
+					})
+				}),
+				/* @__PURE__ */ jsx("div", { className: "split-button-seperator" }),
+				/* @__PURE__ */ jsx("button", {
+					className: "renderer-controls-button",
+					type: "button",
+					onClick: onZoomIn,
+					"aria-label": scaleUp,
+					children: /* @__PURE__ */ jsx("span", {
+						className: "zoom-in-label",
+						"aria-hidden": "true"
+					})
+				})
+			]
+		}) }),
+		/* @__PURE__ */ jsx(ZoomSelectBox_default, {
+			autoZoom,
+			scale,
+			setScale
+		}),
+		/* @__PURE__ */ jsx(I18nContext.Consumer, { children: ({ rotateLeft, rotateRight, download }) => /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsxs("div", {
+			className: "button-group",
+			children: [
+				/* @__PURE__ */ jsx("button", {
+					className: "renderer-controls-button",
+					type: "button",
+					onClick: onRotateLeft,
+					"aria-label": rotateLeft,
+					children: /* @__PURE__ */ jsx("span", {
+						className: "rotate-left-label",
+						"aria-hidden": "true"
+					})
+				}),
+				/* @__PURE__ */ jsx("div", { className: "split-button-seperator" }),
+				/* @__PURE__ */ jsx("button", {
+					className: "renderer-controls-button",
+					type: "button",
+					onClick: onRotateRight,
+					"aria-label": rotateRight,
+					children: /* @__PURE__ */ jsx("span", {
+						className: "rotate-right-label",
+						"aria-hidden": "true"
+					})
+				})
+			]
+		}), downloadBtn && /* @__PURE__ */ jsx("div", {
+			className: "button-group",
+			children: /* @__PURE__ */ jsx("button", {
+				className: "renderer-controls-button",
+				type: "button",
+				onClick: onDownload,
+				"aria-label": download,
+				children: /* @__PURE__ */ jsx("span", {
+					className: "download-label",
+					"aria-hidden": "true"
+				})
+			})
+		})] }) })
+	] })
+});
+var PdfRendererControls_default = PdfControls;
+
+//#endregion
+//#region src/components/PdfRenderer/PdfRendererView.tsx
+const PdfRendererView = ({ autoZoom, containerRef, controls, downloadBtn, iconStyles, i18nData, isLoading, scale, setScale, onDownload, onRotateLeft, onRotateRight, onZoomIn, onZoomOut }) => /* @__PURE__ */ jsxs("div", {
+	className: "pdfjs-multi renderer-container",
+	style: iconStyles,
+	children: [controls && /* @__PURE__ */ jsx(I18nContext.Provider, {
+		value: {
+			...defaultI18n,
+			...i18nData ?? {}
+		},
+		children: /* @__PURE__ */ jsx(PdfRendererControls_default, {
+			autoZoom,
+			downloadBtn,
+			scale,
+			setScale,
+			onDownload,
+			onZoomIn,
+			onZoomOut,
+			onRotateRight,
+			onRotateLeft
+		})
+	}), /* @__PURE__ */ jsx("div", {
+		className: "renderer-stage",
+		children: /* @__PURE__ */ jsx("div", {
+			ref: containerRef,
+			className: `renderer-target-container ${!controls ? "no-controls" : ""} `,
+			children: /* @__PURE__ */ jsx("div", {
+				id: "viewer",
+				className: `pdfViewer ${isLoading ? "hidden" : ""}`
+			})
+		})
+	})]
+});
+var PdfRendererView_default = PdfRendererView;
+
+//#endregion
+//#region src/lib/filenameHelper.ts
+const isDataSchema = (url) => {
+	let i = 0, ii = url.length;
+	while (i < ii && url[i].trim() === "") i++;
+	return url.substring(i, i + 5).toLowerCase() === "data:";
+};
+const getPDFFileNameFromURL = (url, defaultFilename = "document.pdf") => {
+	if (typeof url !== "string") return defaultFilename;
+	if (isDataSchema(url)) {
+		console.warn("getPDFFileNameFromURL: ignoring \"data:\" URL for performance reasons.");
+		return defaultFilename;
+	}
+	const reURI = /^(?:(?:[^:]+:)?\/\/[^/]+)?([^?#]*)(\?[^#]*)?(#.*)?$/;
+	const reFilename = /[^/?#=]+\.pdf\b(?!.*\.pdf\b)/i;
+	const splitURI = reURI.exec(url);
+	let suggestedFilename = null;
+	if (splitURI) suggestedFilename = reFilename.exec(splitURI[1]) || reFilename.exec(splitURI[2]) || reFilename.exec(splitURI[3]);
+	if (suggestedFilename) {
+		suggestedFilename = suggestedFilename[0];
+		if (suggestedFilename.includes("%")) try {
+			const suggestedFilenameResult = reFilename.exec(decodeURIComponent(suggestedFilename));
+			if (suggestedFilenameResult) suggestedFilename = suggestedFilenameResult[0];
+		} catch (_ex) {}
+	}
+	return suggestedFilename || defaultFilename;
+};
+
+//#endregion
+//#region src/components/PdfRenderer/usePdfRenderer.ts
+const SCALE = {
+	percent: 100,
+	min: 10,
+	max: 1e3,
+	roundTo: 10,
+	auto: -1,
+	default: 100
+};
+const AUTO_FIT = {
+	maxContainerWidth: 1020,
+	padding: 56,
+	fallbackWidth: 1019
+};
+const ZOOM = {
+	largeStepMin: 110,
+	largeStepMax: 990,
+	specialSteps: new Set([75, 125]),
+	roundingExceptions: new Set([125]),
+	stepLarge: 20,
+	stepDefault: 10,
+	stepSmall: 5
+};
+const ROTATION_STEP = 90;
+const SCROLL_DEFAULT = 0;
+const roundToNearest = (numToRound, numToRoundTo) => Math.round(numToRound / numToRoundTo) * numToRoundTo;
+const usePdfRenderer = ({ activeIndex, autoZoom, pdfChangeHook, pdfDoc, rotation, scrollLeft, scrollTop, zoom }) => {
+	const containerRef = useRef(null);
+	const pdfViewerRef = useRef(null);
+	const downloadManagerRef = useRef(null);
+	const initialAutoZoomRef = useRef(autoZoom);
+	const latestPdfDocRef = useRef(pdfDoc);
+	const [scale, setScaleState] = useState(SCALE.default);
+	const [isLoading, setIsLoading] = useState(true);
+	const scaleRef = useRef(scale);
+	useEffect(() => {
+		scaleRef.current = scale;
+	}, [scale]);
+	useEffect(() => {
+		latestPdfDocRef.current = pdfDoc;
+	}, [pdfDoc]);
+	const applyScale = useCallback((nextScaleValue) => {
+		const nextScale = nextScaleValue >= SCALE.min ? nextScaleValue : SCALE.min;
+		setScaleState(nextScale);
+		if (pdfViewerRef.current) pdfViewerRef.current.currentScaleValue = String(nextScale / SCALE.percent);
+	}, []);
+	const autoFitScale = useCallback(() => {
+		const firstPage = pdfViewerRef.current?._pages?.[0];
+		if (!firstPage) return;
+		const originalWidth = firstPage.viewport.width / firstPage.scale;
+		const offsetWidth = containerRef.current?.offsetWidth;
+		const containerWidth = offsetWidth && offsetWidth < AUTO_FIT.maxContainerWidth ? offsetWidth - AUTO_FIT.padding : AUTO_FIT.fallbackWidth;
+		let nextScale = SCALE.auto;
+		if (containerRef.current) nextScale = Math.abs(containerWidth) / originalWidth;
+		applyScale(nextScale * SCALE.percent);
+	}, [applyScale]);
+	const setScale = useCallback((nextScaleValue) => {
+		if (autoZoom && nextScaleValue < 0) {
+			autoFitScale();
+			return;
+		}
+		applyScale(nextScaleValue);
+	}, [
+		applyScale,
+		autoFitScale,
+		autoZoom
+	]);
+	const setScrollTop = useCallback((nextScrollTop) => {
+		if (containerRef.current) containerRef.current.scrollTop = nextScrollTop ?? SCROLL_DEFAULT;
+	}, []);
+	const setScrollLeft = useCallback((nextScrollLeft) => {
+		if (containerRef.current) containerRef.current.scrollLeft = nextScrollLeft ?? SCROLL_DEFAULT;
+	}, []);
+	const rePosition = useCallback(async () => {
+		if (!pdfViewerRef.current) return;
+		await pdfViewerRef.current.firstPagePromise;
+		if (rotation) pdfViewerRef.current.pagesRotation = rotation;
+		if (zoom) setScale(zoom);
+		else if (!zoom && autoZoom) autoFitScale();
+		if (typeof scrollTop !== "undefined") setScrollTop(scrollTop ?? null);
+		if (typeof scrollLeft !== "undefined") setScrollLeft(scrollLeft ?? null);
+	}, [
+		autoFitScale,
+		autoZoom,
+		rotation,
+		scrollLeft,
+		scrollTop,
+		setScale,
+		setScrollLeft,
+		setScrollTop,
+		zoom
+	]);
+	const rePositionRef = useRef(rePosition);
+	useEffect(() => {
+		rePositionRef.current = rePosition;
+	}, [rePosition]);
+	useEffect(() => {
+		let cancelled = false;
+		const setupViewer = async () => {
+			const { PdfjsLib } = await import("./pdfjsLib-cEuHH6WZ.mjs");
+			if (cancelled) return;
+			globalThis.pdfjsLib = PdfjsLib;
+			const { PDFViewer, DownloadManager, EventBus } = globalThis.__pdfjsViewer ?? await import("pdfjs-dist/web/pdf_viewer.mjs");
+			downloadManagerRef.current = new DownloadManager();
+			if (!containerRef.current) return;
+			pdfViewerRef.current = new PDFViewer({
+				container: containerRef.current,
+				eventBus: new EventBus()
+			});
+			pdfViewerRef.current.setDocument(latestPdfDocRef.current);
+			if (initialAutoZoomRef.current) window.addEventListener("resizeAutoZoom", autoFitScale);
+			await rePositionRef.current();
+			if (!cancelled) setIsLoading(false);
+		};
+		setupViewer();
+		return () => {
+			cancelled = true;
+			if (initialAutoZoomRef.current) window.removeEventListener("resizeAutoZoom", autoFitScale);
+			pdfViewerRef.current = null;
+			downloadManagerRef.current = null;
+		};
+	}, [autoFitScale]);
+	const prevPdfDocRef = useRef(pdfDoc);
+	const prevActiveIndexRef = useRef(activeIndex);
+	useEffect(() => {
+		if (!pdfViewerRef.current) {
+			prevPdfDocRef.current = pdfDoc;
+			prevActiveIndexRef.current = activeIndex;
+			return;
+		}
+		if (prevPdfDocRef.current !== pdfDoc) {
+			if (typeof pdfChangeHook === "function") pdfChangeHook(String(prevActiveIndexRef.current), {
+				zoom: scaleRef.current,
+				rotation: pdfViewerRef.current.pagesRotation,
+				scrollTop: containerRef.current?.scrollTop ?? null,
+				scrollLeft: containerRef.current?.scrollLeft ?? null
+			});
+			pdfViewerRef.current.setDocument(pdfDoc);
+			rePosition();
+		}
+		prevPdfDocRef.current = pdfDoc;
+		prevActiveIndexRef.current = activeIndex;
+	}, [
+		activeIndex,
+		pdfChangeHook,
+		pdfDoc,
+		rePosition
+	]);
+	const zoomIn = useCallback(() => {
+		const nextScale = roundToNearest(scaleRef.current, SCALE.roundTo);
+		let newScale = nextScale;
+		if (nextScale >= ZOOM.largeStepMin && nextScale < ZOOM.largeStepMax) newScale = nextScale + ZOOM.stepLarge;
+		else if (ZOOM.specialSteps.has(nextScale)) newScale = nextScale + ZOOM.stepSmall;
+		else newScale = nextScale + ZOOM.stepDefault;
+		if (newScale > SCALE.max) return;
+		setScale(newScale);
+	}, [setScale]);
+	const zoomOut = useCallback(() => {
+		let nextScale = scaleRef.current;
+		nextScale = ZOOM.roundingExceptions.has(nextScale) ? nextScale : roundToNearest(nextScale, SCALE.roundTo);
+		let newScale = nextScale;
+		if (nextScale > ZOOM.largeStepMin && !ZOOM.specialSteps.has(nextScale)) newScale = nextScale - ZOOM.stepLarge;
+		else if (ZOOM.specialSteps.has(nextScale)) newScale = nextScale - ZOOM.stepSmall;
+		else newScale = nextScale - ZOOM.stepDefault;
+		if (newScale <= 0) return;
+		setScale(newScale);
+	}, [setScale]);
+	const rotateRight = useCallback(() => {
+		if (!pdfViewerRef.current) return;
+		const currentRotation = pdfViewerRef.current.pagesRotation;
+		pdfViewerRef.current.pagesRotation = currentRotation + ROTATION_STEP;
+	}, []);
+	const rotateLeft = useCallback(() => {
+		if (!pdfViewerRef.current) return;
+		const currentRotation = pdfViewerRef.current.pagesRotation;
+		pdfViewerRef.current.pagesRotation = currentRotation - ROTATION_STEP;
+	}, []);
+	return {
+		containerRef,
+		download: useCallback(async () => {
+			if (!downloadManagerRef.current) return;
+			const url = pdfDoc._transport?._params?.url;
+			let filename = getPDFFileNameFromURL(url ?? "");
+			if (typeof pdfDoc.getMetadata === "function") try {
+				const contentDispositionFilename = (await pdfDoc.getMetadata()).contentDispositionFilename;
+				if (typeof contentDispositionFilename === "string" && contentDispositionFilename.trim()) filename = contentDispositionFilename;
+			} catch (_error) {}
+			const downloadByUrl = () => {
+				if (!url) return;
+				downloadManagerRef.current.downloadUrl(url, filename);
+			};
+			try {
+				const data = await pdfDoc.getData();
+				downloadManagerRef.current.download(data, url ?? "", filename);
+			} catch (_e) {
+				downloadByUrl();
+			}
+		}, [pdfDoc]),
+		isLoading,
+		pdfViewerRef,
+		rotateLeft,
+		rotateRight,
+		scale,
+		setScale,
+		zoomIn,
+		zoomOut
+	};
+};
+
+//#endregion
+//#region src/lib/iconStyles.ts
+const iconVarMap = {
+	zoomIn: "--pdfjs-multi-control-icon-zoom-in",
+	zoomOut: "--pdfjs-multi-control-icon-zoom-out",
+	rotateLeft: "--pdfjs-multi-control-icon-rotate-left",
+	rotateRight: "--pdfjs-multi-control-icon-rotate-right",
+	download: "--pdfjs-multi-control-icon-download",
+	selectArrow: "--pdfjs-multi-select-icon",
+	toggleList: "--pdfjs-multi-control-icon-toggle-list",
+	texture: "--pdfjs-multi-texture"
+};
+const toCssValue = (value) => {
+	const trimmed = value.trim();
+	if (!trimmed) return void 0;
+	if (trimmed === "none") return "none";
+	if (/^[a-z-]+\(/i.test(trimmed)) return trimmed;
+	return `url("${trimmed.replaceAll("\"", "\\\"")}")`;
+};
+const buildIconStyles = (icons) => {
+	if (!icons) return void 0;
+	const style = {};
+	for (const [key, cssVar] of Object.entries(iconVarMap)) {
+		const iconValue = icons[key];
+		if (!iconValue) continue;
+		const cssValue = toCssValue(iconValue);
+		if (!cssValue) continue;
+		style[cssVar] = cssValue;
+	}
+	return Object.keys(style).length ? style : void 0;
+};
+
+//#endregion
+//#region src/components/PdfRenderer/PdfRenderer.tsx
+const PdfRenderer = forwardRef(({ pdfDoc, activeIndex = "0", autoZoom = true, controls = true, downloadBtn = true, icons, i18nData = defaultI18n, pdfChangeHook = null, zoom, rotation = 0, scrollTop = 0, scrollLeft = 0 }, ref) => {
+	const { containerRef, download, isLoading, pdfViewerRef, rotateLeft, rotateRight, scale, setScale, zoomIn, zoomOut } = usePdfRenderer({
+		activeIndex,
+		autoZoom,
+		pdfChangeHook,
+		pdfDoc,
+		rotation,
+		scrollLeft,
+		scrollTop,
+		zoom
+	});
+	useImperativeHandle(ref, () => ({ get pdfViewer() {
+		return pdfViewerRef.current;
+	} }));
+	return /* @__PURE__ */ jsx(PdfRendererView_default, {
+		autoZoom,
+		containerRef,
+		controls,
+		downloadBtn,
+		iconStyles: buildIconStyles(icons),
+		i18nData,
+		isLoading,
+		scale,
+		setScale,
+		onDownload: download,
+		onRotateLeft: rotateLeft,
+		onRotateRight: rotateRight,
+		onZoomIn: zoomIn,
+		onZoomOut: zoomOut
+	});
+});
+PdfRenderer.displayName = "PdfRenderer";
+var PdfRenderer_default = PdfRenderer;
+
+//#endregion
+//#region src/components/PdfMultiViewer/PdfMultiViewerView.tsx
+const PdfMultiViewerView = ({ activeIndex, autoZoom, controls, files, iconStyles, i18nData, listVisible, overlayMode, pdfToShow, viewerContainerRef, onRememberPosition, onSelectPdf, onToggleList }) => /* @__PURE__ */ jsxs("div", {
+	className: "pdfjs-multi pdf-multi-viewer",
+	ref: viewerContainerRef,
+	style: iconStyles,
+	children: [
+		/* @__PURE__ */ jsx("div", {
+			className: "pdf-multi-viewer-option-bar",
+			children: /* @__PURE__ */ jsx("button", {
+				className: `viewer-controls-button${listVisible ? " toggled" : ""}`,
+				onClick: onToggleList,
+				type: "button",
+				"aria-label": "Toggle list",
+				children: /* @__PURE__ */ jsx("span", {
+					className: "toggle-list-label",
+					"aria-hidden": "true"
+				})
+			})
+		}),
+		/* @__PURE__ */ jsx("ul", {
+			className: `pdf-viewer-list${!listVisible ? " hidden" : ""}${overlayMode ? " overlay" : ""}`,
+			children: files.map((file, index) => {
+				const handleSelect = onSelectPdf(String(index), file);
+				const isLoading = Boolean(file.isLoading && !file.pdfProxy);
+				return /* @__PURE__ */ jsx("li", {
+					className: `pdf-viewer-list-item${file.pdfProxy ? " loaded" : ""}${isLoading ? " loading" : ""}${activeIndex === String(index) ? " active" : ""}`,
+					children: /* @__PURE__ */ jsxs("button", {
+						className: "pdf-viewer-list-item-button",
+						onClick: handleSelect,
+						type: "button",
+						children: [
+							file.title || file.source,
+							file.pdfProxy && /* @__PURE__ */ jsxs("div", {
+								className: "pdf-viewer-list-item-meta",
+								children: [
+									i18nData?.pages ?? "Pages",
+									": ",
+									file.pdfProxy.numPages
+								]
+							}),
+							isLoading && !file.pdfProxy && /* @__PURE__ */ jsx("div", {
+								className: "pdf-viewer-list-item-meta",
+								children: i18nData?.loading ?? "Loading..."
+							})
+						]
+					})
+				}, file.source);
+			})
+		}),
+		/* @__PURE__ */ jsx("div", {
+			className: "pdf-viewer-multi-renderer",
+			children: pdfToShow?.pdfProxy ? /* @__PURE__ */ jsx(PdfRenderer_default, {
+				activeIndex,
+				autoZoom,
+				controls,
+				pdfDoc: pdfToShow.pdfProxy,
+				i18nData,
+				pdfChangeHook: onRememberPosition,
+				zoom: pdfToShow.zoom,
+				rotation: pdfToShow.rotation,
+				scrollTop: pdfToShow.scrollTop,
+				scrollLeft: pdfToShow.scrollLeft
+			}) : pdfToShow ? /* @__PURE__ */ jsxs("output", {
+				className: "pdf-viewer-loading",
+				"aria-live": "polite",
+				children: [/* @__PURE__ */ jsx("span", {
+					className: "pdf-viewer-loading-spinner",
+					"aria-hidden": "true"
+				}), /* @__PURE__ */ jsx("span", {
+					className: "pdf-viewer-loading-text",
+					children: i18nData?.loading ?? "Loading..."
+				})]
+			}) : null
+		})
+	]
+});
+var PdfMultiViewerView_default = PdfMultiViewerView;
+
+//#endregion
+//#region src/components/PdfMultiViewer/usePdfMultiViewer.ts
+const createPdfFile = (pdf) => {
+	return typeof pdf === "object" ? {
+		...pdf,
+		isLoading: false,
+		pdfProxy: null
+	} : {
+		isLoading: false,
+		source: pdf,
+		pdfProxy: null
+	};
+};
+const usePdfMultiViewer = ({ pdfs, startIndex, i18nData, lazyLoad, initialLoadIndex, workerSrc }) => {
+	const viewerContainerRef = useRef(null);
+	const initialFilesRef = useRef(null);
+	const workerRef = useRef(null);
+	const loadingIndicesRef = useRef(/* @__PURE__ */ new Set());
+	const initialLoadDoneRef = useRef(false);
+	const [files, setFiles] = useState(() => {
+		const mapped = pdfs.map(createPdfFile);
+		initialFilesRef.current = mapped;
+		return mapped;
+	});
+	const [activeIndex, setActiveIndex] = useState(() => `${startIndex}`);
+	const [listVisible, setListVisible] = useState(true);
+	const [overlayMode, setOverlayMode] = useState(false);
+	const resolveIndex = useCallback((index) => {
+		const resolved = Number(index);
+		return Number.isNaN(resolved) ? 0 : resolved;
+	}, []);
+	useEffect(() => {
+		if (workerSrc) {
+			PdfjsLib.GlobalWorkerOptions.workerSrc = workerSrc;
+			const worker = PdfjsLib.PDFWorker.create({});
+			workerRef.current = worker;
+			return () => {
+				worker.destroy();
+				if (workerRef.current === worker) workerRef.current = null;
+			};
+		}
+	}, [workerSrc]);
+	const toggleList = useCallback(() => {
+		setListVisible((state) => !state);
+	}, []);
+	const setFileLoading = useCallback((index, isLoading) => {
+		setFiles((state) => state.map((pdfFile, pdfIndex) => {
+			if (pdfIndex !== index) return pdfFile;
+			return {
+				...pdfFile,
+				isLoading
+			};
+		}));
+	}, []);
+	const loadPdfDocument = useCallback(async (file, index) => {
+		if (file.pdfProxy) return;
+		if (loadingIndicesRef.current.has(index)) return;
+		loadingIndicesRef.current.add(index);
+		setFileLoading(index, true);
+		try {
+			const worker = workerRef.current;
+			const pdfDoc = await PdfjsLib.getDocument({
+				url: file.source,
+				...worker ? { worker } : {}
+			}).promise;
+			setFiles((state) => state.map((pdfFile, pdfIndex) => {
+				if (pdfIndex !== index) return pdfFile;
+				return {
+					...pdfFile,
+					isLoading: false,
+					pdfProxy: pdfDoc
+				};
+			}));
+		} catch (_error) {
+			setFileLoading(index, false);
+		} finally {
+			loadingIndicesRef.current.delete(index);
+		}
+	}, [setFileLoading]);
+	const selectPdf = useCallback((nextIndex, file) => () => {
+		setActiveIndex(nextIndex);
+		if (lazyLoad && !file.pdfProxy) loadPdfDocument(file, Number(nextIndex));
+		if (overlayMode && listVisible) toggleList();
+	}, [
+		lazyLoad,
+		listVisible,
+		loadPdfDocument,
+		overlayMode,
+		toggleList
+	]);
+	const updateOverlayMode = useCallback((currentContainerWidth) => {
+		const containerWidth = currentContainerWidth || viewerContainerRef.current?.offsetWidth;
+		setOverlayMode((current) => {
+			if (containerWidth && containerWidth >= 330 && containerWidth <= 667 && !current) return true;
+			if (current && containerWidth && containerWidth > 667) return false;
+			return current;
+		});
+	}, []);
+	const onResizeEvent = useCallback(() => {
+		updateOverlayMode(viewerContainerRef.current?.offsetWidth);
+	}, [updateOverlayMode]);
+	const loadPdfDocuments = useCallback(() => {
+		(initialFilesRef.current ?? []).forEach(async (file, index) => {
+			await loadPdfDocument(file, index);
+		});
+	}, [loadPdfDocument]);
+	const rememberPosition = useCallback((index, position) => {
+		setFiles((state) => state.map((pdfFile, pdfIndex) => {
+			if (pdfIndex !== Number(index)) return pdfFile;
+			return {
+				...pdfFile,
+				...position
+			};
+		}));
+	}, []);
+	useEffect(() => {
+		window.addEventListener("resizeAutoZoom", onResizeEvent);
+		updateOverlayMode(viewerContainerRef.current?.offsetWidth);
+		if (!lazyLoad) loadPdfDocuments();
+		return () => {
+			window.removeEventListener("resizeAutoZoom", onResizeEvent);
+		};
+	}, [
+		lazyLoad,
+		loadPdfDocuments,
+		onResizeEvent,
+		updateOverlayMode
+	]);
+	useEffect(() => {
+		if (!lazyLoad) return;
+		const initialIndex = resolveIndex(initialLoadIndex ?? startIndex);
+		const nextFile = files[initialIndex];
+		if (!nextFile) return;
+		if (initialLoadDoneRef.current) return;
+		initialLoadDoneRef.current = true;
+		loadPdfDocument(nextFile, initialIndex);
+	}, [
+		files,
+		initialLoadIndex,
+		lazyLoad,
+		loadPdfDocument,
+		resolveIndex,
+		startIndex
+	]);
+	useEffect(() => {
+		if (!lazyLoad) return;
+		const nextIndex = resolveIndex(activeIndex);
+		const nextFile = files[nextIndex];
+		if (!nextFile) return;
+		loadPdfDocument(nextFile, nextIndex);
+	}, [
+		activeIndex,
+		files,
+		lazyLoad,
+		loadPdfDocument,
+		resolveIndex
+	]);
+	return {
+		activeIndex,
+		files,
+		i18nData,
+		listVisible,
+		overlayMode,
+		pdfToShow: files[Number(activeIndex)],
+		rememberPosition,
+		selectPdf,
+		toggleList,
+		viewerContainerRef
+	};
+};
+
+//#endregion
+//#region src/components/PdfMultiViewer/PdfMultiViewer.tsx
+const PdfMultiViewer = ({ pdfs, autoZoom = true, controls = true, icons, lazyLoad = true, initialLoadIndex, startIndex = "0", i18nData = {
+	loading: "Loading...",
+	pages: "Pages"
+}, workerSrc }) => {
+	const { activeIndex, files, listVisible, overlayMode, pdfToShow, rememberPosition, selectPdf, toggleList, viewerContainerRef } = usePdfMultiViewer({
+		i18nData,
+		pdfs,
+		startIndex,
+		lazyLoad,
+		initialLoadIndex,
+		workerSrc
+	});
+	return /* @__PURE__ */ jsx(PdfMultiViewerView_default, {
+		activeIndex,
+		autoZoom,
+		controls,
+		files,
+		iconStyles: buildIconStyles(icons),
+		i18nData,
+		listVisible,
+		onRememberPosition: rememberPosition,
+		onSelectPdf: selectPdf,
+		onToggleList: toggleList,
+		overlayMode,
+		pdfToShow,
+		viewerContainerRef
+	});
+};
+var PdfMultiViewer_default = PdfMultiViewer;
+
+//#endregion
+export { PdfMultiViewer_default as PdfMultiViewer, PdfRenderer_default as PdfRenderer, PdfjsLib };
+//# sourceMappingURL=index.mjs.map