kviewer 0.0.1

package/dist/runtime/components/tools/ToolProperties.vue

@@ -0,0 +1,174 @@
+<template>
+  <div class="flex items-center gap-2 px-2 py-1 rounded-md border border-default bg-default/60 lg:min-w-64">
+    <template v-if="supportsProperties">
+      <!-- ── Desktop: inline color buttons + slider (md and above) ── -->
+      <div class="hidden lg:flex items-center gap-1">
+        <button
+          v-for="color in colors"
+          :key="color"
+          class="w-4 h-4 rounded-full border-2 cursor-pointer transition-transform hover:scale-110"
+          :class="color === currentColor ? 'border-white ring-1 ring-primary' : 'border-transparent'"
+          :style="{ backgroundColor: color }"
+          :title="`Color: ${color}`"
+          @click="setColor(color)"
+        />
+      </div>
+
+      <div
+        v-if="activeType === AnnotationType.FREEHAND"
+        class="hidden lg:flex items-center gap-2 min-w-40"
+      >
+        <UIcon name="i-lucide-minus" class="text-[10px] text-muted" />
+        <USlider
+          :model-value="freehandStrokeWidth"
+          :min="1"
+          :max="24"
+          :step="1"
+          size="sm"
+          class="w-28"
+          @update:model-value="setFreehandSize"
+        />
+        <UIcon name="i-lucide-plus" class="text-[10px] text-muted" />
+        <span class="w-9 text-[11px] text-muted text-right tabular-nums">
+          {{ freehandStrokeWidth }}px
+        </span>
+      </div>
+
+      <!-- ── Mobile: two popover buttons (below md) ── -->
+      <div class="flex lg:hidden items-center gap-1">
+        <!-- Color popover -->
+        <UPopover v-model:open="colorPopoverOpen">
+          <button
+            class="flex items-center justify-center w-7 h-7 rounded-md hover:bg-default cursor-pointer"
+            title="Color"
+          >
+            <span
+              class="w-4 h-4 rounded-full border border-white/30"
+              :style="{ backgroundColor: currentColor ?? colors[0] }"
+            />
+          </button>
+          <template #content>
+            <div class="p-3">
+              <div class="grid grid-cols-4 gap-1.5">
+                <button
+                  v-for="color in colors"
+                  :key="color"
+                  class="w-7 h-7 rounded-full border-2 cursor-pointer transition-transform hover:scale-110"
+                  :class="color === currentColor ? 'border-white ring-2 ring-primary' : 'border-transparent'"
+                  :style="{ backgroundColor: color }"
+                  @click="setColorAndClose(color)"
+                />
+              </div>
+            </div>
+          </template>
+        </UPopover>
+
+        <!-- Stroke width popover (freehand only) -->
+        <UPopover v-if="activeType === AnnotationType.FREEHAND">
+          <button
+            class="flex items-center justify-center h-7 px-1.5 gap-0.5 rounded-md hover:bg-default cursor-pointer"
+            title="Stroke width"
+          >
+            <UIcon name="i-lucide-pencil" class="text-sm text-muted" />
+            <span class="text-[10px] text-muted tabular-nums">{{ freehandStrokeWidth }}</span>
+          </button>
+          <template #content>
+            <div class="p-3 flex items-center gap-3">
+              <button
+                class="flex items-center justify-center w-8 h-8 rounded-md hover:bg-default cursor-pointer disabled:opacity-40 disabled:cursor-not-allowed"
+                :disabled="freehandStrokeWidth <= 1"
+                title="Decrease stroke width"
+                @click="decrementStrokeWidth"
+              >
+                <UIcon name="i-lucide-minus" class="text-sm" />
+              </button>
+              <span class="w-9 text-center text-sm tabular-nums">
+                {{ freehandStrokeWidth }}px
+              </span>
+              <button
+                class="flex items-center justify-center w-8 h-8 rounded-md hover:bg-default cursor-pointer disabled:opacity-40 disabled:cursor-not-allowed"
+                :disabled="freehandStrokeWidth >= 24"
+                title="Increase stroke width"
+                @click="incrementStrokeWidth"
+              >
+                <UIcon name="i-lucide-plus" class="text-sm" />
+              </button>
+            </div>
+          </template>
+        </UPopover>
+      </div>
+    </template>
+
+    <template v-else>
+      <div class="flex items-center gap-1.5 text-xs text-muted">
+        <UIcon name="i-lucide-sliders-horizontal" class="text-sm" />
+        <span>No properties</span>
+      </div>
+    </template>
+  </div>
+</template>
+
+<script setup>
+import { computed, ref } from "vue";
+import { defaultOptions, annotationDefinitions } from "../../annotation/engine/config";
+import { AnnotationType } from "../../annotation/engine/types";
+import { useViewerState } from "../../composables/useViewerState";
+const emit = defineEmits(["styleUpdated"]);
+const state = useViewerState();
+const colors = defaultOptions.colors;
+const styleVersion = ref(0);
+const colorPopoverOpen = ref(false);
+const activeType = computed(() => {
+  return typeof state.activeTool.value === "number" ? state.activeTool.value : null;
+});
+const supportsProperties = computed(
+  () => activeType.value === AnnotationType.FREEHAND || activeType.value === AnnotationType.FREE_HIGHLIGHT || activeType.value === AnnotationType.RECTANGLE
+);
+const activeDef = computed(() => {
+  if (!supportsProperties.value || activeType.value === null) return null;
+  styleVersion.value;
+  return getDef(activeType.value);
+});
+const currentColor = computed(() => {
+  styleVersion.value;
+  if (activeType.value === null) return null;
+  const def = getDef(activeType.value);
+  return def?.style?.color ?? null;
+});
+const freehandStrokeWidth = computed(() => {
+  styleVersion.value;
+  const def = getDef(AnnotationType.FREEHAND);
+  return def?.style?.strokeWidth ?? defaultOptions.setting.STROKE_WIDTH;
+});
+function getDef(type) {
+  return annotationDefinitions.find((d) => d.type === type);
+}
+function setColor(color) {
+  if (!supportsProperties.value) return;
+  const def = activeDef.value;
+  if (!def) return;
+  def.style = { ...def.style ?? {}, color };
+  styleVersion.value++;
+  emit("styleUpdated");
+}
+function setColorAndClose(color) {
+  setColor(color);
+  colorPopoverOpen.value = false;
+}
+function setFreehandSize(value) {
+  const raw = Array.isArray(value) ? value[0] : value;
+  if (raw === void 0) return;
+  const def = getDef(AnnotationType.FREEHAND);
+  if (!def) return;
+  const strokeWidth = Math.min(24, Math.max(1, Math.round(raw)));
+  def.style = { ...def.style ?? {}, strokeWidth };
+  styleVersion.value++;
+  emit("styleUpdated");
+}
+function incrementStrokeWidth() {
+  if (freehandStrokeWidth.value < 24) setFreehandSize(freehandStrokeWidth.value + 1);
+}
+function decrementStrokeWidth() {
+  if (freehandStrokeWidth.value > 1) setFreehandSize(freehandStrokeWidth.value - 1);
+}
+</script>

