kviewer 0.0.1

package/dist/runtime/composables/usePageProxyCache.js

@@ -0,0 +1,73 @@
+import { provide, inject } from "vue";
+const DEFAULT_MAX_SIZE = 50;
+const PAGE_PROXY_CACHE_KEY = Symbol("kviewer-page-proxy-cache");
+export function createPageProxyCache(maxSize = DEFAULT_MAX_SIZE) {
+  let doc = null;
+  const cache = /* @__PURE__ */ new Map();
+  const accessOrder = [];
+  const inflight = /* @__PURE__ */ new Map();
+  function touch(pageNumber) {
+    const idx = accessOrder.indexOf(pageNumber);
+    if (idx !== -1) {
+      accessOrder.splice(idx, 1);
+    }
+    accessOrder.push(pageNumber);
+  }
+  function evict() {
+    while (cache.size > maxSize && accessOrder.length > 0) {
+      const oldest = accessOrder.shift();
+      const proxy = cache.get(oldest);
+      if (proxy) {
+        proxy.cleanup();
+        cache.delete(oldest);
+      }
+    }
+  }
+  function setDocument(newDoc) {
+    clear();
+    doc = newDoc;
+  }
+  async function getPage(pageNumber) {
+    const cached = cache.get(pageNumber);
+    if (cached) {
+      touch(pageNumber);
+      return cached;
+    }
+    const pending = inflight.get(pageNumber);
+    if (pending) return pending;
+    if (!doc) {
+      throw new Error("PageProxyCache: no document set");
+    }
+    const promise = doc.getPage(pageNumber).then((proxy) => {
+      inflight.delete(pageNumber);
+      cache.set(pageNumber, proxy);
+      touch(pageNumber);
+      evict();
+      return proxy;
+    }).catch((err) => {
+      inflight.delete(pageNumber);
+      throw err;
+    });
+    inflight.set(pageNumber, promise);
+    return promise;
+  }
+  function clear() {
+    for (const proxy of cache.values()) {
+      proxy.cleanup();
+    }
+    cache.clear();
+    accessOrder.length = 0;
+    inflight.clear();
+    doc = null;
+  }
+  const cacheInstance = { setDocument, getPage, clear };
+  provide(PAGE_PROXY_CACHE_KEY, cacheInstance);
+  return cacheInstance;
+}
+export function usePageProxyCache() {
+  const cache = inject(PAGE_PROXY_CACHE_KEY);
+  if (!cache) {
+    throw new Error("usePageProxyCache() must be used inside a <KViewer> component");
+  }
+  return cache;
+}

package/dist/runtime/composables/usePageSettings.d.ts

@@ -0,0 +1,16 @@
+import { type Ref } from 'vue';
+export type PageTransition = 'continuous' | 'single-page';
+export type LayoutMode = 'single' | 'double';
+export interface PageSettings {
+    pageTransition: Ref<PageTransition>;
+    setPageTransition: (mode: PageTransition) => void;
+    rotation: Ref<number>;
+    rotateCW: () => void;
+    rotateCCW: () => void;
+    layoutMode: Ref<LayoutMode>;
+    setLayoutMode: (mode: LayoutMode) => void;
+    isFullscreen: Ref<boolean>;
+    toggleFullscreen: () => void;
+}
+export declare function providePageSettings(viewerRoot: Ref<HTMLElement | null>): PageSettings;
+export declare function usePageSettings(): PageSettings;

package/dist/runtime/composables/usePageSettings.js

@@ -0,0 +1,66 @@
+import {
+  ref,
+  provide,
+  inject,
+  onMounted,
+  onBeforeUnmount
+} from "vue";
+const PAGE_SETTINGS_KEY = Symbol("kviewer-page-settings");
+export function providePageSettings(viewerRoot) {
+  const pageTransition = ref("continuous");
+  const rotation = ref(0);
+  const layoutMode = ref("single");
+  const isFullscreen = ref(false);
+  function setPageTransition(mode) {
+    pageTransition.value = mode;
+  }
+  function rotateCW() {
+    rotation.value = (rotation.value + 90) % 360;
+  }
+  function rotateCCW() {
+    rotation.value = (rotation.value - 90 + 360) % 360;
+  }
+  function setLayoutMode(mode) {
+    layoutMode.value = mode;
+  }
+  function toggleFullscreen() {
+    const el = viewerRoot.value;
+    if (!el) return;
+    if (document.fullscreenElement) {
+      document.exitFullscreen();
+    } else {
+      el.requestFullscreen();
+    }
+  }
+  function onFullscreenChange() {
+    isFullscreen.value = !!document.fullscreenElement;
+  }
+  onMounted(() => {
+    document.addEventListener("fullscreenchange", onFullscreenChange);
+  });
+  onBeforeUnmount(() => {
+    document.removeEventListener("fullscreenchange", onFullscreenChange);
+  });
+  const settings = {
+    pageTransition,
+    setPageTransition,
+    rotation,
+    rotateCW,
+    rotateCCW,
+    layoutMode,
+    setLayoutMode,
+    isFullscreen,
+    toggleFullscreen
+  };
+  provide(PAGE_SETTINGS_KEY, settings);
+  return settings;
+}
+export function usePageSettings() {
+  const settings = inject(PAGE_SETTINGS_KEY);
+  if (!settings) {
+    throw new Error(
+      "usePageSettings() must be used inside a <KViewer> component"
+    );
+  }
+  return settings;
+}

