web-mojo 2.1.46

package/dist/chunks/PDFViewer-Dyo-Oeyd.js

@@ -0,0 +1,946 @@
+import { V as View } from "./WebApp-B6mgbNn2.js";
+import Dialog from "./Dialog-DSlctbon.js";
+class LightboxGallery extends View {
+  constructor(options = {}) {
+    super({
+      ...options,
+      className: `lightbox-gallery ${options.className || ""}`,
+      tagName: "div"
+    });
+    const rawImages = Array.isArray(options.images) ? options.images : [options.images || options.src].filter(Boolean);
+    this.images = rawImages.map((img) => {
+      if (typeof img === "string") {
+        return { src: img, alt: "" };
+      }
+      return { src: img.src, alt: img.alt || "" };
+    });
+    this.currentIndex = options.startIndex || 0;
+    this.showNavigation = options.showNavigation !== false && this.images.length > 1;
+    this.showCounter = options.showCounter !== false && this.images.length > 1;
+    this.allowKeyboard = options.allowKeyboard !== false;
+    this.closeOnBackdrop = options.closeOnBackdrop !== false;
+    this.fitToScreen = options.fitToScreen !== false;
+    this._keyboardHandler = this.handleKeyboard.bind(this);
+    this.updateTemplateProperties();
+  }
+  updateTemplateProperties() {
+    this.currentImage = this.images[this.currentIndex] || { src: "", alt: "" };
+    this.currentNumber = this.currentIndex + 1;
+    this.total = this.images.length;
+    this.isFirst = this.currentIndex === 0;
+    this.isLast = this.currentIndex === this.images.length - 1;
+    this.imageStyle = this.fitToScreen ? "width: 90vw; max-height: 100%; object-fit: contain; user-select: none; cursor: zoom-in;" : "max-width: none; max-height: none; user-select: none; cursor: zoom-out;";
+    this.containerStyle = this.fitToScreen ? "" : "overflow: auto;";
+    this.modeIndicator = this.fitToScreen ? "Fit to Screen" : "Original Size";
+  }
+  async getTemplate() {
+    this.images[this.currentIndex];
+    this.images.length > 1;
+    return `
+      <div class="lightbox-overlay position-fixed top-0 start-0 w-100 h-100 d-flex align-items-center justify-content-center"
+           style="background: rgba(0,0,0,0.9); z-index: 9999;"
+           data-action="backdrop-click">
+
+        <!-- Close button -->
+        <button type="button" class="btn-close btn-close-white position-absolute top-0 end-0 m-4"
+                data-action="close"
+                style="z-index: 10001;"
+                title="Close"></button>
+
+        <!-- Counter -->
+        {{#showCounter}}
+        <div class="lightbox-counter position-absolute top-0 start-50 translate-middle-x mt-4 text-white"
+             style="z-index: 10001; font-size: 1.1rem;">
+          {{currentNumber}} of {{total}}
+        </div>
+        {{/showCounter}}
+
+        <!-- Mode Indicator -->
+        <div class="lightbox-mode-indicator position-absolute bottom-0 start-50 translate-middle-x mb-4 text-white bg-dark bg-opacity-75 px-3 py-2 rounded"
+             style="z-index: 10001; font-size: 0.9rem;">
+          {{modeIndicator}} • Click image to toggle
+        </div>
+
+        <!-- Navigation -->
+        {{#showNavigation}}
+        <button type="button" class="btn btn-light btn-lg position-absolute start-0 top-50 translate-middle-y ms-4"
+                data-action="prev"
+                style="z-index: 10001;"
+                title="Previous"
+                {{#isFirst}}disabled{{/isFirst}}>
+          <i class="bi bi-chevron-left"></i>
+        </button>
+
+        <button type="button" class="btn btn-light btn-lg position-absolute end-0 top-50 translate-middle-y me-4"
+                data-action="next"
+                style="z-index: 10001;"
+                title="Next"
+                {{#isLast}}disabled{{/isLast}}>
+          <i class="bi bi-chevron-right"></i>
+        </button>
+        {{/showNavigation}}
+
+        <!-- Image container -->
+        <div class="lightbox-image-container w-100 h-100 d-flex align-items-center justify-content-center p-5"
+             style="{{containerStyle}}">
+          {{#currentImage}}
+          <img src="{{src}}"
+               alt="{{alt}}"
+               class="lightbox-image img-fluid"
+               style="{{imageStyle}}"
+               data-action="image-click">
+          {{/currentImage}}
+        </div>
+
+        <!-- Loading spinner -->
+        <div class="lightbox-loading position-absolute top-50 start-50 translate-middle text-white"
+             style="display: none;">
+          <div class="spinner-border" role="status">
+            <span class="visually-hidden">Loading...</span>
+          </div>
+        </div>
+      </div>
+    `;
+  }
+  async onAfterRender() {
+    document.body.appendChild(this.element);
+    document.body.style.overflow = "hidden";
+    if (this.allowKeyboard) {
+      document.addEventListener("keydown", this._keyboardHandler);
+    }
+    this.preloadAdjacentImages();
+  }
+  // Action handlers
+  async handleActionClose() {
+    this.close();
+  }
+  async handleActionBackdropClick(e) {
+    if (this.closeOnBackdrop && e.target === e.currentTarget) {
+      this.close();
+    }
+  }
+  async handleActionPrev() {
+    this.showPrevious();
+  }
+  async handleActionNext() {
+    this.showNext();
+  }
+  async handleActionImageClick() {
+    this.toggleImageMode();
+  }
+  // Navigation methods
+  showPrevious() {
+    if (this.currentIndex > 0) {
+      this.currentIndex--;
+      this.updateImage();
+      this.preloadAdjacentImages();
+    }
+  }
+  showNext() {
+    if (this.currentIndex < this.images.length - 1) {
+      this.currentIndex++;
+      this.updateImage();
+      this.preloadAdjacentImages();
+    }
+  }
+  goToImage(index) {
+    if (index >= 0 && index < this.images.length && index !== this.currentIndex) {
+      this.currentIndex = index;
+      this.updateImage();
+      this.preloadAdjacentImages();
+    }
+  }
+  // Update image without full re-render
+  async updateImage() {
+    const currentImage = this.images[this.currentIndex];
+    const imgElement = this.element.querySelector(".lightbox-image");
+    const counterElement = this.element.querySelector(".lightbox-counter");
+    const prevBtn = this.element.querySelector('[data-action="prev"]');
+    const nextBtn = this.element.querySelector('[data-action="next"]');
+    if (imgElement) {
+      this.showLoading();
+      imgElement.src = currentImage.src;
+      imgElement.alt = currentImage.alt;
+      await this.waitForImageLoad(imgElement);
+      this.hideLoading();
+    }
+    if (counterElement) {
+      counterElement.textContent = `${this.currentIndex + 1} of ${this.images.length}`;
+    }
+    if (prevBtn) {
+      prevBtn.disabled = this.currentIndex === 0;
+    }
+    if (nextBtn) {
+      nextBtn.disabled = this.currentIndex === this.images.length - 1;
+    }
+    this.updateTemplateProperties();
+    this.updateImageDisplay();
+    const eventBus = this.getApp()?.events;
+    if (eventBus) {
+      eventBus.emit("lightbox:image-changed", {
+        gallery: this,
+        index: this.currentIndex,
+        image: currentImage
+      });
+    }
+  }
+  showLoading() {
+    const loading = this.element.querySelector(".lightbox-loading");
+    if (loading) {
+      loading.style.display = "block";
+    }
+  }
+  hideLoading() {
+    const loading = this.element.querySelector(".lightbox-loading");
+    if (loading) {
+      loading.style.display = "none";
+    }
+  }
+  waitForImageLoad(imgElement) {
+    return new Promise((resolve) => {
+      if (imgElement.complete) {
+        resolve();
+      } else {
+        imgElement.onload = resolve;
+        imgElement.onerror = resolve;
+      }
+    });
+  }
+  // Preload adjacent images for smooth navigation
+  preloadAdjacentImages() {
+    const preloadIndexes = [];
+    if (this.currentIndex > 0) {
+      preloadIndexes.push(this.currentIndex - 1);
+    }
+    if (this.currentIndex < this.images.length - 1) {
+      preloadIndexes.push(this.currentIndex + 1);
+    }
+    preloadIndexes.forEach((index) => {
+      const image = this.images[index];
+      const preloadImg = new Image();
+      preloadImg.src = image.src;
+    });
+  }
+  // Keyboard navigation
+  handleKeyboard(e) {
+    switch (e.key) {
+      case "Escape":
+        e.preventDefault();
+        this.close();
+        break;
+      case "ArrowLeft":
+        e.preventDefault();
+        this.showPrevious();
+        break;
+      case "ArrowRight":
+        e.preventDefault();
+        this.showNext();
+        break;
+      case "Home":
+        e.preventDefault();
+        this.goToImage(0);
+        break;
+      case "End":
+        e.preventDefault();
+        this.goToImage(this.images.length - 1);
+        break;
+    }
+  }
+  // Toggle between fit-to-screen and original size
+  toggleImageMode() {
+    this.fitToScreen = !this.fitToScreen;
+    this.updateTemplateProperties();
+    this.updateImageDisplay();
+    const eventBus = this.getApp()?.events;
+    if (eventBus) {
+      eventBus.emit("lightbox:mode-changed", {
+        gallery: this,
+        fitToScreen: this.fitToScreen
+      });
+    }
+  }
+  // Update image display without full re-render
+  updateImageDisplay() {
+    const imgElement = this.element.querySelector(".lightbox-image");
+    const containerElement = this.element.querySelector(".lightbox-image-container");
+    const indicatorElement = this.element.querySelector(".lightbox-mode-indicator");
+    if (imgElement) {
+      if (this.fitToScreen) {
+        imgElement.style.maxWidth = "100%";
+        imgElement.style.maxHeight = "100%";
+        imgElement.style.objectFit = "contain";
+        imgElement.style.cursor = "zoom-in";
+      } else {
+        imgElement.style.maxWidth = "none";
+        imgElement.style.maxHeight = "none";
+        imgElement.style.objectFit = "none";
+        imgElement.style.cursor = "zoom-out";
+      }
+      imgElement.style.userSelect = "none";
+    }
+    if (containerElement) {
+      containerElement.style.overflow = this.fitToScreen ? "" : "auto";
+    }
+    if (indicatorElement) {
+      indicatorElement.textContent = `${this.modeIndicator} • Click image to toggle`;
+    }
+  }
+  // Close lightbox
+  close() {
+    const eventBus = this.getApp()?.events;
+    if (eventBus) {
+      eventBus.emit("lightbox:closed", { gallery: this });
+    }
+    this.destroy();
+  }
+  async onBeforeDestroy() {
+    document.body.style.overflow = "";
+    if (this.allowKeyboard) {
+      document.removeEventListener("keydown", this._keyboardHandler);
+    }
+    if (this.element.parentNode === document.body) {
+      document.body.removeChild(this.element);
+    }
+  }
+  // Static method to show lightbox
+  static show(images, options = {}) {
+    const lightbox = new LightboxGallery({
+      images,
+      ...options
+    });
+    lightbox.render().then(() => {
+      lightbox.mount();
+    });
+    return lightbox;
+  }
+}
+window.LightboxGallery = LightboxGallery;
+class PDFViewer extends View {
+  constructor(options = {}) {
+    super({
+      ...options,
+      className: `pdf-viewer ${options.className || ""}`,
+      tagName: "div"
+    });
+    this.pdfUrl = options.pdfUrl || options.src || "";
+    this.title = options.title || "PDF Document";
+    this.pdfDoc = null;
+    this.currentPage = 1;
+    this.totalPages = 0;
+    this.pageRendering = false;
+    this.pageNumPending = null;
+    this.scale = 1;
+    this.minScale = 0.25;
+    this.maxScale = 5;
+    this.scaleStep = 0.25;
+    this.fitMode = "page";
+    this.canvas = null;
+    this.ctx = null;
+    this.showControls = options.showControls !== false;
+    this.allowZoom = options.allowZoom !== false;
+    this.allowNavigation = options.allowNavigation !== false;
+    this.showPageNumbers = options.showPageNumbers !== false;
+    this.isLoaded = false;
+    this.isLoading = false;
+    this.pdfjsWorkerPath = options.pdfjsWorkerPath || "https://cdnjs.cloudflare.com/ajax/libs/pdf.js/4.0.379/pdf.worker.min.js";
+    this.pdfjsCMapUrl = options.pdfjsCMapUrl || "https://cdnjs.cloudflare.com/ajax/libs/pdf.js/4.0.379/cmaps/";
+    this.canvasContainer = null;
+    this.controlsElement = null;
+    this.statusElement = null;
+    this.pageInput = null;
+  }
+  async getTemplate() {
+    return `
+      <div class="pdf-viewer-container">
+        {{#showControls}}
+        <div class="pdf-viewer-toolbar" data-container="toolbar">
+          <div class="btn-toolbar" role="toolbar">
+            <!-- Navigation Controls -->
+            {{#allowNavigation}}
+            <div class="btn-group me-2" role="group" aria-label="Navigation">
+              <button type="button" class="btn btn-outline-secondary btn-sm" data-action="first-page" title="First Page">
+                <i class="bi bi-chevron-double-left"></i>
+              </button>
+              <button type="button" class="btn btn-outline-secondary btn-sm" data-action="prev-page" title="Previous Page">
+                <i class="bi bi-chevron-left"></i>
+              </button>
+              
+              {{#showPageNumbers}}
+              <div class="input-group input-group-sm" style="width: 120px;">
+                <input type="number" class="form-control text-center page-input" min="1" value="1" data-change-action="page-input">
+                <span class="input-group-text page-total">/ 0</span>
+              </div>
+              {{/showPageNumbers}}
+              
+              <button type="button" class="btn btn-outline-secondary btn-sm" data-action="next-page" title="Next Page">
+                <i class="bi bi-chevron-right"></i>
+              </button>
+              <button type="button" class="btn btn-outline-secondary btn-sm" data-action="last-page" title="Last Page">
+                <i class="bi bi-chevron-double-right"></i>
+              </button>
+            </div>
+            {{/allowNavigation}}
+
+            <!-- Zoom Controls -->
+            {{#allowZoom}}
+            <div class="btn-group me-2" role="group" aria-label="Zoom">
+              <button type="button" class="btn btn-outline-secondary btn-sm" data-action="zoom-out" title="Zoom Out">
+                <i class="bi bi-zoom-out"></i>
+              </button>
+              <button type="button" class="btn btn-outline-secondary btn-sm" data-action="zoom-in" title="Zoom In">
+                <i class="bi bi-zoom-in"></i>
+              </button>
+              
+              <div class="btn-group" role="group">
+                <button type="button" class="btn btn-outline-secondary btn-sm dropdown-toggle" data-bs-toggle="dropdown" title="Fit">
+                  <i class="bi bi-arrows-fullscreen"></i>
+                </button>
+                <ul class="dropdown-menu">
+                  <li><a class="dropdown-item" href="#" data-action="fit-page">Fit Page</a></li>
+                  <li><a class="dropdown-item" href="#" data-action="fit-width">Fit Width</a></li>
+                  <li><a class="dropdown-item" href="#" data-action="actual-size">Actual Size</a></li>
+                </ul>
+              </div>
+            </div>
+            {{/allowZoom}}
+
+            <!-- Utility Controls -->
+            <div class="btn-group me-2" role="group" aria-label="Utilities">
+              <button type="button" class="btn btn-outline-secondary btn-sm" data-action="download" title="Download">
+                <i class="bi bi-download"></i>
+              </button>
+              <button type="button" class="btn btn-outline-secondary btn-sm" data-action="print" title="Print">
+                <i class="bi bi-printer"></i>
+              </button>
+            </div>
+          </div>
+        </div>
+        {{/showControls}}
+
+        <!-- PDF Content Area -->
+        <div class="pdf-viewer-content" data-container="content">
+          <div class="pdf-canvas-container" data-container="canvasContainer">
+            <canvas class="pdf-canvas" data-container="canvas"></canvas>
+          </div>
+
+          <div class="pdf-viewer-overlay">
+            <div class="pdf-viewer-loading">
+              <div class="spinner-border text-primary" role="status">
+                <span class="visually-hidden">Loading PDF...</span>
+              </div>
+              <div class="mt-2">Loading PDF...</div>
+            </div>
+          </div>
+
+          <div class="pdf-viewer-error" style="display: none;">
+            <div class="alert alert-danger" role="alert">
+              <i class="bi bi-exclamation-triangle"></i>
+              <strong>Error:</strong> <span class="error-message">Failed to load PDF</span>
+            </div>
+          </div>
+        </div>
+
+        <!-- Status Bar -->
+        <div class="pdf-viewer-status" data-container="status">
+          <small class="text-muted">
+            <span class="current-page">0</span> of <span class="total-pages">0</span> pages |
+            <span class="zoom-level">100%</span> |
+            <span class="document-title">{{title}}</span>
+          </small>
+        </div>
+      </div>
+    `;
+  }
+  get() {
+    return {
+      pdfUrl: this.pdfUrl,
+      title: this.title,
+      showControls: this.showControls,
+      allowZoom: this.allowZoom,
+      allowNavigation: this.allowNavigation,
+      showPageNumbers: this.showPageNumbers
+    };
+  }
+  async onAfterRender() {
+    this.canvas = this.element.querySelector(".pdf-canvas");
+    this.canvasContainer = this.element.querySelector(".pdf-canvas-container");
+    this.controlsElement = this.element.querySelector(".pdf-viewer-toolbar");
+    this.statusElement = this.element.querySelector(".pdf-viewer-status");
+    this.pageInput = this.element.querySelector(".page-input");
+    this.overlayElement = this.element.querySelector(".pdf-viewer-overlay");
+    this.errorElement = this.element.querySelector(".pdf-viewer-error");
+    if (this.canvas) {
+      this.ctx = this.canvas.getContext("2d");
+    }
+    this.setupEssentialEventListeners();
+    await this.initializePDFJS();
+    if (this.pdfUrl) {
+      await this.loadPDF();
+    }
+  }
+  setupEssentialEventListeners() {
+    const keydownHandler = (e) => this.handleKeyDown(e);
+    document.addEventListener("keydown", keydownHandler);
+    let resizeObserver = null;
+    if (this.canvasContainer) {
+      resizeObserver = new ResizeObserver(() => {
+        if (this.fitMode !== "auto") {
+          this.applyFitMode();
+        }
+      });
+      resizeObserver.observe(this.canvasContainer);
+    }
+    this._essentialListeners = [
+      { el: document, type: "keydown", fn: keydownHandler }
+    ];
+    this._resizeObserver = resizeObserver;
+  }
+  async initializePDFJS() {
+    try {
+      if (typeof window.pdfjsLib === "undefined") {
+        await this.loadPDFJSLibrary();
+      }
+      window.pdfjsLib.GlobalWorkerOptions.workerSrc = this.pdfjsWorkerPath;
+      return true;
+    } catch (error) {
+      console.error("Failed to initialize PDF.js:", error);
+      this.showError("Failed to initialize PDF viewer");
+      return false;
+    }
+  }
+  async loadPDFJSLibrary() {
+    return new Promise((resolve, reject) => {
+      const script = document.createElement("script");
+      script.src = "https://cdnjs.cloudflare.com/ajax/libs/pdf.js/4.0.379/pdf.min.js";
+      script.onload = resolve;
+      script.onerror = reject;
+      document.head.appendChild(script);
+    });
+  }
+  // Action Handlers
+  async handleActionFirstPage() {
+    await this.goToPage(1);
+  }
+  async handleActionPrevPage() {
+    await this.goToPage(this.currentPage - 1);
+  }
+  async handleActionNextPage() {
+    await this.goToPage(this.currentPage + 1);
+  }
+  async handleActionLastPage() {
+    await this.goToPage(this.totalPages);
+  }
+  async onChangePageInput(event, element) {
+    const pageNumber = parseInt(element.value, 10);
+    if (pageNumber >= 1 && pageNumber <= this.totalPages) {
+      await this.goToPage(pageNumber);
+    } else {
+      element.value = this.currentPage;
+    }
+  }
+  async handleActionZoomIn() {
+    this.setScale(this.scale + this.scaleStep);
+  }
+  async handleActionZoomOut() {
+    this.setScale(this.scale - this.scaleStep);
+  }
+  async handleActionFitPage() {
+    this.setFitMode("page");
+  }
+  async handleActionFitWidth() {
+    this.setFitMode("width");
+  }
+  async handleActionActualSize() {
+    this.setScale(1);
+    this.fitMode = "auto";
+  }
+  async handleActionDownload() {
+    this.downloadPDF();
+  }
+  async handleActionPrint() {
+    window.print();
+  }
+  // PDF Loading
+  async loadPDF() {
+    if (!this.pdfUrl || !window.pdfjsLib) {
+      this.showError("PDF URL or PDF.js library not available");
+      return false;
+    }
+    this.isLoading = true;
+    this.showLoading();
+    try {
+      const loadingTask = window.pdfjsLib.getDocument({
+        url: this.pdfUrl,
+        cMapUrl: this.pdfjsCMapUrl,
+        cMapPacked: true
+      });
+      this.pdfDoc = await loadingTask.promise;
+      this.totalPages = this.pdfDoc.numPages;
+      this.currentPage = 1;
+      this.updatePageControls();
+      this.updateStatus();
+      await this.renderPage(1);
+      this.isLoaded = true;
+      this.isLoading = false;
+      this.element.classList.add("loaded");
+      this.hideLoading();
+      this.applyFitMode();
+      const eventBus = this.getApp()?.events;
+      if (eventBus) {
+        eventBus.emit("pdfviewer:loaded", {
+          viewer: this,
+          pdfUrl: this.pdfUrl,
+          totalPages: this.totalPages
+        });
+      }
+      return true;
+    } catch (error) {
+      console.error("Error loading PDF:", error);
+      this.isLoading = false;
+      this.showError("Failed to load PDF document");
+      const eventBus = this.getApp()?.events;
+      if (eventBus) {
+        eventBus.emit("pdfviewer:error", {
+          viewer: this,
+          pdfUrl: this.pdfUrl,
+          error: error.message
+        });
+      }
+      return false;
+    }
+  }
+  async renderPage(pageNumber) {
+    if (this.pageRendering) {
+      this.pageNumPending = pageNumber;
+      return;
+    }
+    if (!this.pdfDoc || !this.canvas || !this.ctx) {
+      return;
+    }
+    this.pageRendering = true;
+    this.currentPage = pageNumber;
+    try {
+      const page = await this.pdfDoc.getPage(pageNumber);
+      const viewport = page.getViewport({ scale: this.scale });
+      this.canvas.height = viewport.height;
+      this.canvas.width = viewport.width;
+      this.ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
+      const renderContext = {
+        canvasContext: this.ctx,
+        viewport
+      };
+      const renderTask = page.render(renderContext);
+      await renderTask.promise;
+      this.pageRendering = false;
+      if (this.pageNumPending !== null) {
+        const pendingPage = this.pageNumPending;
+        this.pageNumPending = null;
+        await this.renderPage(pendingPage);
+      }
+      this.updatePageControls();
+      this.updateStatus();
+      const eventBus = this.getApp()?.events;
+      if (eventBus) {
+        eventBus.emit("pdfviewer:page-changed", {
+          viewer: this,
+          currentPage: this.currentPage,
+          totalPages: this.totalPages
+        });
+      }
+    } catch (error) {
+      console.error("Error rendering page:", error);
+      this.pageRendering = false;
+      this.showError("Failed to render PDF page");
+    }
+  }
+  // Navigation
+  async goToPage(pageNumber) {
+    if (!this.pdfDoc || pageNumber < 1 || pageNumber > this.totalPages) {
+      return;
+    }
+    await this.renderPage(pageNumber);
+  }
+  // Zoom and Fit
+  setScale(scale) {
+    const oldScale = this.scale;
+    this.scale = Math.max(this.minScale, Math.min(this.maxScale, scale));
+    this.fitMode = "auto";
+    if (this.isLoaded) {
+      this.renderPage(this.currentPage);
+    }
+    const eventBus = this.getApp()?.events;
+    if (eventBus && oldScale !== this.scale) {
+      eventBus.emit("pdfviewer:scale-changed", {
+        viewer: this,
+        oldScale,
+        newScale: this.scale
+      });
+    }
+  }
+  setFitMode(mode) {
+    const oldMode = this.fitMode;
+    this.fitMode = mode;
+    this.applyFitMode();
+    const eventBus = this.getApp()?.events;
+    if (eventBus) {
+      eventBus.emit("pdfviewer:fit-mode-changed", {
+        viewer: this,
+        oldMode,
+        newMode: mode
+      });
+    }
+  }
+  applyFitMode() {
+    if (!this.isLoaded || !this.pdfDoc || !this.canvasContainer) {
+      return;
+    }
+    this.pdfDoc.getPage(this.currentPage).then((page) => {
+      const containerRect = this.canvasContainer.getBoundingClientRect();
+      const viewport = page.getViewport({ scale: 1 });
+      let newScale;
+      if (this.fitMode === "page") {
+        const scaleX = (containerRect.width - 40) / viewport.width;
+        const scaleY = (containerRect.height - 40) / viewport.height;
+        newScale = Math.min(scaleX, scaleY);
+      } else if (this.fitMode === "width") {
+        newScale = (containerRect.width - 40) / viewport.width;
+      } else {
+        return;
+      }
+      this.scale = Math.max(this.minScale, Math.min(this.maxScale, newScale));
+      this.renderPage(this.currentPage);
+    });
+  }
+  // Event Handlers
+  handleKeyDown(e) {
+    if (e.target.tagName === "INPUT" && e.target !== this.pageInput) {
+      return;
+    }
+    switch (e.key) {
+      case "ArrowLeft":
+      case "PageUp":
+        e.preventDefault();
+        this.goToPage(this.currentPage - 1);
+        break;
+      case "ArrowRight":
+      case "PageDown":
+        e.preventDefault();
+        this.goToPage(this.currentPage + 1);
+        break;
+      case "Home":
+        e.preventDefault();
+        this.goToPage(1);
+        break;
+      case "End":
+        e.preventDefault();
+        this.goToPage(this.totalPages);
+        break;
+      case "+":
+      case "=":
+        if (e.ctrlKey || e.metaKey) {
+          e.preventDefault();
+          this.setScale(this.scale + this.scaleStep);
+        }
+        break;
+      case "-":
+        if (e.ctrlKey || e.metaKey) {
+          e.preventDefault();
+          this.setScale(this.scale - this.scaleStep);
+        }
+        break;
+      case "0":
+        if (e.ctrlKey || e.metaKey) {
+          e.preventDefault();
+          this.setFitMode("page");
+        }
+        break;
+    }
+  }
+  // UI Updates
+  updatePageControls() {
+    if (this.pageInput) {
+      this.pageInput.value = this.currentPage;
+    }
+    const pageTotalElement = this.element.querySelector(".page-total");
+    if (pageTotalElement) {
+      pageTotalElement.textContent = `/ ${this.totalPages}`;
+    }
+    const firstBtn = this.element.querySelector('[data-action="first-page"]');
+    const prevBtn = this.element.querySelector('[data-action="prev-page"]');
+    const nextBtn = this.element.querySelector('[data-action="next-page"]');
+    const lastBtn = this.element.querySelector('[data-action="last-page"]');
+    if (firstBtn) firstBtn.disabled = this.currentPage <= 1;
+    if (prevBtn) prevBtn.disabled = this.currentPage <= 1;
+    if (nextBtn) nextBtn.disabled = this.currentPage >= this.totalPages;
+    if (lastBtn) lastBtn.disabled = this.currentPage >= this.totalPages;
+    const zoomInBtn = this.element.querySelector('[data-action="zoom-in"]');
+    const zoomOutBtn = this.element.querySelector('[data-action="zoom-out"]');
+    if (zoomInBtn) zoomInBtn.disabled = this.scale >= this.maxScale;
+    if (zoomOutBtn) zoomOutBtn.disabled = this.scale <= this.minScale;
+  }
+  updateStatus() {
+    if (!this.statusElement) return;
+    const currentPageElement = this.statusElement.querySelector(".current-page");
+    const totalPagesElement = this.statusElement.querySelector(".total-pages");
+    const zoomLevelElement = this.statusElement.querySelector(".zoom-level");
+    if (currentPageElement) {
+      currentPageElement.textContent = this.currentPage;
+    }
+    if (totalPagesElement) {
+      totalPagesElement.textContent = this.totalPages;
+    }
+    if (zoomLevelElement) {
+      zoomLevelElement.textContent = `${Math.round(this.scale * 100)}%`;
+    }
+  }
+  // Utility Methods
+  showLoading() {
+    if (this.overlayElement) {
+      this.overlayElement.style.display = "flex";
+    }
+  }
+  hideLoading() {
+    if (this.overlayElement) {
+      this.overlayElement.style.display = "none";
+    }
+  }
+  showError(message) {
+    this.hideLoading();
+    if (this.errorElement) {
+      const errorMessageElement = this.errorElement.querySelector(".error-message");
+      if (errorMessageElement) {
+        errorMessageElement.textContent = message;
+      }
+      this.errorElement.style.display = "block";
+    }
+    console.error("PDF Viewer Error:", message);
+  }
+  downloadPDF() {
+    if (!this.pdfUrl) return;
+    const link = document.createElement("a");
+    link.href = this.pdfUrl;
+    link.download = this.title + ".pdf";
+    link.target = "_blank";
+    link.click();
+  }
+  // Public API
+  setPDF(pdfUrl, title = "") {
+    const oldPdfUrl = this.pdfUrl;
+    this.pdfUrl = pdfUrl;
+    this.title = title || "PDF Document";
+    this.isLoaded = false;
+    this.element.classList.remove("loaded");
+    if (this.pdfDoc) {
+      this.pdfDoc.destroy();
+      this.pdfDoc = null;
+    }
+    this.currentPage = 1;
+    this.totalPages = 0;
+    this.scale = 1;
+    if (pdfUrl) {
+      this.loadPDF();
+    }
+    const eventBus = this.getApp()?.events;
+    if (eventBus) {
+      eventBus.emit("pdfviewer:pdf-changed", {
+        viewer: this,
+        oldPdfUrl,
+        newPdfUrl: pdfUrl
+      });
+    }
+  }
+  getCurrentPage() {
+    return this.currentPage;
+  }
+  getTotalPages() {
+    return this.totalPages;
+  }
+  getCurrentScale() {
+    return this.scale;
+  }
+  async onBeforeDestroy() {
+    if (this.pdfDoc) {
+      this.pdfDoc.destroy();
+      this.pdfDoc = null;
+    }
+    this.pageRendering = false;
+    this.pageNumPending = null;
+    if (this._essentialListeners) {
+      this._essentialListeners.forEach(({ el, type, fn }) => {
+        if (el) el.removeEventListener(type, fn);
+      });
+      this._essentialListeners = null;
+    }
+    if (this._resizeObserver) {
+      this._resizeObserver.disconnect();
+      this._resizeObserver = null;
+    }
+    const eventBus = this.getApp()?.events;
+    if (eventBus) {
+      eventBus.emit("pdfviewer:destroyed", { viewer: this });
+    }
+  }
+  // Static method to show PDF in a fullscreen dialog
+  static async showDialog(pdfUrl, options = {}) {
+    const {
+      title = "PDF Viewer",
+      size = "fullscreen",
+      showControls = true,
+      allowZoom = true,
+      allowNavigation = true,
+      showPageNumbers = true,
+      ...dialogOptions
+    } = options;
+    const viewer = new PDFViewer({
+      pdfUrl,
+      title,
+      showControls,
+      allowZoom,
+      allowNavigation,
+      showPageNumbers
+    });
+    const dialog = new Dialog({
+      title,
+      body: viewer,
+      size,
+      centered: true,
+      backdrop: "static",
+      keyboard: true,
+      buttons: [
+        {
+          text: "Download",
+          action: "download",
+          class: "btn btn-outline-primary"
+        },
+        {
+          text: "Close",
+          action: "close",
+          class: "btn btn-secondary",
+          dismiss: true
+        }
+      ],
+      ...dialogOptions
+    });
+    await dialog.render();
+    document.body.appendChild(dialog.element);
+    await dialog.mount();
+    dialog.show();
+    return new Promise((resolve) => {
+      dialog.on("hidden", () => {
+        dialog.destroy();
+        resolve(viewer);
+      });
+      dialog.on("action:download", () => {
+        viewer.downloadPDF();
+      });
+      dialog.on("action:close", () => {
+        dialog.hide();
+      });
+    });
+  }
+}
+export {
+  LightboxGallery as L,
+  PDFViewer as P
+};
+//# sourceMappingURL=PDFViewer-Dyo-Oeyd.js.map