kviewer 0.0.3 → 0.0.5

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

@@ -0,0 +1,39 @@
+import Konva from "konva";
+import { AnnotationType } from "../engine/types.js";
+import {
+  createAnnotationStore,
+  createGhostGroup,
+  getAnnotationColor,
+  normalizedStrokeWidth,
+  rectFromPdfRect
+} from "./utils.js";
+export function decodeSquareAnnotation(annotation, context) {
+  const rect = rectFromPdfRect(annotation.rect, context.pageHeight);
+  if (!rect || typeof annotation.id !== "string") return null;
+  const color = getAnnotationColor(annotation, AnnotationType.RECTANGLE);
+  const strokeWidth = normalizedStrokeWidth(annotation, 1);
+  const isFilled = strokeWidth <= 0.1;
+  const group = createGhostGroup(annotation.id);
+  group.add(new Konva.Rect({
+    x: rect.x,
+    y: rect.y,
+    width: rect.width,
+    height: rect.height,
+    strokeScaleEnabled: false,
+    stroke: color,
+    strokeWidth,
+    fill: isFilled ? color : void 0,
+    opacity: isFilled ? 0.5 : 1
+  }));
+  const store = createAnnotationStore({
+    annotation,
+    allAnnotations: context.allAnnotations,
+    pageNumber: context.pageNumber,
+    type: AnnotationType.RECTANGLE,
+    group,
+    color,
+    overrideSubtype: "Square"
+  });
+  group.destroy();
+  return store;
+}

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

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

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

@@ -0,0 +1,38 @@
+import Konva from "konva";
+import { AnnotationType } from "../engine/types.js";
+import {
+  createAnnotationStore,
+  createGhostGroup,
+  getAnnotationText,
+  rectFromPdfRect
+} from "./utils.js";
+export function decodeStampAnnotation(annotation, context) {
+  if (typeof annotation.id !== "string") return null;
+  const rect = rectFromPdfRect(annotation.rect, context.pageHeight);
+  if (!rect) return null;
+  const appearance = context.stampAppearances?.get(annotation.id);
+  if (!appearance) {
+    console.debug(`[KViewer] Missing stamp appearance for annotation ${annotation.id}`);
+    return null;
+  }
+  const group = createGhostGroup(annotation.id);
+  group.add(new Konva.Image({
+    x: rect.x,
+    y: rect.y,
+    width: rect.width > 0 ? rect.width : appearance.width,
+    height: rect.height > 0 ? rect.height : appearance.height,
+    base64: appearance.dataUrl
+  }));
+  const store = createAnnotationStore({
+    annotation,
+    allAnnotations: context.allAnnotations,
+    pageNumber: context.pageNumber,
+    type: AnnotationType.STAMP,
+    group,
+    contentsText: getAnnotationText(annotation),
+    contentsImage: appearance.dataUrl,
+    overrideSubtype: "Stamp"
+  });
+  group.destroy();
+  return store;
+}

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

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

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

@@ -0,0 +1,33 @@
+import { AnnotationType } from "../engine/types.js";
+import { createDocumentIcon } from "../engine/utils.js";
+import {
+  createAnnotationStore,
+  createGhostGroup,
+  getAnnotationColor,
+  getAnnotationText,
+  rectFromPdfRect
+} from "./utils.js";
+export function decodeTextAnnotation(annotation, context) {
+  if (annotation.inReplyTo) return null;
+  const rect = rectFromPdfRect(annotation.rect, context.pageHeight);
+  if (!rect || typeof annotation.id !== "string") return null;
+  const color = getAnnotationColor(annotation, AnnotationType.NOTE);
+  const group = createGhostGroup(annotation.id);
+  group.add(...createDocumentIcon({
+    x: rect.x,
+    y: rect.y,
+    fill: color
+  }));
+  const store = createAnnotationStore({
+    annotation,
+    allAnnotations: context.allAnnotations,
+    pageNumber: context.pageNumber,
+    type: AnnotationType.NOTE,
+    group,
+    color,
+    contentsText: getAnnotationText(annotation),
+    overrideSubtype: "Text"
+  });
+  group.destroy();
+  return store;
+}

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