package/dist/runtime/composables/usePageVirtualization.d.ts

@@ -0,0 +1,19 @@
+import { type ShallowRef, type ComputedRef, type Ref } from 'vue';
+import type { PDFDocumentProxy } from 'pdfjs-dist';
+export interface PageMeta {
+    pageNumber: number;
+    width: number;
+    height: number;
+}
+export interface PageVirtualization {
+    pageMetas: ShallowRef<PageMeta[]>;
+    currentPage: Ref<number>;
+    renderedPages: ComputedRef<Set<number>>;
+    isPageRendered: (pageNumber: number) => boolean;
+    observePage: (pageNumber: number, element: HTMLElement) => void;
+    unobservePage: (pageNumber: number) => void;
+    scrollToPage: (pageNumber: number) => void;
+    init: (doc: PDFDocumentProxy, scrollRoot: HTMLElement) => Promise<void>;
+    destroy: () => void;
+}
+export declare function createPageVirtualization(): PageVirtualization;

package/dist/runtime/composables/usePageVirtualization.js

@@ -0,0 +1,203 @@
+import { shallowRef, ref, computed, triggerRef } from "vue";
+const PAGE_BUFFER = 3;
+const DIMENSION_BATCH_SIZE = 20;
+export function createPageVirtualization() {
+  const pageMetas = shallowRef([]);
+  const currentPage = ref(1);
+  const visiblePages = shallowRef(/* @__PURE__ */ new Set());
+  let observer = null;
+  let scrollRoot = null;
+  let scrollListener = null;
+  const elementToPage = /* @__PURE__ */ new Map();
+  const pageToElement = /* @__PURE__ */ new Map();
+  const renderedPages = computed(() => {
+    const visible = visiblePages.value;
+    if (visible.size === 0) return /* @__PURE__ */ new Set();
+    const sorted = [...visible].sort((a, b) => a - b);
+    const minPage = sorted[0];
+    const maxPage = sorted[sorted.length - 1];
+    const totalPages = pageMetas.value.length;
+    const bufferMin = Math.max(1, minPage - PAGE_BUFFER);
+    const bufferMax = Math.min(totalPages, maxPage + PAGE_BUFFER);
+    const result = /* @__PURE__ */ new Set();
+    for (let i = bufferMin; i <= bufferMax; i++) {
+      result.add(i);
+    }
+    return result;
+  });
+  function isPageRendered(pageNumber) {
+    return renderedPages.value.has(pageNumber);
+  }
+  function handleIntersection(entries) {
+    let changed = false;
+    const current = new Set(visiblePages.value);
+    for (const entry of entries) {
+      const pageNumber = elementToPage.get(entry.target);
+      if (pageNumber === void 0) continue;
+      if (entry.isIntersecting) {
+        if (!current.has(pageNumber)) {
+          current.add(pageNumber);
+          changed = true;
+        }
+      } else {
+        if (current.has(pageNumber)) {
+          current.delete(pageNumber);
+          changed = true;
+        }
+      }
+    }
+    if (changed) {
+      visiblePages.value = current;
+      triggerRef(visiblePages);
+    }
+  }
+  function observePage(pageNumber, element) {
+    if (!observer) return;
+    const prev = pageToElement.get(pageNumber);
+    if (prev && prev !== element) {
+      observer.unobserve(prev);
+      elementToPage.delete(prev);
+    }
+    elementToPage.set(element, pageNumber);
+    pageToElement.set(pageNumber, element);
+    observer.observe(element);
+  }
+  function unobservePage(pageNumber) {
+    const element = pageToElement.get(pageNumber);
+    if (element) {
+      observer?.unobserve(element);
+      elementToPage.delete(element);
+      pageToElement.delete(pageNumber);
+    }
+  }
+  function updateCurrentPage() {
+    if (!scrollRoot) return;
+    const rootTop = scrollRoot.scrollTop;
+    const rootMid = rootTop + scrollRoot.clientHeight / 2;
+    let bestPage = currentPage.value;
+    let bestDist = Infinity;
+    for (const [pageNum, el] of pageToElement) {
+      const top = el.offsetTop;
+      const bottom = top + el.offsetHeight;
+      const dist = rootMid < top ? top - rootMid : rootMid > bottom ? rootMid - bottom : 0;
+      if (dist < bestDist) {
+        bestDist = dist;
+        bestPage = pageNum;
+      }
+    }
+    if (bestPage !== currentPage.value) {
+      currentPage.value = bestPage;
+    }
+  }
+  function scrollToPage(pageNumber) {
+    const element = pageToElement.get(pageNumber);
+    if (element && scrollRoot) {
+      element.scrollIntoView({ block: "start", behavior: "instant" });
+      currentPage.value = pageNumber;
+    }
+  }
+  async function fetchPageDimensions(doc, pageNumber) {
+    const proxy = await doc.getPage(pageNumber);
+    const view = proxy.view;
+    return {
+      pageNumber,
+      width: view[2] - view[0],
+      height: view[3] - view[1]
+    };
+  }
+  async function init(doc, root) {
+    destroy();
+    scrollRoot = root;
+    const totalPages = doc.numPages;
+    const firstMeta = await fetchPageDimensions(doc, 1);
+    const metas = [];
+    for (let i = 1; i <= totalPages; i++) {
+      if (i === 1) {
+        metas.push(firstMeta);
+      } else {
+        metas.push({
+          pageNumber: i,
+          width: firstMeta.width,
+          height: firstMeta.height
+        });
+      }
+    }
+    pageMetas.value = metas;
+    observer = new IntersectionObserver(handleIntersection, {
+      root,
+      rootMargin: "200% 0px",
+      threshold: 0
+    });
+    scrollListener = () => updateCurrentPage();
+    root.addEventListener("scroll", scrollListener, { passive: true });
+    if (totalPages > 1) {
+      fetchRemainingDimensions(doc, totalPages);
+    }
+  }
+  function fetchRemainingDimensions(doc, totalPages) {
+    let currentPage2 = 2;
+    function processBatch() {
+      if (currentPage2 > totalPages || !observer) return;
+      const batchEnd = Math.min(currentPage2 + DIMENSION_BATCH_SIZE - 1, totalPages);
+      const promises = [];
+      for (let i = currentPage2; i <= batchEnd; i++) {
+        promises.push(fetchPageDimensions(doc, i));
+      }
+      Promise.all(promises).then((results) => {
+        if (!observer) return;
+        const updated = [...pageMetas.value];
+        let changed = false;
+        for (const meta of results) {
+          const idx = meta.pageNumber - 1;
+          const existing = updated[idx];
+          if (existing && (existing.width !== meta.width || existing.height !== meta.height)) {
+            updated[idx] = meta;
+            changed = true;
+          }
+        }
+        if (changed) {
+          pageMetas.value = updated;
+        }
+        currentPage2 = batchEnd + 1;
+        if (currentPage2 <= totalPages) {
+          if (typeof requestIdleCallback === "function") {
+            requestIdleCallback(() => processBatch());
+          } else {
+            setTimeout(processBatch, 0);
+          }
+        }
+      });
+    }
+    if (typeof requestIdleCallback === "function") {
+      requestIdleCallback(() => processBatch());
+    } else {
+      setTimeout(processBatch, 0);
+    }
+  }
+  function destroy() {
+    if (observer) {
+      observer.disconnect();
+      observer = null;
+    }
+    if (scrollListener && scrollRoot) {
+      scrollRoot.removeEventListener("scroll", scrollListener);
+      scrollListener = null;
+    }
+    elementToPage.clear();
+    pageToElement.clear();
+    visiblePages.value = /* @__PURE__ */ new Set();
+    pageMetas.value = [];
+    scrollRoot = null;
+  }
+  return {
+    pageMetas,
+    currentPage,
+    renderedPages,
+    isPageRendered,
+    observePage,
+    unobservePage,
+    scrollToPage,
+    init,
+    destroy
+  };
+}

