kviewer 0.0.1

package/dist/runtime/annotation/engine/types.d.ts

@@ -0,0 +1,170 @@
+import type { IRect } from 'konva/lib/types';
+export type PdfjsAnnotationSubtype = 'Link' | 'Text' | 'Widget' | 'Popup' | 'FreeText' | 'Line' | 'Square' | 'Circle' | 'PolyLine' | 'Polygon' | 'Caret' | 'Ink' | 'Highlight' | 'Underline' | 'Squiggly' | 'StrikeOut' | 'Stamp' | 'FileAttachment' | 'Note' | 'Arrow';
+export declare enum PdfjsAnnotationType {
+    NONE = 0,
+    TEXT = 1,
+    LINK = 2,
+    FREETEXT = 3,
+    LINE = 4,
+    SQUARE = 5,
+    CIRCLE = 6,
+    POLYGON = 7,
+    POLYLINE = 8,
+    HIGHLIGHT = 9,
+    UNDERLINE = 10,
+    SQUIGGLY = 11,
+    STRIKEOUT = 12,
+    STAMP = 13,
+    CARET = 14,
+    INK = 15,
+    POPUP = 16,
+    FILEATTACHMENT = 17,
+    SOUND = 18,
+    MOVIE = 19,
+    WIDGET = 20,
+    SCREEN = 21,
+    PRINTERMARK = 22,
+    TRAPNET = 23,
+    WATERMARK = 24,
+    THREED = 25,
+    REDACT = 26,
+    NOTE = 27
+}
+export declare enum PdfjsAnnotationEditorType {
+    DISABLE = -1,
+    NONE = 0,
+    FREETEXT = 3,
+    HIGHLIGHT = 9,
+    STAMP = 13,
+    INK = 15
+}
+export declare enum AnnotationType {
+    NONE = -1,
+    SELECT = 0,
+    HIGHLIGHT = 1,
+    STRIKEOUT = 2,
+    UNDERLINE = 3,
+    FREETEXT = 4,
+    RECTANGLE = 5,
+    CIRCLE = 6,
+    FREEHAND = 7,
+    FREE_HIGHLIGHT = 8,
+    SIGNATURE = 9,
+    STAMP = 10,
+    NOTE = 11,
+    ARROW = 12,
+    CLOUD = 13
+}
+export interface IAnnotationType {
+    name: string;
+    type: AnnotationType;
+    pdfjsEditorType: PdfjsAnnotationEditorType;
+    pdfjsAnnotationType: PdfjsAnnotationType;
+    subtype?: PdfjsAnnotationSubtype;
+    isOnce: boolean;
+    resizable: boolean;
+    draggable: boolean;
+    icon?: string;
+    style?: IAnnotationStyle;
+    styleEditable?: {
+        color: boolean;
+        strokeWidth: boolean;
+        opacity: boolean;
+    };
+}
+export interface IAnnotationStyle {
+    color?: string;
+    fontSize?: number;
+    opacity?: number;
+    strokeWidth?: number;
+}
+export interface IAnnotationComment {
+    id: string;
+    title: string;
+    date: string;
+    content: string;
+    status?: CommentStatus;
+}
+export declare enum CommentStatus {
+    Accepted = "Accepted",
+    Rejected = "Rejected",
+    Cancelled = "Cancelled",
+    Completed = "Completed",
+    None = "None",
+    Closed = "Closed"
+}
+export interface IAnnotationContentsObj {
+    text: string;
+    image?: string;
+}
+export interface StampDefinition {
+    id: string;
+    name: string;
+    imageUrl: string;
+    previewUrl?: string;
+    width?: number;
+    height?: number;
+}
+export interface SignatureData {
+    id: string;
+    imageUrl: string;
+    name?: string;
+}
+export interface SignatureHandlers {
+    onLoad: () => Promise<SignatureData[]>;
+    onSave: (imageUrl: string) => Promise<SignatureData>;
+    onDelete: (id: string) => Promise<void>;
+}
+export interface IAnnotationStore {
+    id: string;
+    pageNumber: number;
+    konvaString: string;
+    konvaClientRect: IRect;
+    title: string;
+    type: AnnotationType;
+    color?: string | null;
+    subtype: PdfjsAnnotationSubtype;
+    fontSize?: number | null;
+    pdfjsType: PdfjsAnnotationType;
+    pdfjsEditorType: PdfjsAnnotationEditorType;
+    date: string;
+    contentsObj?: IAnnotationContentsObj | null;
+    comments: IAnnotationComment[];
+    resizable: boolean;
+    draggable: boolean;
+}
+export type FormFieldType = 'text' | 'checkbox' | 'radio' | 'dropdown' | 'signature' | 'button';
+export interface FormFieldDefinition {
+    id: string;
+    pageNumber: number;
+    fieldType: FormFieldType;
+    fieldName: string;
+    rect: [number, number, number, number];
+    readOnly: boolean;
+    required: boolean;
+    defaultValue?: string;
+    maxLen?: number;
+    multiLine?: boolean;
+    password?: boolean;
+    comb?: boolean;
+    exportValue?: string;
+    buttonValue?: string;
+    options?: {
+        displayValue: string;
+        exportValue: string;
+    }[];
+    combo?: boolean;
+    multiSelect?: boolean;
+    editable?: boolean;
+    buttonLabel?: string;
+    fontSize?: number;
+    color?: number[];
+    backgroundColor?: number[];
+    textAlignment?: number;
+}
+export interface FormFieldValue {
+    fieldId: string;
+    fieldName: string;
+    fieldType: FormFieldType;
+    value: string | boolean | string[];
+}