@@ -0,0 +1,23 @@
+import type { PDFPageProxy } from 'pdfjs-dist';
+import { type RawPdfAnnotation, type StampAppearance } from './types.js';
+export interface StampExtractionOptions {
+    scale?: number;
+    diffThreshold?: number;
+}
+export interface PixelBounds {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export declare function stampRectToPixelBounds(rect: unknown, pageHeight: number, scale: number, canvasWidth: number, canvasHeight: number): PixelBounds | null;
+export declare function findMaskBounds(mask: Uint8Array, width: number, height: number): PixelBounds | null;
+export declare function computeDiffMask(base: Uint8ClampedArray, annotated: Uint8ClampedArray, width: number, height: number, threshold?: number): {
+    mask: Uint8Array;
+    bounds: PixelBounds | null;
+};
+export declare function applyMaskOrFallback(annotated: Uint8ClampedArray, mask: Uint8Array): {
+    data: Uint8ClampedArray;
+    usedMask: boolean;
+};
+export declare function extractStampAppearancesForPage(page: PDFPageProxy, pageHeight: number, annotations: RawPdfAnnotation[], options?: StampExtractionOptions): Promise<Map<string, StampAppearance>>;

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

@@ -0,0 +1,168 @@
+import { PdfjsAnnotationType } from "../engine/types.js";
+import { isNumber } from "./types.js";
+const PDFJS_ANNOTATION_MODE_DISABLE = 0;
+const PDFJS_ANNOTATION_MODE_ENABLE = 1;
+const DEFAULT_RENDER_SCALE = 2;
+const DEFAULT_DIFF_THRESHOLD = 24;
+function normalizedPageRect(rect, pageHeight) {
+  if (!Array.isArray(rect) || rect.length < 4) return null;
+  const [rx1, ry1, rx2, ry2] = rect;
+  if (!isNumber(rx1) || !isNumber(ry1) || !isNumber(rx2) || !isNumber(ry2)) return null;
+  const x1 = Math.min(rx1, rx2);
+  const x2 = Math.max(rx1, rx2);
+  const y1 = Math.min(ry1, ry2);
+  const y2 = Math.max(ry1, ry2);
+  return {
+    x: x1,
+    y: pageHeight - y2,
+    width: x2 - x1,
+    height: y2 - y1
+  };
+}
+export function stampRectToPixelBounds(rect, pageHeight, scale, canvasWidth, canvasHeight) {
+  const normalized = normalizedPageRect(rect, pageHeight);
+  if (!normalized) return null;
+  const left = Math.max(0, Math.floor(normalized.x * scale));
+  const top = Math.max(0, Math.floor(normalized.y * scale));
+  const right = Math.min(canvasWidth, Math.ceil((normalized.x + normalized.width) * scale));
+  const bottom = Math.min(canvasHeight, Math.ceil((normalized.y + normalized.height) * scale));
+  const width = Math.max(0, right - left);
+  const height = Math.max(0, bottom - top);
+  if (width === 0 || height === 0) return null;
+  return { x: left, y: top, width, height };
+}
+export function findMaskBounds(mask, width, height) {
+  let minX = width;
+  let minY = height;
+  let maxX = -1;
+  let maxY = -1;
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      const index = y * width + x;
+      if (mask[index] !== 1) continue;
+      if (x < minX) minX = x;
+      if (y < minY) minY = y;
+      if (x > maxX) maxX = x;
+      if (y > maxY) maxY = y;
+    }
+  }
+  if (maxX < minX || maxY < minY) return null;
+  return {
+    x: minX,
+    y: minY,
+    width: maxX - minX + 1,
+    height: maxY - minY + 1
+  };
+}
+export function computeDiffMask(base, annotated, width, height, threshold = DEFAULT_DIFF_THRESHOLD) {
+  const pixelCount = width * height;
+  const mask = new Uint8Array(pixelCount);
+  if (base.length !== annotated.length || base.length !== pixelCount * 4) {
+    return { mask, bounds: null };
+  }
+  for (let pixel = 0; pixel < pixelCount; pixel++) {
+    const rgbaIndex = pixel * 4;
+    const delta = Math.abs(annotated[rgbaIndex] - base[rgbaIndex]) + Math.abs(annotated[rgbaIndex + 1] - base[rgbaIndex + 1]) + Math.abs(annotated[rgbaIndex + 2] - base[rgbaIndex + 2]) + Math.abs(annotated[rgbaIndex + 3] - base[rgbaIndex + 3]);
+    const hasVisiblePixel = annotated[rgbaIndex + 3] > 0;
+    if (hasVisiblePixel && delta >= threshold) {
+      mask[pixel] = 1;
+    }
+  }
+  return { mask, bounds: findMaskBounds(mask, width, height) };
+}
+export function applyMaskOrFallback(annotated, mask) {
+  const output = new Uint8ClampedArray(annotated);
+  const hasDiff = mask.includes(1);
+  if (!hasDiff) return { data: output, usedMask: false };
+  for (let pixel = 0; pixel < mask.length; pixel++) {
+    if (mask[pixel] === 1) continue;
+    const rgbaIndex = pixel * 4;
+    output[rgbaIndex] = 0;
+    output[rgbaIndex + 1] = 0;
+    output[rgbaIndex + 2] = 0;
+    output[rgbaIndex + 3] = 0;
+  }
+  return { data: output, usedMask: true };
+}
+function createCanvas(width, height) {
+  if (typeof document === "undefined") return null;
+  const canvas = document.createElement("canvas");
+  canvas.width = width;
+  canvas.height = height;
+  return canvas;
+}
+async function renderPageToCanvas(page, canvas, annotationMode, scale) {
+  const context = canvas.getContext("2d", { willReadFrequently: true });
+  if (!context) throw new Error("Unable to create canvas context for stamp extraction");
+  const viewport = page.getViewport({ scale });
+  const task = page.render({
+    canvasContext: context,
+    viewport,
+    annotationMode
+  });
+  await task.promise;
+}
+export async function extractStampAppearancesForPage(page, pageHeight, annotations, options = {}) {
+  const appearances = /* @__PURE__ */ new Map();
+  const stampAnnotations = annotations.filter(
+    (annotation) => annotation.annotationType === PdfjsAnnotationType.STAMP && typeof annotation.id === "string"
+  );
+  if (stampAnnotations.length === 0) return appearances;
+  const scale = options.scale ?? DEFAULT_RENDER_SCALE;
+  const diffThreshold = options.diffThreshold ?? DEFAULT_DIFF_THRESHOLD;
+  const viewport = page.getViewport({ scale });
+  const renderWidth = Math.max(1, Math.ceil(viewport.width));
+  const renderHeight = Math.max(1, Math.ceil(viewport.height));
+  const baseCanvas = createCanvas(renderWidth, renderHeight);
+  const annotatedCanvas = createCanvas(renderWidth, renderHeight);
+  if (!baseCanvas || !annotatedCanvas) return appearances;
+  try {
+    await renderPageToCanvas(page, baseCanvas, PDFJS_ANNOTATION_MODE_DISABLE, scale);
+    await renderPageToCanvas(page, annotatedCanvas, PDFJS_ANNOTATION_MODE_ENABLE, scale);
+  } catch (error) {
+    console.warn("[KViewer] Failed to render page for stamp extraction", error);
+    return appearances;
+  }
+  const baseContext = baseCanvas.getContext("2d", { willReadFrequently: true });
+  const annotatedContext = annotatedCanvas.getContext("2d", { willReadFrequently: true });
+  if (!baseContext || !annotatedContext) return appearances;
+  for (const annotation of stampAnnotations) {
+    try {
+      const id = annotation.id;
+      const bounds = stampRectToPixelBounds(
+        annotation.rect,
+        pageHeight,
+        scale,
+        renderWidth,
+        renderHeight
+      );
+      if (!bounds) continue;
+      const baseData = baseContext.getImageData(bounds.x, bounds.y, bounds.width, bounds.height);
+      const annotatedData = annotatedContext.getImageData(bounds.x, bounds.y, bounds.width, bounds.height);
+      const { mask } = computeDiffMask(
+        baseData.data,
+        annotatedData.data,
+        bounds.width,
+        bounds.height,
+        diffThreshold
+      );
+      const { data: maskedData } = applyMaskOrFallback(annotatedData.data, mask);
+      const outputCanvas = createCanvas(bounds.width, bounds.height);
+      if (!outputCanvas) continue;
+      const outputContext = outputCanvas.getContext("2d");
+      if (!outputContext) continue;
+      const outputImageData = outputContext.createImageData(bounds.width, bounds.height);
+      outputImageData.data.set(maskedData);
+      outputContext.putImageData(outputImageData, 0, 0);
+      const dataUrl = outputCanvas.toDataURL("image/png");
+      appearances.set(id, {
+        dataUrl,
+        width: bounds.width / scale,
+        height: bounds.height / scale
+      });
+    } catch (error) {
+      console.warn(`[KViewer] Failed to extract stamp appearance ${annotation.id}`, error);
+    }
+  }
+  return appearances;
+}

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