package/dist/runtime/composables/useSearchIndex.d.ts

@@ -0,0 +1,11 @@
+import { type Ref } from 'vue';
+import type { PDFDocumentProxy } from 'pdfjs-dist';
+export interface SearchIndex {
+    isReady: Ref<boolean>;
+    totalPages: Ref<number>;
+    getPageText: (pageNumber: number) => string | null;
+    buildIndex: (doc: PDFDocumentProxy) => Promise<void>;
+    destroy: () => void;
+}
+export declare function createSearchIndex(): SearchIndex;
+export declare function useSearchIndex(): SearchIndex;

package/dist/runtime/composables/useSearchIndex.js

@@ -0,0 +1,71 @@
+import { ref, provide, inject } from "vue";
+const SEARCH_INDEX_KEY = Symbol("kviewer-search-index");
+const INDEX_BATCH_SIZE = 5;
+export function createSearchIndex() {
+  const isReady = ref(false);
+  const totalPages = ref(0);
+  const pageTexts = /* @__PURE__ */ new Map();
+  let destroyed = false;
+  function getPageText(pageNumber) {
+    return pageTexts.get(pageNumber) ?? null;
+  }
+  async function extractPageText(doc, pageNumber) {
+    const page = await doc.getPage(pageNumber);
+    const content = await page.getTextContent({
+      includeMarkedContent: false,
+      disableNormalization: false
+    });
+    return content.items.filter((item) => "str" in item).map((item) => item.str).join("");
+  }
+  async function buildIndex(doc) {
+    destroyed = false;
+    isReady.value = false;
+    pageTexts.clear();
+    totalPages.value = doc.numPages;
+    let currentPage = 1;
+    while (currentPage <= doc.numPages && !destroyed) {
+      const batchEnd = Math.min(currentPage + INDEX_BATCH_SIZE - 1, doc.numPages);
+      const promises = [];
+      for (let i = currentPage; i <= batchEnd; i++) {
+        const pageNum = i;
+        promises.push(
+          extractPageText(doc, pageNum).then((text) => ({ pageNumber: pageNum, text }))
+        );
+      }
+      const results = await Promise.all(promises);
+      if (destroyed) return;
+      for (const { pageNumber, text } of results) {
+        pageTexts.set(pageNumber, text);
+      }
+      currentPage = batchEnd + 1;
+      if (currentPage <= doc.numPages) {
+        await new Promise((resolve) => {
+          if (typeof requestIdleCallback === "function") {
+            requestIdleCallback(() => resolve());
+          } else {
+            setTimeout(resolve, 0);
+          }
+        });
+      }
+    }
+    if (!destroyed) {
+      isReady.value = true;
+    }
+  }
+  function destroy() {
+    destroyed = true;
+    isReady.value = false;
+    totalPages.value = 0;
+    pageTexts.clear();
+  }
+  const index = { isReady, totalPages, getPageText, buildIndex, destroy };
+  provide(SEARCH_INDEX_KEY, index);
+  return index;
+}
+export function useSearchIndex() {
+  const index = inject(SEARCH_INDEX_KEY);
+  if (!index) {
+    throw new Error("useSearchIndex() must be used inside a <KViewer> component");
+  }
+  return index;
+}

