@geelato/gl-ui-web-arco 0.0.1

package/dist/GlPdf-CP236wBj.js

@@ -0,0 +1,891 @@
+import { defineComponent, ref, watch, onMounted, nextTick, onBeforeUnmount, computed, resolveComponent, createElementBlock, openBlock, normalizeStyle, normalizeClass, toDisplayString, createElementVNode, createVNode, withDirectives, createTextVNode, vModelText, withModifiers, toRaw, markRaw } from "vue";
+import { Message } from "@arco-design/web-vue";
+import { useDebounceFn } from "@vueuse/core";
+import { entityApi } from "@geelato/gl-runtime-core";
+import { _ as _export_sfc } from "./main-D7ErSddl.js";
+const _hoisted_1 = {
+  key: 0,
+  class: "gl-pdf-loading"
+};
+const _hoisted_2 = {
+  key: 1,
+  class: "gl-pdf-error"
+};
+const _hoisted_3 = {
+  key: 2,
+  class: "gl-pdf-body"
+};
+const _hoisted_4 = { class: "toolbar-left" };
+const _hoisted_5 = ["disabled"];
+const _hoisted_6 = ["max"];
+const _hoisted_7 = ["disabled"];
+const _hoisted_8 = { class: "toolbar-middle" };
+const _hoisted_9 = { class: "scale-percent" };
+const _hoisted_10 = { class: "toolbar-right" };
+const _hoisted_11 = ["title"];
+const __default__ = {
+  name: "GlPdf"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...__default__,
+  props: {
+    // PDF文件的URL
+    url: {
+      type: String,
+      required: false,
+      default: ""
+    },
+    // 页面宽度，支持 '100%'、'200em'、'1024px' 等
+    width: {
+      type: String,
+      default: "800px"
+    },
+    // 页面高度，支持 '100%'、'200em'、'1024px' 等
+    height: {
+      type: String,
+      default: "600px"
+    },
+    // 初始页码
+    page: {
+      type: Number,
+      default: 1
+    },
+    // 缩放比例
+    scale: {
+      type: Number,
+      default: 1
+    },
+    // 是否显示外边框，默认不显示
+    bordered: {
+      type: Boolean,
+      default: false
+    }
+  },
+  emits: ["load", "error", "page-change"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const loading = ref(false);
+    const error = ref(null);
+    const pdfInstance = ref(null);
+    const currentPage = ref(props.page);
+    const totalPages = ref(0);
+    const containerRef = ref(null);
+    const toolbarRef = ref(null);
+    const pdfBlobUrl = ref("");
+    const fileNameRef = ref("");
+    const scaleRef = ref(props.scale);
+    const rotationRef = ref(0);
+    const isFullscreen = ref(false);
+    const fitMode = ref(null);
+    const internalUrl = ref(props.url || "");
+    const canvasElements = /* @__PURE__ */ new Set();
+    const iframeElements = /* @__PURE__ */ new Set();
+    const unwatchFns = [];
+    let isComponentUnmounted = false;
+    const loadPdfJs = async () => {
+      loading.value = true;
+      error.value = null;
+      try {
+        const pdfjsLib = await import("./pdfjs-Cvb5nkrC.js").then((n) => n.p);
+        const workerUrl = (await import("./pdfjs-Cvb5nkrC.js").then((n) => n.a)).default;
+        pdfjsLib.GlobalWorkerOptions.workerSrc = workerUrl;
+        return pdfjsLib;
+      } catch (err) {
+        error.value = "Failed to load PDF.js library";
+        emits("error", err);
+        throw err;
+      }
+    };
+    const loadPdfDocument = async (pdfjsLib) => {
+      var _a, _b, _c, _d, _e, _f;
+      try {
+        if (!internalUrl.value) {
+          pdfInstance.value = null;
+          totalPages.value = 0;
+          if (containerRef.value) {
+            containerRef.value.innerHTML = "";
+          }
+          return;
+        }
+        if (pdfBlobUrl.value) {
+          try {
+            URL.revokeObjectURL(pdfBlobUrl.value);
+            pdfBlobUrl.value = "";
+          } catch (_) {
+          }
+        }
+        const authHeaders = ((_b = (_a = entityApi).getHeader) == null ? void 0 : _b.call(_a)) || {};
+        const extraHeaders = {};
+        try {
+          const { searchParams, pathname } = new URL(window.location.href);
+          if (pathname && /^\/[a-zA-Z]+\.html$/.test(pathname)) {
+            const appId = searchParams.get("appId") || "";
+            const tenantCode = searchParams.get("tenantCode") || "";
+            if (appId) extraHeaders["App-Id"] = appId;
+            if (tenantCode) extraHeaders["Tenant-Code"] = tenantCode;
+          }
+        } catch (_) {
+        }
+        const resp = await fetch(internalUrl.value, {
+          credentials: "include",
+          headers: {
+            Accept: "application/pdf,application/octet-stream;q=0.9,*/*;q=0.8",
+            ...authHeaders,
+            ...extraHeaders
+          }
+        });
+        if (!resp.ok) {
+          const msg = `HTTP ${resp.status} ${resp.statusText}`;
+          error.value = msg;
+          emits("error", new Error(msg));
+          return;
+        }
+        const contentTypeRaw = ((_d = (_c = resp.headers).get) == null ? void 0 : _d.call(_c, "content-type")) || "";
+        const contentType = contentTypeRaw.toLowerCase();
+        const headersObj = {};
+        try {
+          resp.headers.forEach((v, k) => {
+            headersObj[k] = v;
+          });
+        } catch (_) {
+        }
+        let sampleText;
+        try {
+          const respClone = resp.clone();
+          sampleText = await respClone.text();
+        } catch (_) {
+          sampleText = void 0;
+        }
+        const buffer = await resp.arrayBuffer();
+        const cdHeader = ((_f = (_e = resp.headers).get) == null ? void 0 : _f.call(_e, "content-disposition")) || "";
+        const parseContentDispositionFilename = (cd) => {
+          try {
+            const mStar = cd.match(/filename\*=\s*UTF-8''([^;\r\n]+)/i);
+            if (mStar && mStar[1]) return decodeURIComponent(mStar[1].trim());
+            const m = cd.match(/filename\s*=\s*"?([^";\r\n]+)"?/i);
+            if (m && m[1]) return m[1].trim();
+          } catch (_) {
+          }
+          return "";
+        };
+        const parseFilenameFromQuery = (u) => {
+          try {
+            const x = new URL(u, window.location.origin);
+            const sp = x.searchParams;
+            const val = sp.get("filename") || sp.get("fileName") || sp.get("name");
+            return val ? decodeURIComponent(val) : "";
+          } catch (_) {
+            return "";
+          }
+        };
+        const deriveFileNameFromUrl = (u) => {
+          try {
+            const x = new URL(u, window.location.origin);
+            const segs = x.pathname.split("/").filter(Boolean);
+            const last = segs.pop() || "";
+            return decodeURIComponent(last || "");
+          } catch (_) {
+            return "";
+          }
+        };
+        const ensurePdfExt = (name) => {
+          if (!name) return "";
+          return name.toLowerCase().endsWith(".pdf") ? name : `${name}.pdf`;
+        };
+        const fromQuery = parseFilenameFromQuery(internalUrl.value);
+        const fromCd = parseContentDispositionFilename(cdHeader);
+        const fromUrl = deriveFileNameFromUrl(internalUrl.value);
+        const picked = ensurePdfExt(fromQuery || fromCd || fromUrl);
+        if (picked) fileNameRef.value = picked;
+        let isPdfSig = false;
+        try {
+          const head = new Uint8Array(buffer.slice(0, 5));
+          const sig = String.fromCharCode(...head);
+          isPdfSig = sig.startsWith("%PDF-");
+        } catch (_) {
+        }
+        if (!isPdfSig || !contentType.includes("application/pdf")) {
+          const msg = `非PDF响应或结构无效（content-type: ${contentType || "未知"}）`;
+          error.value = msg;
+          emits("error", {
+            type: "non-pdf",
+            url: internalUrl.value,
+            status: resp.status,
+            statusText: resp.statusText,
+            contentType,
+            headers: headersObj,
+            bodyPreview: sampleText ? sampleText.slice(0, 2e3) : void 0
+          });
+          return;
+        }
+        const loadingTask = pdfjsLib.getDocument({ data: buffer, disableWorker: true });
+        const doc = await loadingTask.promise;
+        pdfInstance.value = markRaw(doc);
+        try {
+          const blob = new Blob([buffer], { type: "application/pdf" });
+          pdfBlobUrl.value = URL.createObjectURL(blob);
+        } catch (_) {
+          pdfBlobUrl.value = "";
+        }
+        totalPages.value = toRaw(pdfInstance.value).numPages;
+        emits("load", { numPages: totalPages.value });
+        await nextTick();
+        renderPage(currentPage.value);
+      } catch (err) {
+        error.value = "Failed to load PDF document";
+        emits("error", err);
+      } finally {
+        loading.value = false;
+      }
+    };
+    const renderPage = async (pageNum) => {
+      if (!internalUrl.value || !pdfInstance.value || isComponentUnmounted) return;
+      if (!containerRef.value) {
+        containerRef.value = document.querySelector(".gl-pdf-content");
+      }
+      if (!containerRef.value) {
+        return;
+      }
+      try {
+        const doc = toRaw(pdfInstance.value);
+        const page = await doc.getPage(pageNum);
+        const viewport = page.getViewport({ scale: scaleRef.value, rotation: rotationRef.value });
+        containerRef.value.innerHTML = "";
+        const canvas = document.createElement("canvas");
+        const context = canvas.getContext("2d");
+        if (!context) {
+          throw new Error("Failed to get canvas context");
+        }
+        canvas.height = viewport.height;
+        canvas.width = viewport.width;
+        canvasElements.add(canvas);
+        const pageLayer = document.createElement("div");
+        pageLayer.style.position = "relative";
+        pageLayer.style.width = `${viewport.width}px`;
+        pageLayer.style.height = `${viewport.height}px`;
+        canvas.style.width = `${viewport.width}px`;
+        canvas.style.height = `${viewport.height}px`;
+        canvas.style.position = "absolute";
+        canvas.style.left = "0";
+        canvas.style.top = "0";
+        canvas.style.zIndex = "1";
+        const renderContext = {
+          canvasContext: context,
+          viewport
+        };
+        const renderTask = page.render(renderContext);
+        await renderTask.promise;
+        pageLayer.appendChild(canvas);
+        containerRef.value.appendChild(pageLayer);
+      } catch (err) {
+        emits("error", err);
+        try {
+          if (containerRef.value && pdfBlobUrl.value) {
+            containerRef.value.innerHTML = "";
+            const iframe = document.createElement("iframe");
+            iframe.src = pdfBlobUrl.value;
+            iframe.style.width = "100%";
+            iframe.style.height = "100%";
+            iframe.style.border = "none";
+            containerRef.value.appendChild(iframe);
+            iframeElements.add(iframe);
+          }
+        } catch (_) {
+        }
+      }
+    };
+    const prevPage = () => {
+      if (currentPage.value <= 1) return;
+      currentPage.value--;
+      renderPage(currentPage.value);
+      emits("page-change", currentPage.value);
+    };
+    const nextPage = () => {
+      if (currentPage.value >= totalPages.value) return;
+      currentPage.value++;
+      renderPage(currentPage.value);
+      emits("page-change", currentPage.value);
+    };
+    const goToPage = (pageNum) => {
+      if (pageNum < 1 || pageNum > totalPages.value) return;
+      currentPage.value = pageNum;
+      renderPage(currentPage.value);
+      emits("page-change", currentPage.value);
+    };
+    const stopWatchUrl = watch(() => props.url, (val) => {
+      if (!isComponentUnmounted) {
+        internalUrl.value = val || "";
+        initPdf();
+      }
+    });
+    unwatchFns.push(stopWatchUrl);
+    const stopWatchScale = watch(() => props.scale, () => {
+      if (!isComponentUnmounted) {
+        scaleRef.value = props.scale;
+        renderPage(currentPage.value);
+      }
+    });
+    unwatchFns.push(stopWatchScale);
+    const stopWatchCurrentPage = watch(() => currentPage.value, () => {
+      if (!isComponentUnmounted) {
+        renderPage(currentPage.value);
+      }
+    });
+    unwatchFns.push(stopWatchCurrentPage);
+    const stopWatchContainer = watch(containerRef, (el) => {
+      if (el && pdfInstance.value && !isComponentUnmounted) {
+        renderPage(currentPage.value);
+      }
+    });
+    unwatchFns.push(stopWatchContainer);
+    const doInitPdf = async () => {
+      try {
+        const pdfjsLib = await loadPdfJs();
+        try {
+          if (pdfInstance.value && typeof pdfInstance.value.destroy === "function") {
+            await pdfInstance.value.destroy();
+            pdfInstance.value = null;
+          }
+        } catch (_) {
+        }
+        await loadPdfDocument(pdfjsLib);
+      } catch (err) {
+        loading.value = false;
+        console.error("Failed to initialize PDF:", err);
+      }
+    };
+    const initPdf = useDebounceFn(doInitPdf, 200);
+    let syncToolbarHeightHandler = null;
+    onMounted(() => {
+      try {
+        syncToolbarHeightHandler = () => {
+          const el = toolbarRef.value || document.querySelector(".gl-pdf-toolbar");
+          const contentEl = containerRef.value || document.querySelector(".gl-pdf-content");
+          const h = (el == null ? void 0 : el.offsetHeight) || 50;
+          contentEl == null ? void 0 : contentEl.style.setProperty("--gl-pdf-toolbar-h", `${h}px`);
+        };
+        nextTick(syncToolbarHeightHandler);
+        window.addEventListener("resize", syncToolbarHeightHandler);
+      } catch (_) {
+      }
+      initPdf();
+    });
+    const clearCanvases = () => {
+      canvasElements.forEach((canvas) => {
+        try {
+          const context = canvas.getContext("2d");
+          if (context) {
+            context.clearRect(0, 0, canvas.width, canvas.height);
+          }
+          canvas.width = 0;
+          canvas.height = 0;
+          canvas.remove();
+        } catch (e) {
+          console.error("清理canvas失败:", e);
+        }
+      });
+      canvasElements.clear();
+    };
+    const clearIframes = () => {
+      iframeElements.forEach((iframe) => {
+        try {
+          iframe.src = "";
+          iframe.remove();
+        } catch (e) {
+          console.error("清理iframe失败:", e);
+        }
+      });
+      iframeElements.clear();
+    };
+    onBeforeUnmount(() => {
+      isComponentUnmounted = true;
+      unwatchFns.forEach((unwatch) => {
+        try {
+          unwatch();
+        } catch (e) {
+          console.error("停止watch失败:", e);
+        }
+      });
+      unwatchFns.length = 0;
+      if (syncToolbarHeightHandler) {
+        try {
+          window.removeEventListener("resize", syncToolbarHeightHandler);
+          syncToolbarHeightHandler = null;
+        } catch (e) {
+          console.error("移除resize监听器失败:", e);
+        }
+      }
+      clearCanvases();
+      clearIframes();
+      if (pdfBlobUrl.value) {
+        try {
+          URL.revokeObjectURL(pdfBlobUrl.value);
+          pdfBlobUrl.value = "";
+        } catch (e) {
+          console.error("清理Blob URL失败:", e);
+        }
+      }
+      if (pdfInstance.value && typeof pdfInstance.value.destroy === "function") {
+        try {
+          pdfInstance.value.destroy();
+          pdfInstance.value = null;
+        } catch (e) {
+          console.error("销毁PDF实例失败:", e);
+        }
+      }
+      if (containerRef.value) {
+        try {
+          containerRef.value.innerHTML = "";
+          containerRef.value = null;
+        } catch (e) {
+          console.error("清空容器失败:", e);
+        }
+      }
+      if (toolbarRef.value) {
+        toolbarRef.value = null;
+      }
+    });
+    const printPdf = async () => {
+      try {
+        const sanitizeTitle = (s) => (s || "").replace(/[<>&]/g, " ").slice(0, 200);
+        const ensureSuffixPdf = (s) => {
+          const t = (s || "").trim();
+          if (!t) return "document.pdf";
+          return t.toLowerCase().endsWith(".pdf") ? t : `${t}.pdf`;
+        };
+        const computePrintTitle = () => {
+          const fromState = fileNameRef.value && fileNameRef.value.trim();
+          const fromHostQuery = (() => {
+            try {
+              const sp = new URL(window.location.href).searchParams;
+              const v = sp.get("filename") || sp.get("fileName") || sp.get("name");
+              return v ? decodeURIComponent(v) : "";
+            } catch (_) {
+              return "";
+            }
+          })();
+          const fromUrl = (() => {
+            try {
+              const x = new URL(internalUrl.value, window.location.origin);
+              const segs = x.pathname.split("/").filter(Boolean);
+              const last = segs.pop() || "";
+              return last ? decodeURIComponent(last) : "";
+            } catch (_) {
+              return "";
+            }
+          })();
+          const nameBase = fromState || fromHostQuery || fromUrl || "document";
+          const name = ensureSuffixPdf(nameBase);
+          return sanitizeTitle(name);
+        };
+        let url = pdfBlobUrl.value;
+        if (!url && internalUrl.value) {
+          const resp = await fetch(internalUrl.value, { credentials: "include" });
+          if (resp.ok) {
+            const buf = await resp.arrayBuffer();
+            url = URL.createObjectURL(new Blob([buf], { type: "application/pdf" }));
+          }
+        }
+        if (!url) {
+          Message.error("无法获取可打印的 PDF 内容");
+          return;
+        }
+        const tryPrintInNewWindow = async () => {
+          return new Promise((resolve) => {
+            let w = null;
+            try {
+              w = window.open("", "_blank");
+            } catch (_) {
+            }
+            if (!w) {
+              resolve(false);
+              return;
+            }
+            try {
+              const title = computePrintTitle();
+              w.document.write("<html><head><title>" + title + '</title><style>@page{size:auto;margin:10mm;}body{margin:0;padding:0;}</style></head><body><iframe id="pdfFrame" style="position:fixed;left:-10000px;width:1px;height:1px;border:0;" aria-hidden="true"></iframe></body></html>');
+              w.document.close();
+              const frame = w.document.getElementById("pdfFrame");
+              if (frame) {
+                frame.src = url;
+                frame.onload = () => {
+                  try {
+                    w == null ? void 0 : w.focus();
+                    w == null ? void 0 : w.print();
+                  } catch (_) {
+                  }
+                  setTimeout(() => {
+                    try {
+                      w == null ? void 0 : w.close();
+                    } catch (_) {
+                    }
+                    ;
+                    resolve(true);
+                  }, 800);
+                };
+              } else {
+                setTimeout(() => {
+                  try {
+                    w == null ? void 0 : w.focus();
+                    w == null ? void 0 : w.print();
+                  } catch (_) {
+                  }
+                  ;
+                  resolve(true);
+                }, 600);
+              }
+            } catch (_) {
+              resolve(false);
+            }
+          });
+        };
+        const tryPrintInHiddenIframe = async () => {
+          return new Promise((resolve) => {
+            const iframe = document.createElement("iframe");
+            iframe.style.position = "fixed";
+            iframe.style.right = "-10000px";
+            iframe.style.bottom = "0";
+            iframe.style.width = "1px";
+            iframe.style.height = "1px";
+            iframe.style.opacity = "0.01";
+            iframe.style.border = "0";
+            iframe.setAttribute("aria-hidden", "true");
+            iframe.name = `gl-pdf-print-${Date.now()}`;
+            iframe.src = url;
+            document.body.appendChild(iframe);
+            const cleanup = () => {
+              try {
+                document.body.removeChild(iframe);
+              } catch (_) {
+              }
+            };
+            let doneTimer = null;
+            let settled = false;
+            const done = () => {
+              var _a, _b;
+              if (settled) return;
+              settled = true;
+              if (doneTimer) {
+                clearTimeout(doneTimer);
+                doneTimer = null;
+              }
+              iframe.onload = null;
+              try {
+                (_a = iframe.contentWindow) == null ? void 0 : _a.focus();
+                (_b = iframe.contentWindow) == null ? void 0 : _b.print();
+              } catch (_) {
+              }
+              setTimeout(() => {
+                cleanup();
+                resolve(true);
+              }, 1e3);
+            };
+            iframe.onload = done;
+            doneTimer = window.setTimeout(done, 800);
+          });
+        };
+        const tryImagePrint = async () => {
+          try {
+            const rawDoc = toRaw(pdfInstance.value);
+            if (rawDoc && typeof rawDoc.getPage === "function") {
+              const w = window.open("", "_blank");
+              if (!w) return false;
+              const title = computePrintTitle();
+              w.document.write("<html><head><title>" + title + "</title><style>@page{size:auto;margin:10mm;}body{margin:0;padding:0;}img{display:block;width:100%;page-break-after:always;}</style></head><body></body></html>");
+              const body = w.document.body;
+              let mq = null;
+              let changeHandler = null;
+              const cleanupMq = () => {
+                if (!mq || !changeHandler) return;
+                try {
+                  if (mq.removeEventListener) mq.removeEventListener("change", changeHandler);
+                  else if (mq.removeListener) mq.removeListener(changeHandler);
+                } catch (_) {
+                }
+                mq = null;
+                changeHandler = null;
+              };
+              const closeWin = () => {
+                cleanupMq();
+                try {
+                  w.close();
+                } catch (_) {
+                }
+              };
+              let printed = false;
+              w.onafterprint = () => {
+                printed = true;
+                closeWin();
+              };
+              try {
+                mq = w.matchMedia && w.matchMedia("print");
+                changeHandler = (e) => {
+                  if (!e.matches) setTimeout(closeWin, 100);
+                };
+                if (mq == null ? void 0 : mq.addEventListener) mq.addEventListener("change", changeHandler);
+                else if (mq == null ? void 0 : mq.addListener) mq.addListener(changeHandler);
+              } catch (_) {
+              }
+              ;
+              w.onfocus = () => {
+                if (printed) setTimeout(closeWin, 150);
+              };
+              const numPages = rawDoc.numPages || 1;
+              const baseScale = Math.min(2, Math.max(1, scaleRef.value));
+              const printScale = Math.min(2, Math.max(1, baseScale * (window.devicePixelRatio || 1)));
+              const imgPromises = [];
+              for (let i = 1; i <= numPages; i++) {
+                const page = await rawDoc.getPage(i);
+                const viewport = page.getViewport({ scale: printScale, rotation: rotationRef.value });
+                const canvas = document.createElement("canvas");
+                const ctx = canvas.getContext("2d");
+                if (!ctx) continue;
+                canvas.width = viewport.width;
+                canvas.height = viewport.height;
+                const renderTask = page.render({ canvasContext: ctx, viewport });
+                await renderTask.promise;
+                const img = w.document.createElement("img");
+                img.src = canvas.toDataURL("image/png");
+                body.appendChild(img);
+                imgPromises.push(new Promise((resolve) => {
+                  if (img.complete) resolve();
+                  else img.onload = () => resolve();
+                }));
+              }
+              await Promise.all(imgPromises);
+              try {
+                w.document.close();
+              } catch (_) {
+              }
+              try {
+                w.focus();
+                w.print();
+              } catch (_) {
+              }
+              return true;
+            }
+          } catch (_) {
+          }
+          return false;
+        };
+        const ok = await tryImagePrint() || await tryPrintInNewWindow() || await tryPrintInHiddenIframe();
+        if (!ok) {
+          Message.error("未能触发打印，请检查浏览器弹窗与打印权限");
+        }
+        try {
+          URL.revokeObjectURL(url);
+        } catch (_) {
+        }
+      } catch (e) {
+        console.error(e);
+        Message.error("打印失败，请稍后重试");
+      }
+    };
+    const rotateClockwise = () => {
+      rotationRef.value = (rotationRef.value + 90) % 360;
+      renderPage(currentPage.value);
+    };
+    const toggleFullscreen = async () => {
+      var _a, _b;
+      try {
+        const el = document.querySelector(".gl-pdf-container") || containerRef.value;
+        if (!document.fullscreenElement) {
+          await ((_a = el == null ? void 0 : el.requestFullscreen) == null ? void 0 : _a.call(el));
+          isFullscreen.value = true;
+        } else {
+          await ((_b = document.exitFullscreen) == null ? void 0 : _b.call(document));
+          isFullscreen.value = false;
+        }
+      } catch (_) {
+      }
+    };
+    const renderDebounced = useDebounceFn(() => {
+      renderPage(currentPage.value);
+    }, 50);
+    const onWheelZoom = (e) => {
+      e.preventDefault();
+      const step = 0.1;
+      if (e.deltaY > 0) {
+        scaleRef.value = Math.max(0.1, +(scaleRef.value - step).toFixed(2));
+      } else {
+        scaleRef.value = Math.min(4, +(scaleRef.value + step).toFixed(2));
+      }
+      fitMode.value = null;
+      renderDebounced();
+    };
+    const computeScaleToFit = async (mode) => {
+      if (!pdfInstance.value || !containerRef.value) return;
+      try {
+        const doc = toRaw(pdfInstance.value);
+        const page = await doc.getPage(currentPage.value);
+        const base = page.getViewport({ scale: 1, rotation: rotationRef.value });
+        const containerEl = containerRef.value;
+        const cw = containerEl.clientWidth;
+        let ch = containerEl.clientHeight;
+        if (!ch || ch === 0) {
+          const rect = containerEl.getBoundingClientRect();
+          ch = Math.max(0, Math.floor(rect.height));
+        }
+        const scaleW = cw / base.width;
+        const scaleH = ch / base.height;
+        const nextScale = mode === "width" ? scaleW : Math.min(scaleW, scaleH);
+        scaleRef.value = Math.max(0.1, Math.min(4, +nextScale.toFixed(3)));
+        fitMode.value = mode;
+        await nextTick();
+        renderPage(currentPage.value);
+      } catch (_) {
+      }
+    };
+    const applyFitWidth = () => {
+      computeScaleToFit("width");
+    };
+    const applyFitPage = () => {
+      computeScaleToFit("page");
+    };
+    const setPdf = (params) => {
+      if (!params || typeof params !== "object") return;
+      const nextUrl = params.url || "";
+      const nextPage2 = typeof params.page === "number" ? params.page : props.page;
+      internalUrl.value = nextUrl;
+      currentPage.value = nextPage2;
+      initPdf();
+    };
+    const setUrl = (url) => {
+      internalUrl.value = url || "";
+      currentPage.value = props.page;
+      initPdf();
+    };
+    const scalePercent = computed(() => `${Math.round(scaleRef.value * 100)}%`);
+    __expose({
+      prevPage,
+      nextPage,
+      goToPage,
+      setPdf,
+      setUrl
+    });
+    return (_ctx, _cache) => {
+      const _component_gl_iconfont = resolveComponent("gl-iconfont");
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["gl-pdf-container", { "gl-pdf-bordered": props.bordered }]),
+        style: normalizeStyle({ width: __props.width, height: __props.height })
+      }, [
+        loading.value ? (openBlock(), createElementBlock("div", _hoisted_1, " Loading PDF... ")) : error.value ? (openBlock(), createElementBlock("div", _hoisted_2, toDisplayString(error.value), 1)) : (openBlock(), createElementBlock("div", _hoisted_3, [
+          createElementVNode("div", {
+            class: "gl-pdf-toolbar",
+            ref_key: "toolbarRef",
+            ref: toolbarRef
+          }, [
+            createElementVNode("div", _hoisted_4, [
+              createElementVNode("button", {
+                class: "icon-btn",
+                title: "打印",
+                onClick: printPdf
+              }, [
+                createVNode(_component_gl_iconfont, {
+                  type: "gl-print",
+                  class: "gl-toolbar-icon"
+                })
+              ]),
+              createElementVNode("button", {
+                onClick: prevPage,
+                disabled: currentPage.value <= 1
+              }, "上一页", 8, _hoisted_5),
+              createElementVNode("span", null, [
+                withDirectives(createElementVNode("input", {
+                  type: "number",
+                  "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => currentPage.value = $event),
+                  min: 1,
+                  max: totalPages.value,
+                  onChange: _cache[1] || (_cache[1] = ($event) => goToPage(currentPage.value))
+                }, null, 40, _hoisted_6), [
+                  [
+                    vModelText,
+                    currentPage.value,
+                    void 0,
+                    { number: true }
+                  ]
+                ]),
+                createTextVNode(" / " + toDisplayString(totalPages.value), 1)
+              ]),
+              createElementVNode("button", {
+                onClick: nextPage,
+                disabled: currentPage.value >= totalPages.value
+              }, "下一页", 8, _hoisted_7)
+            ]),
+            createElementVNode("div", _hoisted_8, [
+              createElementVNode("button", {
+                onClick: _cache[2] || (_cache[2] = ($event) => {
+                  scaleRef.value = Math.max(0.1, +(scaleRef.value - 0.1).toFixed(2));
+                  renderPage(currentPage.value);
+                })
+              }, "-"),
+              createElementVNode("button", {
+                onClick: _cache[3] || (_cache[3] = ($event) => {
+                  scaleRef.value = Math.min(4, +(scaleRef.value + 0.1).toFixed(2));
+                  renderPage(currentPage.value);
+                })
+              }, "+"),
+              createElementVNode("span", _hoisted_9, toDisplayString(scalePercent.value), 1),
+              _cache[4] || (_cache[4] = createElementVNode("span", { class: "gl-pdf-toolbar-divider" }, null, -1)),
+              fitMode.value !== "width" ? (openBlock(), createElementBlock("button", {
+                key: 0,
+                class: "icon-btn",
+                title: "适应宽度",
+                onClick: applyFitWidth
+              }, [
+                createVNode(_component_gl_iconfont, {
+                  type: "gl-adapt-width",
+                  class: "gl-toolbar-icon"
+                })
+              ])) : (openBlock(), createElementBlock("button", {
+                key: 1,
+                class: "icon-btn",
+                title: "适应页面",
+                onClick: applyFitPage
+              }, [
+                createVNode(_component_gl_iconfont, {
+                  type: "gl-adapt-page",
+                  class: "gl-toolbar-icon"
+                })
+              ])),
+              createElementVNode("button", {
+                class: "icon-btn",
+                title: "旋转",
+                onClick: rotateClockwise
+              }, [
+                createVNode(_component_gl_iconfont, {
+                  type: "gl-sync",
+                  class: "gl-toolbar-icon"
+                })
+              ])
+            ]),
+            createElementVNode("div", _hoisted_10, [
+              createElementVNode("button", {
+                class: "icon-btn",
+                title: isFullscreen.value ? "退出最大化" : "最大化",
+                onClick: toggleFullscreen
+              }, [
+                createVNode(_component_gl_iconfont, {
+                  type: isFullscreen.value ? "gl-fullscreen-exit" : "gl-fullscreen",
+                  class: "gl-toolbar-icon"
+                }, null, 8, ["type"])
+              ], 8, _hoisted_11)
+            ])
+          ], 512),
+          createElementVNode("div", {
+            ref_key: "containerRef",
+            ref: containerRef,
+            class: "gl-pdf-content",
+            onWheel: withModifiers(onWheelZoom, ["prevent"]),
+            tabindex: "0"
+          }, null, 544)
+        ]))
+      ], 6);
+    };
+  }
+});
+const GlPdf = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-8114b4d0"]]);
+export {
+  GlPdf as default
+};