package/dist/runtime/annotation/engine/types.js

@@ -0,0 +1,67 @@
+export var PdfjsAnnotationType = /* @__PURE__ */ ((PdfjsAnnotationType2) => {
+  PdfjsAnnotationType2[PdfjsAnnotationType2["NONE"] = 0] = "NONE";
+  PdfjsAnnotationType2[PdfjsAnnotationType2["TEXT"] = 1] = "TEXT";
+  PdfjsAnnotationType2[PdfjsAnnotationType2["LINK"] = 2] = "LINK";
+  PdfjsAnnotationType2[PdfjsAnnotationType2["FREETEXT"] = 3] = "FREETEXT";
+  PdfjsAnnotationType2[PdfjsAnnotationType2["LINE"] = 4] = "LINE";
+  PdfjsAnnotationType2[PdfjsAnnotationType2["SQUARE"] = 5] = "SQUARE";
+  PdfjsAnnotationType2[PdfjsAnnotationType2["CIRCLE"] = 6] = "CIRCLE";
+  PdfjsAnnotationType2[PdfjsAnnotationType2["POLYGON"] = 7] = "POLYGON";
+  PdfjsAnnotationType2[PdfjsAnnotationType2["POLYLINE"] = 8] = "POLYLINE";
+  PdfjsAnnotationType2[PdfjsAnnotationType2["HIGHLIGHT"] = 9] = "HIGHLIGHT";
+  PdfjsAnnotationType2[PdfjsAnnotationType2["UNDERLINE"] = 10] = "UNDERLINE";
+  PdfjsAnnotationType2[PdfjsAnnotationType2["SQUIGGLY"] = 11] = "SQUIGGLY";
+  PdfjsAnnotationType2[PdfjsAnnotationType2["STRIKEOUT"] = 12] = "STRIKEOUT";
+  PdfjsAnnotationType2[PdfjsAnnotationType2["STAMP"] = 13] = "STAMP";
+  PdfjsAnnotationType2[PdfjsAnnotationType2["CARET"] = 14] = "CARET";
+  PdfjsAnnotationType2[PdfjsAnnotationType2["INK"] = 15] = "INK";
+  PdfjsAnnotationType2[PdfjsAnnotationType2["POPUP"] = 16] = "POPUP";
+  PdfjsAnnotationType2[PdfjsAnnotationType2["FILEATTACHMENT"] = 17] = "FILEATTACHMENT";
+  PdfjsAnnotationType2[PdfjsAnnotationType2["SOUND"] = 18] = "SOUND";
+  PdfjsAnnotationType2[PdfjsAnnotationType2["MOVIE"] = 19] = "MOVIE";
+  PdfjsAnnotationType2[PdfjsAnnotationType2["WIDGET"] = 20] = "WIDGET";
+  PdfjsAnnotationType2[PdfjsAnnotationType2["SCREEN"] = 21] = "SCREEN";
+  PdfjsAnnotationType2[PdfjsAnnotationType2["PRINTERMARK"] = 22] = "PRINTERMARK";
+  PdfjsAnnotationType2[PdfjsAnnotationType2["TRAPNET"] = 23] = "TRAPNET";
+  PdfjsAnnotationType2[PdfjsAnnotationType2["WATERMARK"] = 24] = "WATERMARK";
+  PdfjsAnnotationType2[PdfjsAnnotationType2["THREED"] = 25] = "THREED";
+  PdfjsAnnotationType2[PdfjsAnnotationType2["REDACT"] = 26] = "REDACT";
+  PdfjsAnnotationType2[PdfjsAnnotationType2["NOTE"] = 27] = "NOTE";
+  return PdfjsAnnotationType2;
+})(PdfjsAnnotationType || {});
+export var PdfjsAnnotationEditorType = /* @__PURE__ */ ((PdfjsAnnotationEditorType2) => {
+  PdfjsAnnotationEditorType2[PdfjsAnnotationEditorType2["DISABLE"] = -1] = "DISABLE";
+  PdfjsAnnotationEditorType2[PdfjsAnnotationEditorType2["NONE"] = 0] = "NONE";
+  PdfjsAnnotationEditorType2[PdfjsAnnotationEditorType2["FREETEXT"] = 3] = "FREETEXT";
+  PdfjsAnnotationEditorType2[PdfjsAnnotationEditorType2["HIGHLIGHT"] = 9] = "HIGHLIGHT";
+  PdfjsAnnotationEditorType2[PdfjsAnnotationEditorType2["STAMP"] = 13] = "STAMP";
+  PdfjsAnnotationEditorType2[PdfjsAnnotationEditorType2["INK"] = 15] = "INK";
+  return PdfjsAnnotationEditorType2;
+})(PdfjsAnnotationEditorType || {});
+export var AnnotationType = /* @__PURE__ */ ((AnnotationType2) => {
+  AnnotationType2[AnnotationType2["NONE"] = -1] = "NONE";
+  AnnotationType2[AnnotationType2["SELECT"] = 0] = "SELECT";
+  AnnotationType2[AnnotationType2["HIGHLIGHT"] = 1] = "HIGHLIGHT";
+  AnnotationType2[AnnotationType2["STRIKEOUT"] = 2] = "STRIKEOUT";
+  AnnotationType2[AnnotationType2["UNDERLINE"] = 3] = "UNDERLINE";
+  AnnotationType2[AnnotationType2["FREETEXT"] = 4] = "FREETEXT";
+  AnnotationType2[AnnotationType2["RECTANGLE"] = 5] = "RECTANGLE";
+  AnnotationType2[AnnotationType2["CIRCLE"] = 6] = "CIRCLE";
+  AnnotationType2[AnnotationType2["FREEHAND"] = 7] = "FREEHAND";
+  AnnotationType2[AnnotationType2["FREE_HIGHLIGHT"] = 8] = "FREE_HIGHLIGHT";
+  AnnotationType2[AnnotationType2["SIGNATURE"] = 9] = "SIGNATURE";
+  AnnotationType2[AnnotationType2["STAMP"] = 10] = "STAMP";
+  AnnotationType2[AnnotationType2["NOTE"] = 11] = "NOTE";
+  AnnotationType2[AnnotationType2["ARROW"] = 12] = "ARROW";
+  AnnotationType2[AnnotationType2["CLOUD"] = 13] = "CLOUD";
+  return AnnotationType2;
+})(AnnotationType || {});
+export var CommentStatus = /* @__PURE__ */ ((CommentStatus2) => {
+  CommentStatus2["Accepted"] = "Accepted";
+  CommentStatus2["Rejected"] = "Rejected";
+  CommentStatus2["Cancelled"] = "Cancelled";
+  CommentStatus2["Completed"] = "Completed";
+  CommentStatus2["None"] = "None";
+  CommentStatus2["Closed"] = "Closed";
+  return CommentStatus2;
+})(CommentStatus || {});