package/dist/runtime/components/tools/ToolProperties.vue.d.ts

@@ -0,0 +1,7 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    styleUpdated: () => any;
+}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{
+    onStyleUpdated?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/tools/ZoomControls.d.vue.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/tools/ZoomControls.vue

@@ -0,0 +1,59 @@
+<template>
+  <div class="flex items-center gap-1">
+    <USelect
+      :items="zoomItems"
+      :model-value="currentZoomValue"
+      variant="ghost"
+      color="neutral"
+      size="xs"
+      class="w-24"
+      @update:model-value="onZoomChange"
+    />
+    <UButton
+      icon="i-lucide-minus"
+      variant="ghost"
+      color="neutral"
+      size="xs"
+      @click="state.zoomOut"
+    />
+    <UButton
+      icon="i-lucide-plus"
+      variant="ghost"
+      color="neutral"
+      size="xs"
+      @click="state.zoomIn"
+    />
+  </div>
+</template>
+
+<script setup>
+import { computed } from "vue";
+import { useViewerState } from "../../composables/useViewerState";
+const state = useViewerState();
+const fitModeItems = [
+  { label: "Fit Width", value: "fit-width" },
+  { label: "Fit Page", value: "fit-page" }
+];
+const scaleItems = computed(
+  () => state.scaleOptions.map((s) => ({
+    label: `${Math.round(s * 100)}%`,
+    value: `scale:${s}`
+  }))
+);
+const zoomItems = computed(() => [
+  ...fitModeItems,
+  { label: "---", value: "_separator", disabled: true },
+  ...scaleItems.value
+]);
+const currentZoomValue = computed(() => {
+  if (state.fitMode.value !== "custom") return state.fitMode.value;
+  return `scale:${state.scale.value}`;
+});
+function onZoomChange(value) {
+  if (value.startsWith("scale:")) {
+    state.setScale(Number(value.slice(6)));
+  } else if (value !== "_separator") {
+    state.setFitMode(value);
+  }
+}
+</script>

package/dist/runtime/components/tools/ZoomControls.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/composables/search-utils.d.ts

@@ -0,0 +1,20 @@
+export interface SearchMatch {
+    index: number;
+    length: number;
+}
+export interface SearchOptions {
+    matchCase: boolean;
+    wholeWord: boolean;
+}
+export interface FlattenedMatch {
+    pageNumber: number;
+    matchIndex: number;
+}
+export interface RenderRange {
+    start: number;
+    end: number;
+}
+export declare function findMatchesInText(text: string, query: string, options: SearchOptions): SearchMatch[];
+export declare function flattenMatchesByPage(pageNumbers: number[], matchesByPage: Map<number, SearchMatch[]>): FlattenedMatch[];
+export declare function stepMatchIndex(currentIndex: number, totalMatches: number, previous: boolean): number;
+export declare function getRenderRange(totalMatchesInPage: number, highlightAll: boolean, isSelectedPage: boolean, selectedMatchIndex: number): RenderRange | null;

package/dist/runtime/composables/search-utils.js

@@ -0,0 +1,55 @@
+function isWordCharacter(char) {
+  if (!char) return false;
+  return /[\p{L}\p{N}_]/u.test(char);
+}
+function hasWholeWordBoundary(text, start, length) {
+  const before = start > 0 ? text[start - 1] : void 0;
+  const after = start + length < text.length ? text[start + length] : void 0;
+  return !isWordCharacter(before) && !isWordCharacter(after);
+}
+export function findMatchesInText(text, query, options) {
+  if (!query) return [];
+  const normalizedText = options.matchCase ? text : text.toLocaleLowerCase();
+  const normalizedQuery = options.matchCase ? query : query.toLocaleLowerCase();
+  const matches = [];
+  let fromIndex = 0;
+  while (fromIndex <= normalizedText.length - normalizedQuery.length) {
+    const index = normalizedText.indexOf(normalizedQuery, fromIndex);
+    if (index === -1) break;
+    if (!options.wholeWord || hasWholeWordBoundary(normalizedText, index, normalizedQuery.length)) {
+      matches.push({ index, length: normalizedQuery.length });
+    }
+    fromIndex = index + Math.max(1, normalizedQuery.length);
+  }
+  return matches;
+}
+export function flattenMatchesByPage(pageNumbers, matchesByPage) {
+  const flattened = [];
+  for (const pageNumber of pageNumbers) {
+    const pageMatches = matchesByPage.get(pageNumber) ?? [];
+    for (let matchIndex = 0; matchIndex < pageMatches.length; matchIndex++) {
+      flattened.push({ pageNumber, matchIndex });
+    }
+  }
+  return flattened;
+}
+export function stepMatchIndex(currentIndex, totalMatches, previous) {
+  if (totalMatches <= 0) return -1;
+  if (currentIndex < 0 || currentIndex >= totalMatches) {
+    return previous ? totalMatches - 1 : 0;
+  }
+  if (previous) {
+    return currentIndex === 0 ? totalMatches - 1 : currentIndex - 1;
+  }
+  return currentIndex === totalMatches - 1 ? 0 : currentIndex + 1;
+}
+export function getRenderRange(totalMatchesInPage, highlightAll, isSelectedPage, selectedMatchIndex) {
+  if (totalMatchesInPage <= 0) return null;
+  if (highlightAll) {
+    return { start: 0, end: totalMatchesInPage };
+  }
+  if (!isSelectedPage || selectedMatchIndex < 0 || selectedMatchIndex >= totalMatchesInPage) {
+    return null;
+  }
+  return { start: selectedMatchIndex, end: selectedMatchIndex + 1 };
+}

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

@@ -0,0 +1,7 @@
+import { Painter, type PainterCallbacks } from '../annotation/engine/painter.js';
+import type { ViewerState } from './useViewerState.js';
+export declare function createAnnotationEngine(viewerState: ViewerState, options: {
+    userName?: string;
+    onRequestTextInput: PainterCallbacks['onRequestTextInput'];
+    onRequestDeleteConfirm?: PainterCallbacks['onRequestDeleteConfirm'];
+}): Painter;

package/dist/runtime/composables/useAnnotationEngine.js

@@ -0,0 +1,70 @@
+import { triggerRef } from "vue";
+import { Painter } from "../annotation/engine/painter.js";
+import {
+  AnnotationType
+} from "../annotation/engine/types.js";
+export function createAnnotationEngine(viewerState, options) {
+  const callbacks = {
+    setDefaultMode: () => {
+      const tool = viewerState.activeTool.value;
+      if (tool === AnnotationType.STAMP || tool === AnnotationType.SIGNATURE) return;
+      viewerState.selectTool("hand");
+    },
+    forceReset: () => {
+      viewerState.selectTool("hand");
+    },
+    onStoreAdd: (annotationStore, isOriginal, _currentAnnotation) => {
+      viewerState.annotations.value.set(annotationStore.id, annotationStore);
+      triggerRef(viewerState.annotations);
+      if (!isOriginal) {
+        viewerState.history.commit();
+        if (annotationStore.type === AnnotationType.FREETEXT) {
+          viewerState.painter.value?.selectAnnotation(annotationStore.id);
+        }
+      }
+    },
+    onStoreDelete: (id) => {
+      viewerState.annotations.value.delete(id);
+      triggerRef(viewerState.annotations);
+      if (viewerState.selectedAnnotation.value?.id === id) {
+        viewerState.selectedAnnotation.value = null;
+        viewerState.selectionRect.value = null;
+      }
+      viewerState.history.commit();
+    },
+    onAnnotationSelected: (annotationStore, _isClick, selectorRect) => {
+      viewerState.selectedAnnotation.value = annotationStore;
+      viewerState.selectedAnnotations.value = [annotationStore];
+      viewerState.selectionRect.value = selectorRect;
+    },
+    onMultiSelected: (annotationStores, combinedRect) => {
+      viewerState.selectedAnnotation.value = null;
+      viewerState.selectedAnnotations.value = annotationStores;
+      viewerState.selectionRect.value = combinedRect;
+      viewerState.activeTool.value = "hand";
+    },
+    onAnnotationChange: (annotationStore) => {
+      viewerState.annotations.value.set(annotationStore.id, annotationStore);
+      triggerRef(viewerState.annotations);
+    },
+    onAnnotationChanging: () => {
+      viewerState.selectionRect.value = null;
+    },
+    onAnnotationChanged: (annotationStore, selectorRect) => {
+      viewerState.annotations.value.set(annotationStore.id, annotationStore);
+      triggerRef(viewerState.annotations);
+      viewerState.selectedAnnotation.value = annotationStore;
+      viewerState.selectionRect.value = selectorRect;
+      viewerState.history.commit();
+    },
+    onRequestTextInput: options.onRequestTextInput,
+    onRequestDeleteConfirm: options.onRequestDeleteConfirm
+  };
+  const painter = new Painter({
+    userName: options.userName ?? "User",
+    callbacks,
+    getStylusModeEnabled: () => viewerState.stylusMode.value
+  });
+  viewerState.painter.value = painter;
+  return painter;
+}

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

@@ -0,0 +1,12 @@
+import { type ComputedRef, type ShallowRef } from 'vue';
+import type { Painter } from '../annotation/engine/painter.js';
+import type { IAnnotationStore } from '../annotation/engine/types.js';
+export interface AnnotationHistory {
+    commit: () => void;
+    undo: () => void;
+    redo: () => void;
+    reset: () => void;
+    canUndo: ComputedRef<boolean>;
+    canRedo: ComputedRef<boolean>;
+}
+export declare function createAnnotationHistory(annotations: ShallowRef<Map<string, IAnnotationStore>>, painter: ShallowRef<Painter | null>): AnnotationHistory;

package/dist/runtime/composables/useAnnotationHistory.js

@@ -0,0 +1,69 @@
+import { ref, computed, triggerRef } from "vue";
+const MAX_HISTORY = 50;
+function cloneAnnotations(map) {
+  return Array.from(map.values()).map((a) => ({ ...a, comments: [...a.comments] }));
+}
+export function createAnnotationHistory(annotations, painter) {
+  const undoStack = ref([]);
+  const redoStack = ref([]);
+  const canUndo = computed(() => undoStack.value.length > 0);
+  const canRedo = computed(() => redoStack.value.length > 0);
+  function commit() {
+    const snapshot = cloneAnnotations(annotations.value);
+    undoStack.value.push(snapshot);
+    if (undoStack.value.length > MAX_HISTORY) {
+      undoStack.value.shift();
+    }
+    redoStack.value = [];
+  }
+  function restoreSnapshot(target) {
+    const p = painter.value;
+    if (!p) return;
+    const currentMap = /* @__PURE__ */ new Map();
+    for (const a of p.getData()) {
+      currentMap.set(a.id, a);
+    }
+    const targetMap = /* @__PURE__ */ new Map();
+    for (const a of target) {
+      targetMap.set(a.id, a);
+    }
+    for (const id of currentMap.keys()) {
+      if (!targetMap.has(id)) {
+        p.delete(id, false);
+      }
+    }
+    for (const ann of target) {
+      if (!currentMap.has(ann.id)) {
+        p.reAddAnnotation(ann);
+      }
+    }
+    for (const ann of target) {
+      const current = currentMap.get(ann.id);
+      if (current && current.konvaString !== ann.konvaString) {
+        p.delete(ann.id, false);
+        p.reAddAnnotation(ann);
+      }
+    }
+    annotations.value = targetMap;
+    triggerRef(annotations);
+  }
+  function undo() {
+    if (!canUndo.value) return;
+    const currentSnapshot = cloneAnnotations(annotations.value);
+    redoStack.value.push(currentSnapshot);
+    const target = undoStack.value.pop();
+    restoreSnapshot(target);
+  }
+  function redo() {
+    if (!canRedo.value) return;
+    const currentSnapshot = cloneAnnotations(annotations.value);
+    undoStack.value.push(currentSnapshot);
+    const target = redoStack.value.pop();
+    restoreSnapshot(target);
+  }
+  function reset() {
+    undoStack.value = [];
+    redoStack.value = [];
+  }
+  return { commit, undo, redo, reset, canUndo, canRedo };
+}

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

@@ -0,0 +1,26 @@
+import { type ShallowRef } from 'vue';
+import type { FormFieldDefinition, FormFieldValue } from '../annotation/engine/types.js';
+export interface FormFieldsState {
+    /** Field definitions grouped by page number */
+    fieldDefinitions: ShallowRef<Map<number, FormFieldDefinition[]>>;
+    /** Field values keyed by field id */
+    fieldValues: ShallowRef<Map<string, FormFieldValue>>;
+    /** Parse form fields from raw pdf.js annotations for a page (idempotent) */
+    parsePageFields: (pageNumber: number, rawAnnotations: unknown[]) => void;
+    /** Set a field value by field id */
+    setFieldValue: (fieldId: string, value: string | boolean | string[]) => void;
+    /** Get a field value by field id */
+    getFieldValue: (fieldId: string) => FormFieldValue | undefined;
+    /** Get field definitions for a page */
+    getFieldsForPage: (pageNumber: number) => FormFieldDefinition[];
+    /** Get all field values (for export) */
+    getAllFieldValues: () => FormFieldValue[];
+    /** Set a field value by field name (public API for programmatic fill) */
+    setFieldValueByName: (fieldName: string, value: string | boolean | string[]) => void;
+    /** Reset all field values to their defaults (keeps definitions) */
+    resetValues: () => void;
+    /** Clear all values and definitions (for document change) */
+    reset: () => void;
+}
+export declare function provideFormFields(): FormFieldsState;
+export declare function useFormFields(): FormFieldsState;

package/dist/runtime/composables/useFormFields.js

@@ -0,0 +1,112 @@
+import {
+  shallowRef,
+  triggerRef,
+  provide,
+  inject
+} from "vue";
+import { parseFormFields } from "../annotation/parsers/parseFormFields.js";
+const FORM_FIELDS_KEY = Symbol("kviewer-form-fields");
+export function provideFormFields() {
+  const fieldDefinitions = shallowRef(/* @__PURE__ */ new Map());
+  const fieldValues = shallowRef(/* @__PURE__ */ new Map());
+  function parsePageFields(pageNumber, rawAnnotations) {
+    if (fieldDefinitions.value.has(pageNumber)) return;
+    const defs = parseFormFields(rawAnnotations, pageNumber);
+    if (defs.length === 0) return;
+    fieldDefinitions.value.set(pageNumber, defs);
+    triggerRef(fieldDefinitions);
+    for (const def of defs) {
+      if (fieldValues.value.has(def.id)) continue;
+      fieldValues.value.set(def.id, {
+        fieldId: def.id,
+        fieldName: def.fieldName,
+        fieldType: def.fieldType,
+        value: getDefaultValue(def)
+      });
+    }
+    triggerRef(fieldValues);
+  }
+  function setFieldValue(fieldId, value) {
+    const existing = fieldValues.value.get(fieldId);
+    if (!existing) return;
+    existing.value = value;
+    if (existing.fieldType === "radio" && typeof value === "string" && value !== "") {
+      const fieldName = existing.fieldName;
+      for (const [id, fv] of fieldValues.value.entries()) {
+        if (id !== fieldId && fv.fieldName === fieldName && fv.fieldType === "radio") {
+          fv.value = "";
+        }
+      }
+    }
+    triggerRef(fieldValues);
+  }
+  function getFieldValue(fieldId) {
+    return fieldValues.value.get(fieldId);
+  }
+  function getFieldsForPage(pageNumber) {
+    return fieldDefinitions.value.get(pageNumber) ?? [];
+  }
+  function getAllFieldValues() {
+    return Array.from(fieldValues.value.values());
+  }
+  function setFieldValueByName(fieldName, value) {
+    for (const [, fv] of fieldValues.value.entries()) {
+      if (fv.fieldName === fieldName) {
+        fv.value = value;
+      }
+    }
+    triggerRef(fieldValues);
+  }
+  function getDefaultValue(def) {
+    if (def.fieldType === "checkbox") {
+      return def.defaultValue != null && def.defaultValue !== "Off" && def.defaultValue !== "";
+    }
+    if (def.fieldType === "radio") {
+      return def.defaultValue ?? "";
+    }
+    if (def.fieldType === "text" || def.fieldType === "dropdown") {
+      return def.defaultValue ?? "";
+    }
+    return "";
+  }
+  function resetValues() {
+    for (const [, defs] of fieldDefinitions.value.entries()) {
+      for (const def of defs) {
+        const fv = fieldValues.value.get(def.id);
+        if (fv) {
+          fv.value = getDefaultValue(def);
+        }
+      }
+    }
+    triggerRef(fieldValues);
+  }
+  function reset() {
+    fieldDefinitions.value = /* @__PURE__ */ new Map();
+    fieldValues.value = /* @__PURE__ */ new Map();
+    triggerRef(fieldDefinitions);
+    triggerRef(fieldValues);
+  }
+  const state = {
+    fieldDefinitions,
+    fieldValues,
+    parsePageFields,
+    setFieldValue,
+    getFieldValue,
+    getFieldsForPage,
+    getAllFieldValues,
+    setFieldValueByName,
+    resetValues,
+    reset
+  };
+  provide(FORM_FIELDS_KEY, state);
+  return state;
+}
+export function useFormFields() {
+  const state = inject(FORM_FIELDS_KEY);
+  if (!state) {
+    throw new Error(
+      "useFormFields() must be used inside a <KViewer> component"
+    );
+  }
+  return state;
+}

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

@@ -0,0 +1,8 @@
+import type { PDFDocumentProxy, PDFPageProxy } from 'pdfjs-dist';
+export interface PageProxyCache {
+    setDocument: (doc: PDFDocumentProxy) => void;
+    getPage: (pageNumber: number) => Promise<PDFPageProxy>;
+    clear: () => void;
+}
+export declare function createPageProxyCache(maxSize?: number): PageProxyCache;
+export declare function usePageProxyCache(): PageProxyCache;