@@ -0,0 +1,57 @@
+export interface RawPdfTextObject {
+    str?: unknown;
+}
+export interface RawPdfBorderStyle {
+    width?: unknown;
+    rawWidth?: unknown;
+    style?: unknown;
+    dashArray?: unknown;
+}
+export interface RawPdfPoint {
+    x?: unknown;
+    y?: unknown;
+}
+export interface RawPdfAppearanceData {
+    fontColor?: unknown;
+    fontSize?: unknown;
+    fontName?: unknown;
+}
+export interface RawPdfAnnotation {
+    id?: unknown;
+    annotationType?: unknown;
+    subtype?: unknown;
+    rect?: unknown;
+    color?: unknown;
+    borderStyle?: unknown;
+    titleObj?: unknown;
+    contentsObj?: unknown;
+    modificationDate?: unknown;
+    inReplyTo?: unknown;
+    quadPoints?: unknown;
+    defaultAppearanceData?: unknown;
+    inkLists?: unknown;
+    lineCoordinates?: unknown;
+    lineEndings?: unknown;
+    opacity?: unknown;
+    textPosition?: unknown;
+    textContent?: unknown;
+}
+export interface StampAppearance {
+    dataUrl: string;
+    width: number;
+    height: number;
+}
+export interface DecodeContext {
+    pageNumber: number;
+    pageHeight: number;
+    allAnnotations: RawPdfAnnotation[];
+    stampAppearances?: Map<string, StampAppearance>;
+}
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function isString(value: unknown): value is string;
+export declare function isNumber(value: unknown): value is number;
+export declare function asBorderStyle(input: unknown): RawPdfBorderStyle | null;
+export declare function asPoint(input: unknown): RawPdfPoint | null;
+export declare function asTextObject(input: unknown): RawPdfTextObject | null;
+export declare function asAppearanceData(input: unknown): RawPdfAppearanceData | null;
+export declare function isRawPdfAnnotation(value: unknown): value is RawPdfAnnotation;

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