package/dist/runtime/annotation/engine/utils.d.ts

@@ -0,0 +1,40 @@
+import { PDFHexString } from 'pdf-lib';
+export declare function getRGB(color: string): number[];
+export declare function rgbToPdfColor(input: string | undefined): [number, number, number];
+export declare function isElementInDOM(element: HTMLElement): boolean;
+export declare function generateUUID(): string;
+export declare function setCssCustomProperty(propertyName: string, value: string): void;
+export declare function removeCssCustomProperty(propertyName: string): void;
+export declare function base64ToImageBitmap(base64: string): Promise<ImageBitmap>;
+export declare function resizeImage(width: number, height: number, max: number): {
+    newWidth: number;
+    newHeight: number;
+};
+export declare function convertToRGB(array: number[], index?: number): string;
+export declare function formatTimestamp(timestamp: number): string;
+export declare function formatPDFDate(dateString: string | null, full?: boolean): string;
+export declare function getPDFDateTimestamp(dateString: string): number;
+export declare function convertKonvaRectToPdfRect(konvaRect: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}, pageHeight: number): [number, number, number, number];
+export declare function stringToPDFHexString(input: string): PDFHexString;
+export declare function getTimestampString(date?: Date): string;
+export declare function normalizeColor(input: string): string;
+export declare function isSameColor(color1: string, color2: string): boolean;
+export declare function debounce(fn: (...args: unknown[]) => void, delay: number): (...args: unknown[]) => void;
+export declare function createDocumentIcon({ x, y, fill, stroke, strokeWidth, cornerSize, }: {
+    x: number;
+    y: number;
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    cornerSize?: number;
+}): (import("konva/lib/shapes/Rect").Rect | import("konva/lib/shapes/Line").Line<{
+    points: number[];
+    stroke: string;
+    strokeWidth: number;
+    lineCap: "round";
+}>)[];