package/dist/runtime/composables/useViewerSearch.d.ts

@@ -0,0 +1,32 @@
+import { type Ref } from 'vue';
+export interface ViewerSearchState {
+    isOpen: Ref<boolean>;
+    query: Ref<string>;
+    matchCase: Ref<boolean>;
+    wholeWord: Ref<boolean>;
+    highlightAll: Ref<boolean>;
+    currentMatch: Ref<number>;
+    totalMatches: Ref<number>;
+    notFound: Ref<boolean>;
+    open: () => void;
+    close: () => void;
+    reset: () => void;
+    setQuery: (value: string) => void;
+    toggleMatchCase: () => void;
+    toggleWholeWord: () => void;
+    toggleHighlightAll: () => void;
+    findNext: () => void;
+    findPrevious: () => void;
+    registerPageLayer: (pageNumber: number, textDivs: HTMLElement[], textContentItemsStr: string[]) => void;
+    updatePageLayer: (pageNumber: number, textDivs: HTMLElement[], textContentItemsStr: string[]) => void;
+    unregisterPageLayer: (pageNumber: number) => void;
+    setInputElement: (input: HTMLInputElement | null) => void;
+    focusInput: () => void;
+    setSearchIndex: (index: {
+        getPageText: (pageNumber: number) => string | null;
+        totalPages: number;
+    }) => void;
+    setScrollToPage: (fn: (pageNumber: number) => void) => void;
+}
+export declare function provideViewerSearch(): ViewerSearchState;
+export declare function useViewerSearch(): ViewerSearchState;