@@ -0,0 +1,25 @@
+export function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+export function isString(value) {
+  return typeof value === "string";
+}
+export function isNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+export function asBorderStyle(input) {
+  return isRecord(input) ? input : null;
+}
+export function asPoint(input) {
+  return isRecord(input) ? input : null;
+}
+export function asTextObject(input) {
+  return isRecord(input) ? input : null;
+}
+export function asAppearanceData(input) {
+  return isRecord(input) ? input : null;
+}
+export function isRawPdfAnnotation(value) {
+  if (!isRecord(value)) return false;
+  return isString(value.id) && isNumber(value.annotationType);
+}

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

@@ -0,0 +1,48 @@
+import Konva from 'konva';
+import { type AnnotationType, type IAnnotationComment, type IAnnotationStore, type PdfjsAnnotationSubtype } from '../engine/types.js';
+import { type RawPdfAnnotation } from './types.js';
+type Rect = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export interface StrokeWidthOptions {
+    preferRawWidth?: boolean;
+}
+export declare function colorArrayToRgb(input: unknown): string | null;
+export declare function getAnnotationColor(annotation: RawPdfAnnotation, type: AnnotationType): string;
+export declare function getAnnotationTitle(annotation: RawPdfAnnotation): string;
+export declare function getAnnotationText(annotation: RawPdfAnnotation): string;
+export declare function getFreeTextContent(annotation: RawPdfAnnotation): string;
+export declare function getAnnotationDate(annotation: RawPdfAnnotation): string;
+export declare function getComments(annotation: RawPdfAnnotation, allAnnotations: RawPdfAnnotation[]): IAnnotationComment[];
+export declare function rectFromPdfRect(input: unknown, pageHeight: number): Rect | null;
+export declare function pointFromPdfPoint(input: unknown, pageHeight: number): {
+    x: number;
+    y: number;
+} | null;
+export declare function localPointFromPdfPoint(input: unknown): {
+    x: number;
+    y: number;
+} | null;
+export declare function rectFromQuadPoints(input: unknown, pageHeight: number): Rect | null;
+export declare function pointsFromInkList(input: unknown, pageHeight: number): number[];
+export declare function linePointsFromCoordinates(input: unknown, pageHeight: number): number[] | null;
+export declare function normalizedStrokeWidth(annotation: RawPdfAnnotation, fallback?: number, options?: StrokeWidthOptions): number;
+export declare function dashedBorder(annotation: RawPdfAnnotation): number[];
+export declare function hasArrowEnding(value: unknown): boolean;
+export declare function createGhostGroup(id: string): Konva.Group;
+export declare function createAnnotationStore(params: {
+    annotation: RawPdfAnnotation;
+    allAnnotations: RawPdfAnnotation[];
+    pageNumber: number;
+    type: AnnotationType;
+    group: Konva.Group;
+    color?: string;
+    fontSize?: number;
+    contentsText?: string;
+    contentsImage?: string;
+    overrideSubtype?: PdfjsAnnotationSubtype;
+}): IAnnotationStore;
+export {};