kviewer 0.0.4 → 0.0.5

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

@@ -1,7 +1,11 @@
-import { PDFName, PDFNumber, PDFString } from "pdf-lib";
+import { PDFName, PDFNumber, PDFRawStream, PDFString } from "pdf-lib";
 import { convertKonvaRectToPdfRect, rgbToPdfColor, stringToPDFHexString } from "../engine/utils.js";
 import { AnnotationParser } from "./parse.js";
 const UNKNOWN_USER = "Unknown user";
+function formatPdfNumber(value) {
+  if (!Number.isFinite(value)) return "0";
+  return Number(value.toFixed(3)).toString();
+}
 export class LineParser extends AnnotationParser {
   async parse() {
     const { annotation, page, pdfDoc } = this;
@@ -13,17 +17,24 @@ export class LineParser extends AnnotationParser {
     const groupY = konvaGroup.attrs?.y || 0;
     const scaleX = konvaGroup.attrs?.scaleX || 1;
     const scaleY = konvaGroup.attrs?.scaleY || 1;
+    const transformedPaths = [];
+    for (const line of lines) {
+      const points = line.attrs?.points ?? [];
+      if (points.length < 4) continue;
+      const transformedPoints = [];
+      for (let i = 0; i < points.length; i += 2) {
+        const x = groupX + (points[i] ?? 0) * scaleX;
+        const y = groupY + (points[i + 1] ?? 0) * scaleY;
+        transformedPoints.push(x, pageHeight - y);
+      }
+      transformedPaths.push(transformedPoints);
+    }
+    if (transformedPaths.length === 0) {
+      console.warn(`Line annotation ${annotation.id} has no drawable paths`);
+      return;
+    }
     const inkList = context.obj(
-      lines.map((line) => {
-        const points = line.attrs?.points ?? [];
-        const transformedPoints = [];
-        for (let i = 0; i < points.length; i += 2) {
-          const x = groupX + points[i] * scaleX;
-          const y = groupY + points[i + 1] * scaleY;
-          transformedPoints.push(x, pageHeight - y);
-        }
-        return context.obj(transformedPoints);
-      })
+      transformedPaths.map((path) => context.obj(path))
     );
     const firstLine = lines[0]?.attrs || {};
     const strokeWidth = firstLine.strokeWidth ?? 1;
@@ -34,10 +45,118 @@ export class LineParser extends AnnotationParser {
       W: PDFNumber.of(strokeWidth),
       S: PDFName.of("S")
     });
+    const pointerLength = firstLine.pointerLength ?? 10;
+    const pad = Math.max(strokeWidth, pointerLength, 1);
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    for (const path of transformedPaths) {
+      for (let i = 0; i < path.length; i += 2) {
+        const px = path[i];
+        const py = path[i + 1];
+        if (px < minX) minX = px;
+        if (py < minY) minY = py;
+        if (px > maxX) maxX = px;
+        if (py > maxY) maxY = py;
+      }
+    }
+    const x1 = minX - pad;
+    const y1 = minY - pad;
+    const x2 = maxX + pad;
+    const y2 = maxY + pad;
+    const rect = [x1, y1, x2, y2];
+    const appearanceWidth = Math.max(1, x2 - x1);
+    const appearanceHeight = Math.max(1, y2 - y1);
+    const useExtGState = opacity !== 1;
+    const commands = [
+      "q",
+      ...useExtGState ? ["/GS1 gs"] : [],
+      `${formatPdfNumber(r)} ${formatPdfNumber(g)} ${formatPdfNumber(b)} RG`,
+      `${formatPdfNumber(r)} ${formatPdfNumber(g)} ${formatPdfNumber(b)} rg`,
+      `${formatPdfNumber(Math.max(0.1, strokeWidth))} w`,
+      "1 J",
+      // round line cap
+      "1 j"
+      // round line join
+    ];
+    for (const path of transformedPaths) {
+      if (path.length < 4) continue;
+      commands.push(
+        `${formatPdfNumber((path[0] ?? 0) - x1)} ${formatPdfNumber((path[1] ?? 0) - y1)} m`
+      );
+      for (let i = 2; i < path.length; i += 2) {
+        commands.push(
+          `${formatPdfNumber((path[i] ?? 0) - x1)} ${formatPdfNumber((path[i + 1] ?? 0) - y1)} l`
+        );
+      }
+      commands.push("S");
+      const pointerLength2 = firstLine.pointerLength ?? 10;
+      const pointerWidth = firstLine.pointerWidth ?? 10;
+      const hasEndArrow = firstLine.pointerAtEnding !== false;
+      if (hasEndArrow && path.length >= 4) {
+        const endX = (path[path.length - 2] ?? 0) - x1;
+        const endY = (path[path.length - 1] ?? 0) - y1;
+        const prevX = (path[path.length - 4] ?? 0) - x1;
+        const prevY = (path[path.length - 3] ?? 0) - y1;
+        const angle = Math.atan2(endY - prevY, endX - prevX);
+        const halfWidth = pointerWidth / 2;
+        const leftX = endX - pointerLength2 * Math.cos(angle) + halfWidth * Math.sin(angle);
+        const leftY = endY - pointerLength2 * Math.sin(angle) - halfWidth * Math.cos(angle);
+        const rightX = endX - pointerLength2 * Math.cos(angle) - halfWidth * Math.sin(angle);
+        const rightY = endY - pointerLength2 * Math.sin(angle) + halfWidth * Math.cos(angle);
+        commands.push(
+          `${formatPdfNumber(endX)} ${formatPdfNumber(endY)} m`,
+          `${formatPdfNumber(leftX)} ${formatPdfNumber(leftY)} l`,
+          `${formatPdfNumber(rightX)} ${formatPdfNumber(rightY)} l`,
+          "f"
+          // fill the arrowhead
+        );
+      }
+      if (firstLine.pointerAtBeginning && path.length >= 4) {
+        const startX = (path[0] ?? 0) - x1;
+        const startY = (path[1] ?? 0) - y1;
+        const nextX = (path[2] ?? 0) - x1;
+        const nextY = (path[3] ?? 0) - y1;
+        const angle = Math.atan2(startY - nextY, startX - nextX);
+        const halfWidth = pointerWidth / 2;
+        const leftX = startX - pointerLength2 * Math.cos(angle) + halfWidth * Math.sin(angle);
+        const leftY = startX - pointerLength2 * Math.sin(angle) - halfWidth * Math.cos(angle);
+        const rightX = startX - pointerLength2 * Math.cos(angle) - halfWidth * Math.sin(angle);
+        const rightY = startX - pointerLength2 * Math.sin(angle) + halfWidth * Math.cos(angle);
+        commands.push(
+          `${formatPdfNumber(startX)} ${formatPdfNumber(startY)} m`,
+          `${formatPdfNumber(leftX)} ${formatPdfNumber(leftY)} l`,
+          `${formatPdfNumber(rightX)} ${formatPdfNumber(rightY)} l`,
+          "f"
+        );
+      }
+    }
+    commands.push("Q");
+    const resources = useExtGState ? context.obj({
+      ExtGState: context.obj({
+        GS1: context.obj({
+          Type: PDFName.of("ExtGState"),
+          CA: PDFNumber.of(opacity),
+          ca: PDFNumber.of(opacity)
+        })
+      })
+    }) : context.obj({});
+    const appearanceStream = PDFRawStream.of(
+      context.obj({
+        Type: PDFName.of("XObject"),
+        Subtype: PDFName.of("Form"),
+        BBox: context.obj([0, 0, appearanceWidth, appearanceHeight]),
+        Resources: resources
+      }),
+      new TextEncoder().encode(commands.join("\n"))
+    );
+    const appearanceRef = context.register(appearanceStream);
+    const ap = context.obj({ N: appearanceRef });
     const mainAnn = context.obj({
       Type: PDFName.of("Annot"),
       Subtype: PDFName.of("Ink"),
-      Rect: convertKonvaRectToPdfRect(annotation.konvaClientRect, pageHeight),
+      Rect: rect,
       InkList: inkList,
       C: context.obj([PDFNumber.of(r), PDFNumber.of(g), PDFNumber.of(b)]),
       T: stringToPDFHexString(annotation.title || UNKNOWN_USER),
@@ -46,7 +165,8 @@ export class LineParser extends AnnotationParser {
       NM: PDFString.of(annotation.id),
       Border: context.obj([0, 0, 0]),
       BS: bs,
-      CA: PDFNumber.of(opacity)
+      CA: PDFNumber.of(opacity),
+      AP: ap
     });
     const mainAnnRef = context.register(mainAnn);
     this.addAnnotationToPage(page, mainAnnRef);

package/dist/runtime/annotation/pdf-import/decode.d.ts

@@ -0,0 +1,21 @@
+import type { PDFDocumentProxy } from 'pdfjs-dist';
+import { type IAnnotationStore } from '../engine/types.js';
+import { type StampAppearance } from './types.js';
+export interface DecodePdfAnnotationsResult {
+    annotations: IAnnotationStore[];
+    skipped: number;
+    errors: number;
+    pageErrors: number;
+    stampExtracted: number;
+    stampSkipped: number;
+}
+interface DecodePageOptions {
+    stampAppearances?: Map<string, StampAppearance>;
+}
+export declare function filterCollidingAnnotations(annotations: IAnnotationStore[], existingIds: Set<string>): {
+    annotations: IAnnotationStore[];
+    skipped: number;
+};
+export declare function decodePdfPageAnnotations(pageAnnotations: unknown[], pageNumber: number, pageHeight: number, options?: DecodePageOptions): DecodePdfAnnotationsResult;
+export declare function decodePdfAnnotationsFromDocument(pdfDoc: PDFDocumentProxy): Promise<DecodePdfAnnotationsResult>;
+export {};

package/dist/runtime/annotation/pdf-import/decode.js

@@ -0,0 +1,134 @@
+import { PdfjsAnnotationType } from "../engine/types.js";
+import { decodeCircleAnnotation } from "./decode_circle.js";
+import { decodeFreeTextAnnotation } from "./decode_freetext.js";
+import { decodeHighlightAnnotation } from "./decode_highlight.js";
+import { decodeInkAnnotation } from "./decode_ink.js";
+import { decodeLineAnnotation } from "./decode_line.js";
+import { decodeStampAnnotation } from "./decode_stamp.js";
+import { decodeSquareAnnotation } from "./decode_square.js";
+import { decodeTextAnnotation } from "./decode_text.js";
+import { extractStampAppearancesForPage } from "./extract_stamp_appearance.js";
+import { isRawPdfAnnotation } from "./types.js";
+const decoderMap = {
+  [PdfjsAnnotationType.TEXT]: decodeTextAnnotation,
+  [PdfjsAnnotationType.FREETEXT]: decodeFreeTextAnnotation,
+  [PdfjsAnnotationType.HIGHLIGHT]: decodeHighlightAnnotation,
+  [PdfjsAnnotationType.UNDERLINE]: decodeHighlightAnnotation,
+  [PdfjsAnnotationType.STRIKEOUT]: decodeHighlightAnnotation,
+  [PdfjsAnnotationType.SQUARE]: decodeSquareAnnotation,
+  [PdfjsAnnotationType.CIRCLE]: decodeCircleAnnotation,
+  [PdfjsAnnotationType.INK]: decodeInkAnnotation,
+  [PdfjsAnnotationType.LINE]: decodeLineAnnotation,
+  [PdfjsAnnotationType.STAMP]: decodeStampAnnotation
+};
+export function filterCollidingAnnotations(annotations, existingIds) {
+  const result = [];
+  let skipped = 0;
+  for (const annotation of annotations) {
+    if (existingIds.has(annotation.id)) {
+      skipped++;
+      continue;
+    }
+    existingIds.add(annotation.id);
+    result.push(annotation);
+  }
+  return { annotations: result, skipped };
+}
+export function decodePdfPageAnnotations(pageAnnotations, pageNumber, pageHeight, options = {}) {
+  const annotations = [];
+  let skipped = 0;
+  let errors = 0;
+  const rawAnnotations = pageAnnotations.filter(isRawPdfAnnotation);
+  skipped += pageAnnotations.length - rawAnnotations.length;
+  const context = {
+    pageNumber,
+    pageHeight,
+    allAnnotations: rawAnnotations,
+    stampAppearances: options.stampAppearances
+  };
+  const stampEntries = rawAnnotations.filter(
+    (annotation) => annotation.annotationType === PdfjsAnnotationType.STAMP && typeof annotation.id === "string"
+  );
+  const stampExtracted = Math.min(stampEntries.length, options.stampAppearances?.size ?? 0);
+  const stampSkipped = Math.max(0, stampEntries.length - stampExtracted);
+  for (const annotation of rawAnnotations) {
+    const decoder = decoderMap[annotation.annotationType];
+    if (!decoder) {
+      skipped++;
+      continue;
+    }
+    try {
+      const decoded = decoder(annotation, context);
+      if (decoded) {
+        annotations.push(decoded);
+      } else {
+        skipped++;
+      }
+    } catch (error) {
+      errors++;
+      skipped++;
+      console.warn(`[KViewer] Failed to decode annotation ${annotation.id}`, error);
+    }
+  }
+  return {
+    annotations,
+    skipped,
+    errors,
+    pageErrors: 0,
+    stampExtracted,
+    stampSkipped
+  };
+}
+export async function decodePdfAnnotationsFromDocument(pdfDoc) {
+  const annotations = [];
+  let skipped = 0;
+  let errors = 0;
+  let pageErrors = 0;
+  let stampExtracted = 0;
+  let stampSkipped = 0;
+  for (let pageNumber = 1; pageNumber <= pdfDoc.numPages; pageNumber++) {
+    try {
+      const page = await pdfDoc.getPage(pageNumber);
+      const viewport = page.getViewport({ scale: 1 });
+      const pageAnnotations = await page.getAnnotations();
+      const rawAnnotations = pageAnnotations.filter(isRawPdfAnnotation);
+      const hasStampAnnotations = rawAnnotations.some(
+        (annotation) => annotation.annotationType === PdfjsAnnotationType.STAMP && typeof annotation.id === "string"
+      );
+      let stampAppearances;
+      if (hasStampAnnotations) {
+        try {
+          stampAppearances = await extractStampAppearancesForPage(
+            page,
+            viewport.height,
+            rawAnnotations
+          );
+        } catch (error) {
+          console.warn(`[KViewer] Failed to extract stamp appearances on page ${pageNumber}`, error);
+        }
+      }
+      const decoded = decodePdfPageAnnotations(
+        pageAnnotations,
+        pageNumber,
+        viewport.height,
+        { stampAppearances }
+      );
+      annotations.push(...decoded.annotations);
+      skipped += decoded.skipped;
+      errors += decoded.errors;
+      stampExtracted += decoded.stampExtracted;
+      stampSkipped += decoded.stampSkipped;
+    } catch (error) {
+      pageErrors++;
+      console.warn(`[KViewer] Failed to decode page ${pageNumber} annotations`, error);
+    }
+  }
+  return {
+    annotations,
+    skipped,
+    errors,
+    pageErrors,
+    stampExtracted,
+    stampSkipped
+  };
+}

package/dist/runtime/annotation/pdf-import/decode_circle.d.ts

@@ -0,0 +1,3 @@
+import type { IAnnotationStore } from '../engine/types.js';
+import type { DecodeContext, RawPdfAnnotation } from './types.js';
+export declare function decodeCircleAnnotation(annotation: RawPdfAnnotation, context: DecodeContext): IAnnotationStore | null;

package/dist/runtime/annotation/pdf-import/decode_circle.js

@@ -0,0 +1,36 @@
+import Konva from "konva";
+import { AnnotationType } from "../engine/types.js";
+import {
+  createAnnotationStore,
+  createGhostGroup,
+  getAnnotationColor,
+  normalizedStrokeWidth,
+  rectFromPdfRect
+} from "./utils.js";
+export function decodeCircleAnnotation(annotation, context) {
+  const rect = rectFromPdfRect(annotation.rect, context.pageHeight);
+  if (!rect || typeof annotation.id !== "string") return null;
+  const color = getAnnotationColor(annotation, AnnotationType.CIRCLE);
+  const strokeWidth = normalizedStrokeWidth(annotation, 1);
+  const group = createGhostGroup(annotation.id);
+  group.add(new Konva.Ellipse({
+    x: rect.x + rect.width / 2,
+    y: rect.y + rect.height / 2,
+    radiusX: rect.width / 2,
+    radiusY: rect.height / 2,
+    strokeScaleEnabled: false,
+    strokeWidth,
+    stroke: color
+  }));
+  const store = createAnnotationStore({
+    annotation,
+    allAnnotations: context.allAnnotations,
+    pageNumber: context.pageNumber,
+    type: AnnotationType.CIRCLE,
+    group,
+    color,
+    overrideSubtype: "Circle"
+  });
+  group.destroy();
+  return store;
+}

package/dist/runtime/annotation/pdf-import/decode_freetext.d.ts

@@ -0,0 +1,3 @@
+import type { IAnnotationStore } from '../engine/types.js';
+import type { DecodeContext, RawPdfAnnotation } from './types.js';
+export declare function decodeFreeTextAnnotation(annotation: RawPdfAnnotation, context: DecodeContext): IAnnotationStore | null;

package/dist/runtime/annotation/pdf-import/decode_freetext.js

@@ -0,0 +1,87 @@
+import Konva from "konva";
+import { AnnotationType } from "../engine/types.js";
+import { asAppearanceData, isNumber } from "./types.js";
+import {
+  colorArrayToRgb,
+  createAnnotationStore,
+  createGhostGroup,
+  getFreeTextContent,
+  getAnnotationColor,
+  localPointFromPdfPoint,
+  rectFromPdfRect
+} from "./utils.js";
+function estimatedTextWidth(text, fontSize) {
+  const lines = text.split("\n");
+  const longestLine = lines.reduce((max, line) => Math.max(max, line.length), 0);
+  if (longestLine === 0) return 0;
+  return longestLine * fontSize * 0.56;
+}
+function measuredTextWidth(text, fontSize, fontFamily) {
+  const measureNode = new Konva.Text({
+    text,
+    fontSize,
+    fontFamily
+  });
+  const widthFn = measureNode.width;
+  const measured = typeof widthFn === "function" ? widthFn.call(measureNode) : null;
+  const destroyFn = measureNode.destroy;
+  if (typeof destroyFn === "function") {
+    destroyFn.call(measureNode);
+  }
+  return isNumber(measured) ? measured : estimatedTextWidth(text, fontSize);
+}
+function inferTextAlign(rectWidth, textPositionX, measuredWidth) {
+  if (!isNumber(textPositionX) || rectWidth <= 0) return "left";
+  const leftGap = textPositionX;
+  const rightGap = rectWidth - (leftGap + measuredWidth);
+  const tolerance = Math.max(1, rectWidth * 0.08);
+  if (leftGap > tolerance && rightGap > tolerance && Math.abs(leftGap - rightGap) <= tolerance * 2) {
+    return "center";
+  }
+  if (rightGap <= tolerance && leftGap > tolerance) {
+    return "right";
+  }
+  return "left";
+}
+export function decodeFreeTextAnnotation(annotation, context) {
+  const rect = rectFromPdfRect(annotation.rect, context.pageHeight);
+  if (!rect || typeof annotation.id !== "string") return null;
+  const appearance = asAppearanceData(annotation.defaultAppearanceData);
+  const color = colorArrayToRgb(appearance?.fontColor) ?? getAnnotationColor(annotation, AnnotationType.FREETEXT);
+  const rawFontSize = appearance?.fontSize;
+  const fontSize = isNumber(rawFontSize) ? Math.max(1, rawFontSize) : 18;
+  const fontFamily = typeof appearance?.fontName === "string" && appearance.fontName.length > 0 ? appearance.fontName : void 0;
+  const text = getFreeTextContent(annotation);
+  const textPosition = localPointFromPdfPoint(annotation.textPosition);
+  const textWidth = measuredTextWidth(text, fontSize, fontFamily);
+  const textAlign = inferTextAlign(rect.width, textPosition?.x ?? null, textWidth);
+  const x = textPosition && textAlign === "left" ? rect.x + Math.max(0, textPosition.x) : rect.x;
+  const y = textPosition ? rect.y + rect.height - textPosition.y - fontSize : rect.y + 2;
+  const width = rect.width > 0 ? textPosition && textAlign === "left" ? Math.max(1, rect.width - Math.max(0, textPosition.x)) : rect.width : void 0;
+  const group = createGhostGroup(annotation.id);
+  const textNode = new Konva.Text({
+    x,
+    y,
+    text,
+    align: textAlign,
+    fontSize,
+    fontFamily,
+    fill: color,
+    width,
+    wrap: width ? "word" : "none"
+  });
+  group.add(textNode);
+  const store = createAnnotationStore({
+    annotation,
+    allAnnotations: context.allAnnotations,
+    pageNumber: context.pageNumber,
+    type: AnnotationType.FREETEXT,
+    group,
+    color,
+    fontSize,
+    contentsText: text,
+    overrideSubtype: "FreeText"
+  });
+  group.destroy();
+  return store;
+}

package/dist/runtime/annotation/pdf-import/decode_highlight.d.ts

@@ -0,0 +1,3 @@
+import type { IAnnotationStore } from '../engine/types.js';
+import type { DecodeContext, RawPdfAnnotation } from './types.js';
+export declare function decodeHighlightAnnotation(annotation: RawPdfAnnotation, context: DecodeContext): IAnnotationStore | null;

package/dist/runtime/annotation/pdf-import/decode_highlight.js

@@ -0,0 +1,96 @@
+import Konva from "konva";
+import { AnnotationType, PdfjsAnnotationType } from "../engine/types.js";
+import {
+  createAnnotationStore,
+  createGhostGroup,
+  getAnnotationColor,
+  rectFromQuadPoints
+} from "./utils.js";
+function collectQuadSets(input) {
+  if (ArrayBuffer.isView(input)) {
+    const values = Array.from(input);
+    const chunks = [];
+    for (let index = 0; index + 7 < values.length; index += 8) {
+      chunks.push(values.slice(index, index + 8));
+    }
+    return chunks;
+  }
+  if (!Array.isArray(input)) return [];
+  if (input.length === 0) return [];
+  if (typeof input[0] === "number") {
+    const chunks = [];
+    for (let index = 0; index + 7 < input.length; index += 8) {
+      chunks.push(input.slice(index, index + 8));
+    }
+    return chunks;
+  }
+  return input;
+}
+function toAnnotationType(pdfjsType) {
+  if (pdfjsType === PdfjsAnnotationType.HIGHLIGHT) return AnnotationType.HIGHLIGHT;
+  if (pdfjsType === PdfjsAnnotationType.UNDERLINE) return AnnotationType.UNDERLINE;
+  if (pdfjsType === PdfjsAnnotationType.STRIKEOUT) return AnnotationType.STRIKEOUT;
+  return null;
+}
+function createSegment(type, color, rect) {
+  if (type === AnnotationType.HIGHLIGHT) {
+    return new Konva.Rect({
+      x: rect.x,
+      y: rect.y,
+      width: rect.width,
+      height: rect.height,
+      opacity: 0.5,
+      fill: color
+    });
+  }
+  if (type === AnnotationType.UNDERLINE) {
+    return new Konva.Rect({
+      x: rect.x,
+      y: rect.y + rect.height - 1.5,
+      width: rect.width,
+      height: 0.5,
+      stroke: color,
+      strokeWidth: 0.5,
+      hitStrokeWidth: 10
+    });
+  }
+  return new Konva.Rect({
+    x: rect.x,
+    y: rect.y + rect.height / 2,
+    width: rect.width,
+    height: 0.5,
+    stroke: color,
+    strokeWidth: 0.5,
+    hitStrokeWidth: 10
+  });
+}
+export function decodeHighlightAnnotation(annotation, context) {
+  if (typeof annotation.id !== "string" || typeof annotation.annotationType !== "number") {
+    return null;
+  }
+  const type = toAnnotationType(annotation.annotationType);
+  if (type === null) return null;
+  const quadSets = collectQuadSets(annotation.quadPoints);
+  if (quadSets.length === 0) return null;
+  const color = getAnnotationColor(annotation, type);
+  const group = createGhostGroup(annotation.id);
+  for (const quadSet of quadSets) {
+    const rect = rectFromQuadPoints(quadSet, context.pageHeight);
+    if (!rect) continue;
+    group.add(createSegment(type, color, rect));
+  }
+  if (group.children.length === 0) {
+    group.destroy();
+    return null;
+  }
+  const store = createAnnotationStore({
+    annotation,
+    allAnnotations: context.allAnnotations,
+    pageNumber: context.pageNumber,
+    type,
+    group,
+    color
+  });
+  group.destroy();
+  return store;
+}

package/dist/runtime/annotation/pdf-import/decode_ink.d.ts

@@ -0,0 +1,3 @@
+import type { IAnnotationStore } from '../engine/types.js';
+import type { DecodeContext, RawPdfAnnotation } from './types.js';
+export declare function decodeInkAnnotation(annotation: RawPdfAnnotation, context: DecodeContext): IAnnotationStore | null;

package/dist/runtime/annotation/pdf-import/decode_ink.js

@@ -0,0 +1,48 @@
+import Konva from "konva";
+import { AnnotationType } from "../engine/types.js";
+import { isNumber } from "./types.js";
+import {
+  createAnnotationStore,
+  createGhostGroup,
+  getAnnotationColor,
+  normalizedStrokeWidth,
+  pointsFromInkList
+} from "./utils.js";
+export function decodeInkAnnotation(annotation, context) {
+  if (typeof annotation.id !== "string") return null;
+  if (!Array.isArray(annotation.inkLists) || annotation.inkLists.length === 0) return null;
+  const color = getAnnotationColor(annotation, AnnotationType.FREEHAND);
+  const strokeWidth = normalizedStrokeWidth(annotation, 1, { preferRawWidth: true });
+  const opacity = isNumber(annotation.opacity) ? annotation.opacity : 1;
+  const group = createGhostGroup(annotation.id);
+  for (const list of annotation.inkLists) {
+    const points = pointsFromInkList(list, context.pageHeight);
+    if (points.length < 4) continue;
+    group.add(new Konva.Line({
+      points,
+      strokeScaleEnabled: false,
+      stroke: color,
+      strokeWidth,
+      opacity,
+      lineCap: "round",
+      lineJoin: "round",
+      hitStrokeWidth: 20,
+      globalCompositeOperation: "source-over"
+    }));
+  }
+  if (group.children.length === 0) {
+    group.destroy();
+    return null;
+  }
+  const store = createAnnotationStore({
+    annotation,
+    allAnnotations: context.allAnnotations,
+    pageNumber: context.pageNumber,
+    type: AnnotationType.FREEHAND,
+    group,
+    color,
+    overrideSubtype: "Ink"
+  });
+  group.destroy();
+  return store;
+}

package/dist/runtime/annotation/pdf-import/decode_line.d.ts

@@ -0,0 +1,3 @@
+import type { IAnnotationStore } from '../engine/types.js';
+import type { DecodeContext, RawPdfAnnotation } from './types.js';
+export declare function decodeLineAnnotation(annotation: RawPdfAnnotation, context: DecodeContext): IAnnotationStore | null;

package/dist/runtime/annotation/pdf-import/decode_line.js

@@ -0,0 +1,48 @@
+import Konva from "konva";
+import { AnnotationType } from "../engine/types.js";
+import {
+  createAnnotationStore,
+  createGhostGroup,
+  dashedBorder,
+  getAnnotationColor,
+  hasArrowEnding,
+  linePointsFromCoordinates,
+  normalizedStrokeWidth
+} from "./utils.js";
+export function decodeLineAnnotation(annotation, context) {
+  if (typeof annotation.id !== "string") return null;
+  const points = linePointsFromCoordinates(annotation.lineCoordinates, context.pageHeight);
+  if (!points) return null;
+  const color = getAnnotationColor(annotation, AnnotationType.ARROW);
+  const strokeWidth = normalizedStrokeWidth(annotation, 1);
+  const lineEndings = Array.isArray(annotation.lineEndings) ? annotation.lineEndings : [];
+  const pointerAtBeginning = hasArrowEnding(lineEndings[0]);
+  const pointerAtEnding = hasArrowEnding(lineEndings[1]);
+  const group = createGhostGroup(annotation.id);
+  group.add(new Konva.Arrow({
+    points,
+    strokeScaleEnabled: false,
+    stroke: color,
+    fill: color,
+    strokeWidth,
+    hitStrokeWidth: 20,
+    lineCap: "round",
+    lineJoin: "round",
+    pointerLength: 10,
+    pointerWidth: 10,
+    pointerAtBeginning,
+    pointerAtEnding,
+    dash: dashedBorder(annotation)
+  }));
+  const store = createAnnotationStore({
+    annotation,
+    allAnnotations: context.allAnnotations,
+    pageNumber: context.pageNumber,
+    type: AnnotationType.ARROW,
+    group,
+    color,
+    overrideSubtype: "Arrow"
+  });
+  group.destroy();
+  return store;
+}

package/dist/runtime/annotation/pdf-import/decode_square.d.ts

@@ -0,0 +1,3 @@
+import type { IAnnotationStore } from '../engine/types.js';
+import type { DecodeContext, RawPdfAnnotation } from './types.js';
+export declare function decodeSquareAnnotation(annotation: RawPdfAnnotation, context: DecodeContext): IAnnotationStore | null;