package/dist/runtime/annotation/engine/utils.js

@@ -0,0 +1,257 @@
+import Konva from "konva";
+import { PDFHexString } from "pdf-lib";
+export function getRGB(color) {
+  if (color.startsWith("#")) {
+    const colorRGB = Number.parseInt(color.slice(1), 16);
+    return [
+      (colorRGB & 16711680) >> 16,
+      (colorRGB & 65280) >> 8,
+      colorRGB & 255
+    ];
+  }
+  if (color.startsWith("rgb(")) {
+    return color.slice(4, -1).split(",").map((x) => Number.parseInt(x.trim()));
+  }
+  if (color.startsWith("rgba(")) {
+    return color.slice(5, -1).split(",").map((x, index) => index < 3 ? Number.parseInt(x.trim()) : 1);
+  }
+  console.error(`Not a valid color format: "${color}"`);
+  return [0, 0, 0];
+}
+export function rgbToPdfColor(input) {
+  if (!input) return [1, 1, 0];
+  if (input.startsWith("rgb")) {
+    const match = input.match(/\d+/g);
+    if (!match || match.length < 3) return [1, 1, 0];
+    return match.slice(0, 3).map((x) => Number.parseInt(x) / 255);
+  }
+  if (input.startsWith("#")) {
+    const hex = input.replace("#", "");
+    if (hex.length !== 6) return [1, 1, 0];
+    const r = Number.parseInt(hex.slice(0, 2), 16) / 255;
+    const g = Number.parseInt(hex.slice(2, 4), 16) / 255;
+    const b = Number.parseInt(hex.slice(4, 6), 16) / 255;
+    return [r, g, b];
+  }
+  return [1, 1, 0];
+}
+export function isElementInDOM(element) {
+  return document.body.contains(element);
+}
+export function generateUUID() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+export function setCssCustomProperty(propertyName, value) {
+  document.documentElement.style.setProperty(propertyName, value);
+}
+export function removeCssCustomProperty(propertyName) {
+  document.documentElement.style.removeProperty(propertyName);
+}
+export async function base64ToImageBitmap(base64) {
+  const base64Data = base64.split(",")[1];
+  const binaryString = atob(base64Data);
+  const length = binaryString.length;
+  const bytes = new Uint8Array(length);
+  for (let i = 0; i < length; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
+  }
+  const blob = new Blob([bytes], { type: "image/png" });
+  return await createImageBitmap(blob);
+}
+export function resizeImage(width, height, max) {
+  if (width <= max && height <= max) {
+    return { newWidth: width, newHeight: height };
+  }
+  const scaleFactor = Math.min(max / width, max / height);
+  return {
+    newWidth: width * scaleFactor,
+    newHeight: height * scaleFactor
+  };
+}
+export function convertToRGB(array, index = 0) {
+  if (index < 0 || index * 3 + 2 >= array.length) {
+    throw new Error("Index out of bounds");
+  }
+  const r = array[index * 3];
+  const g = array[index * 3 + 1];
+  const b = array[index * 3 + 2];
+  return `rgb(${r}, ${g}, ${b})`;
+}
+export function formatTimestamp(timestamp) {
+  const date = new Date(timestamp);
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  const hours = String(date.getHours()).padStart(2, "0");
+  const minutes = String(date.getMinutes()).padStart(2, "0");
+  const seconds = String(date.getSeconds()).padStart(2, "0");
+  const timezoneOffset = -date.getTimezoneOffset();
+  const timezoneHours = String(
+    Math.floor(Math.abs(timezoneOffset) / 60)
+  ).padStart(2, "0");
+  const timezoneMinutes = String(Math.abs(timezoneOffset) % 60).padStart(
+    2,
+    "0"
+  );
+  const timezoneSign = timezoneOffset >= 0 ? "+" : "-";
+  return `D:${year}${month}${day}${hours}${minutes}${seconds}${timezoneSign}${timezoneHours}'${timezoneMinutes}'`;
+}
+export function formatPDFDate(dateString, full = false) {
+  if (!dateString || typeof dateString !== "string" || !dateString.startsWith("D:")) {
+    return "";
+  }
+  const datePart = dateString.slice(2, 16);
+  if (datePart.length !== 14) return "";
+  const year = datePart.slice(0, 4);
+  const month = datePart.slice(4, 6);
+  const day = datePart.slice(6, 8);
+  const hour = datePart.slice(8, 10);
+  const minute = datePart.slice(10, 12);
+  if (full) {
+    return `${year}-${month}-${day} ${hour}:${minute}`;
+  }
+  const currentDate = /* @__PURE__ */ new Date();
+  const currentYear = currentDate.getFullYear().toString();
+  const currentMonth = (currentDate.getMonth() + 1).toString().padStart(2, "0");
+  const currentDay = currentDate.getDate().toString().padStart(2, "0");
+  if (year === currentYear && month === currentMonth && day === currentDay) {
+    return `${hour}:${minute}`;
+  }
+  if (year === currentYear) {
+    return `${month}-${day}`;
+  }
+  return `${year}-${month}-${day}`;
+}
+export function getPDFDateTimestamp(dateString) {
+  const datePart = dateString.slice(2, 16);
+  const year = Number.parseInt(datePart.slice(0, 4), 10);
+  const month = Number.parseInt(datePart.slice(4, 6), 10) - 1;
+  const day = Number.parseInt(datePart.slice(6, 8), 10);
+  const hour = Number.parseInt(datePart.slice(8, 10), 10);
+  const minute = Number.parseInt(datePart.slice(10, 12), 10);
+  const second = Number.parseInt(datePart.slice(12, 14), 10) || 0;
+  const tzMatch = dateString.slice(16).match(/([+-])(\d{2})'?(\d{2})?'/);
+  let tzOffset = 0;
+  if (tzMatch) {
+    const sign = tzMatch[1] === "+" ? 1 : -1;
+    const hours = Number.parseInt(tzMatch[2], 10) || 0;
+    const minutes = Number.parseInt(tzMatch[3] || "0", 10) || 0;
+    tzOffset = sign * (hours * 60 + minutes);
+  }
+  const date = new Date(Date.UTC(year, month, day, hour, minute, second));
+  return date.getTime() - tzOffset * 60 * 1e3;
+}
+export function convertKonvaRectToPdfRect(konvaRect, pageHeight) {
+  const { x, y, width, height } = konvaRect;
+  const pdfX1 = x;
+  const pdfY1 = pageHeight - y - height;
+  const pdfX2 = pdfX1 + width;
+  const pdfY2 = pdfY1 + height;
+  return [pdfX1, pdfY1, pdfX2, pdfY2];
+}
+export function stringToPDFHexString(input) {
+  const bom = [254, 255];
+  const utf16be = [...bom];
+  for (let i = 0; i < input.length; i++) {
+    const code = input.charCodeAt(i);
+    utf16be.push(code >> 8 & 255, code & 255);
+  }
+  const hexString = utf16be.map((b) => b.toString(16).padStart(2, "0")).join("").toUpperCase();
+  return PDFHexString.of(hexString);
+}
+export function getTimestampString(date = /* @__PURE__ */ new Date()) {
+  const pad = (n) => n.toString().padStart(2, "0");
+  const year = date.getFullYear();
+  const month = pad(date.getMonth() + 1);
+  const day = pad(date.getDate());
+  const hour = pad(date.getHours());
+  const minute = pad(date.getMinutes());
+  const second = pad(date.getSeconds());
+  return `${year}${month}${day}_${hour}${minute}${second}`;
+}
+export function normalizeColor(input) {
+  const hexRegex = /^#(?:[0-9a-f]{3}|[0-9a-f]{6})$/i;
+  const rgbRegex = /^rgb\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*\)$/;
+  input = input.trim().toLowerCase();
+  if (hexRegex.test(input)) {
+    if (input.length === 4) {
+      return "#" + input.slice(1).split("").map((c) => c + c).join("");
+    }
+    return input;
+  }
+  const match = input.match(rgbRegex);
+  if (match) {
+    const r = Number(match[1]);
+    const g = Number(match[2]);
+    const b = Number(match[3]);
+    const clamp = (n) => Math.max(0, Math.min(255, n));
+    return "#" + [r, g, b].map((n) => clamp(n).toString(16).padStart(2, "0")).join("");
+  }
+  throw new Error(`Unsupported color format: ${input}`);
+}
+export function isSameColor(color1, color2) {
+  try {
+    return normalizeColor(color1) === normalizeColor(color2);
+  } catch {
+    return false;
+  }
+}
+export function debounce(fn, delay) {
+  let timeout;
+  return (...args) => {
+    if (timeout) clearTimeout(timeout);
+    timeout = setTimeout(() => fn(...args), delay);
+  };
+}
+export function createDocumentIcon({
+  x,
+  y,
+  fill = "rgb(255, 222, 33)",
+  stroke = "#000",
+  strokeWidth = 1,
+  cornerSize = 3
+}) {
+  const width = 16;
+  const height = 16;
+  const paddingTop = 4;
+  const paddingBottom = 4;
+  const textLineCount = 4;
+  const spacing = (height - paddingTop - paddingBottom) / (textLineCount + 1);
+  const rect = new Konva.Rect({
+    x,
+    y,
+    width,
+    height,
+    fillLinearGradientStartPoint: { x: 0, y: 0 },
+    fillLinearGradientEndPoint: { x: 0, y: height },
+    fillLinearGradientColorStops: [0, fill, 1, "#fff"],
+    stroke,
+    cornerRadius: [0, cornerSize, 0, 0],
+    strokeWidth,
+    shadowColor: "rgba(0,0,0,0.2)",
+    shadowBlur: 2,
+    shadowOffset: { x: 1, y: 1 },
+    shadowOpacity: 0.3
+  });
+  const lines = [];
+  for (let i = 1; i <= textLineCount; i++) {
+    const yPos = y + paddingTop + i * spacing;
+    const xEnd = i === 1 ? x + width - 6 : x + width - 3;
+    const line = new Konva.Line({
+      points: [x + 3, yPos, xEnd, yPos],
+      stroke: "#555",
+      strokeWidth: 0.6,
+      lineCap: "round"
+    });
+    lines.push(line);
+  }
+  return [rect, ...lines];
+}

package/dist/runtime/annotation/parsers/parseFormFields.d.ts

@@ -0,0 +1,9 @@
+import { type FormFieldDefinition } from '../engine/types.js';
+/**
+ * Parse raw pdf.js annotation objects and extract Widget (form field) annotations
+ * into structured FormFieldDefinition objects.
+ *
+ * pdf.js `page.getAnnotations()` returns annotation objects with an `annotationType`
+ * property. Widget annotations (annotationType === 20) represent interactive form fields.
+ */
+export declare function parseFormFields(annotations: any[], pageNumber: number): FormFieldDefinition[];

package/dist/runtime/annotation/parsers/parseFormFields.js

@@ -0,0 +1,101 @@
+import { PdfjsAnnotationType } from "../engine/types.js";
+export function parseFormFields(annotations, pageNumber) {
+  const fields = [];
+  for (const ann of annotations) {
+    if (ann.annotationType !== PdfjsAnnotationType.WIDGET) continue;
+    const fieldType = resolveFieldType(ann);
+    if (!fieldType) continue;
+    const rect = ann.rect;
+    if (!rect || rect.length < 4) continue;
+    const normalizedRect = [
+      Math.min(rect[0], rect[2]),
+      Math.min(rect[1], rect[3]),
+      Math.max(rect[0], rect[2]),
+      Math.max(rect[1], rect[3])
+    ];
+    const def = {
+      id: String(ann.id),
+      pageNumber,
+      fieldType,
+      fieldName: ann.fieldName ?? "",
+      rect: normalizedRect,
+      readOnly: Boolean(ann.readOnly),
+      required: Boolean(ann.required)
+    };
+    if (fieldType === "text") {
+      if (ann.fieldValue != null) def.defaultValue = String(ann.fieldValue);
+      if (typeof ann.maxLen === "number" && ann.maxLen > 0) def.maxLen = ann.maxLen;
+      def.multiLine = Boolean(ann.multiLine);
+      def.password = Boolean(ann.password);
+      def.comb = Boolean(ann.comb);
+    }
+    if (fieldType === "checkbox") {
+      def.exportValue = ann.exportValue ?? "Yes";
+      if (ann.fieldValue != null) {
+        def.defaultValue = String(ann.fieldValue);
+      }
+    }
+    if (fieldType === "radio") {
+      def.buttonValue = ann.buttonValue ?? ann.exportValue ?? "";
+      if (ann.fieldValue != null) {
+        def.defaultValue = String(ann.fieldValue);
+      }
+    }
+    if (fieldType === "dropdown") {
+      def.combo = ann.combo !== false;
+      def.multiSelect = Boolean(ann.multiSelect);
+      def.editable = Boolean(ann.editable);
+      if (ann.fieldValue != null) def.defaultValue = String(ann.fieldValue);
+      if (Array.isArray(ann.options)) {
+        def.options = ann.options.map((opt) => {
+          if (Array.isArray(opt)) {
+            return {
+              exportValue: String(opt[0] ?? ""),
+              displayValue: String(opt[1] ?? opt[0] ?? "")
+            };
+          }
+          if (typeof opt === "object" && opt !== null) {
+            const o = opt;
+            return {
+              exportValue: String(o.exportValue ?? o.value ?? ""),
+              displayValue: String(o.displayValue ?? o.label ?? o.exportValue ?? o.value ?? "")
+            };
+          }
+          return { exportValue: String(opt), displayValue: String(opt) };
+        });
+      }
+    }
+    if (fieldType === "button") {
+      def.buttonLabel = ann.alternativeText ?? ann.fieldValue ?? ann.fieldName ?? "Button";
+    }
+    if (typeof ann.fontSize === "number") def.fontSize = ann.fontSize;
+    if (Array.isArray(ann.color)) {
+      def.color = ann.color.map(
+        (c) => (
+          // pdf.js colors may be 0-1 floats or 0-255 integers
+          c <= 1 ? Math.round(c * 255) : Math.round(c)
+        )
+      );
+    }
+    if (Array.isArray(ann.backgroundColor)) {
+      def.backgroundColor = ann.backgroundColor.map(
+        (c) => c <= 1 ? Math.round(c * 255) : Math.round(c)
+      );
+    }
+    if (typeof ann.textAlignment === "number") def.textAlignment = ann.textAlignment;
+    fields.push(def);
+  }
+  return fields;
+}
+function resolveFieldType(ann) {
+  const ft = ann.fieldType;
+  if (ft === "Tx") return "text";
+  if (ft === "Btn") {
+    if (ann.checkBox) return "checkbox";
+    if (ann.radioButton) return "radio";
+    return "button";
+  }
+  if (ft === "Ch") return "dropdown";
+  if (ft === "Sig") return "signature";
+  return null;
+}

package/dist/runtime/annotation/pdf-export/download.d.ts

@@ -0,0 +1 @@
+export declare function downloadPdfBytes(data: Uint8Array, fileName: string): void;

package/dist/runtime/annotation/pdf-export/download.js

@@ -0,0 +1,10 @@
+export function downloadPdfBytes(data, fileName) {
+  const arrayBuffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+  const blob = new Blob([arrayBuffer], { type: "application/pdf" });
+  const link = document.createElement("a");
+  const url = URL.createObjectURL(blob);
+  link.href = url;
+  link.download = fileName;
+  link.click();
+  URL.revokeObjectURL(url);
+}

package/dist/runtime/annotation/pdf-export/export-form-fields.d.ts

@@ -0,0 +1,9 @@
+import type { PDFDocument } from 'pdf-lib';
+import type { FormFieldValue } from '../engine/types.js';
+/**
+ * Write form field values back to the PDF using pdf-lib's AcroForm API.
+ *
+ * This updates existing form fields in the PDF with the values the user
+ * entered in the viewer. It does NOT create new fields.
+ */
+export declare function writeFormFieldsToPdf(pdfDoc: PDFDocument, fieldValues: FormFieldValue[]): Promise<void>;