kviewer 0.0.1

package/dist/runtime/annotation/engine/input-device.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Input device classification for stylus mode.
+ * Single source of truth for determining input type from native events.
+ */
+export type InputDeviceType = 'pen' | 'touch' | 'mouse' | 'unknown';
+/**
+ * Classify a native event into an input device type.
+ *
+ * Priority:
+ * 1. PointerEvent.pointerType (most reliable, available on modern iPadOS)
+ * 2. Touch.touchType (Safari/WebKit fallback: 'stylus' vs 'direct')
+ * 3. Event constructor heuristic
+ */
+export declare function classifyInputDevice(event: Event): InputDeviceType;
+/**
+ * Returns true if the input should be allowed to create/modify annotations.
+ * In stylus mode: only pen and mouse inputs can annotate.
+ * When stylus mode is off: all inputs can annotate.
+ */
+export declare function shouldAllowAnnotation(event: Event, stylusModeEnabled: boolean): boolean;
+/**
+ * Returns true if the event originated from a finger touch.
+ */
+export declare function isFingerTouch(event: Event): boolean;
+/**
+ * Returns true if a TouchEvent came from Apple Pencil / stylus.
+ * Uses Safari's Touch.touchType API ('stylus' vs 'direct').
+ */
+export declare function isStylusTouch(event: TouchEvent): boolean;
+/**
+ * Detect if the current device is an iPad.
+ * iPadOS 13+ reports as 'MacIntel' in navigator.platform,
+ * so we also check for multi-touch support.
+ */
+export declare function isIPad(): boolean;
+/**
+ * Compute the Euclidean distance between two touch points.
+ */
+export declare function getTouchDistance(touch1: Touch, touch2: Touch): number;
+/**
+ * Compute the midpoint between two touch points in client coordinates.
+ */
+export declare function getTouchCenter(touch1: Touch, touch2: Touch): {
+    x: number;
+    y: number;
+};
+/** Minimum and maximum scale values for pinch zoom. */
+export declare const PINCH_SCALE_MIN = 0.25;
+export declare const PINCH_SCALE_MAX = 4;
+/**
+ * Clamp a scale value to safe bounds.
+ */
+export declare function clampScale(scale: number): number;

package/dist/runtime/annotation/engine/input-device.js

@@ -0,0 +1,64 @@
+export function classifyInputDevice(event) {
+  if (event instanceof PointerEvent) {
+    switch (event.pointerType) {
+      case "pen":
+        return "pen";
+      case "touch":
+        return "touch";
+      case "mouse":
+        return "mouse";
+      default:
+        return "unknown";
+    }
+  }
+  if (typeof TouchEvent !== "undefined" && event instanceof TouchEvent) {
+    const touch = event.touches && event.touches[0] || event.changedTouches && event.changedTouches[0];
+    if (touch && "touchType" in touch) {
+      return touch.touchType === "stylus" ? "pen" : "touch";
+    }
+    return "touch";
+  }
+  if (event instanceof MouseEvent) {
+    return "mouse";
+  }
+  return "unknown";
+}
+export function shouldAllowAnnotation(event, stylusModeEnabled) {
+  if (!stylusModeEnabled) return true;
+  const device = classifyInputDevice(event);
+  return device === "pen" || device === "mouse";
+}
+export function isFingerTouch(event) {
+  return classifyInputDevice(event) === "touch";
+}
+export function isStylusTouch(event) {
+  const touch = event.touches && event.touches[0] || event.changedTouches && event.changedTouches[0];
+  if (touch && "touchType" in touch) {
+    return touch.touchType === "stylus";
+  }
+  return false;
+}
+export function isIPad() {
+  if (typeof navigator === "undefined") return false;
+  if (/iPad/.test(navigator.userAgent)) return true;
+  if (navigator.platform === "MacIntel" && navigator.maxTouchPoints > 1) {
+    return true;
+  }
+  return false;
+}
+export function getTouchDistance(touch1, touch2) {
+  const dx = touch1.clientX - touch2.clientX;
+  const dy = touch1.clientY - touch2.clientY;
+  return Math.sqrt(dx * dx + dy * dy);
+}
+export function getTouchCenter(touch1, touch2) {
+  return {
+    x: (touch1.clientX + touch2.clientX) / 2,
+    y: (touch1.clientY + touch2.clientY) / 2
+  };
+}
+export const PINCH_SCALE_MIN = 0.25;
+export const PINCH_SCALE_MAX = 4;
+export function clampScale(scale) {
+  return Math.min(PINCH_SCALE_MAX, Math.max(PINCH_SCALE_MIN, scale));
+}

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

@@ -0,0 +1,97 @@
+import Konva from 'konva';
+import type { IRect } from 'konva/lib/types';
+import { type IAnnotationStore, type IAnnotationStyle, type IAnnotationType } from './types.js';
+import { type IEditorFreeTextOptions } from './tools/free-text.js';
+export interface KonvaCanvas {
+    pageNumber: number;
+    konvaStage: Konva.Stage;
+    wrapper: HTMLDivElement;
+    isActive: boolean;
+}
+export interface PainterCallbacks {
+    setDefaultMode: () => void;
+    forceReset: () => void;
+    onStoreAdd: (annotationStore: IAnnotationStore, isOriginal: boolean, currentAnnotation: IAnnotationType) => void;
+    onStoreDelete: (id: string) => void;
+    onAnnotationSelected: (annotationStore: IAnnotationStore, isClick: boolean, selectorRect: IRect) => void;
+    onMultiSelected: (annotationStores: IAnnotationStore[], combinedRect: IRect) => void;
+    onAnnotationChange: (annotationStore: IAnnotationStore) => void;
+    onAnnotationChanging: () => void;
+    onAnnotationChanged: (annotationStore: IAnnotationStore, selectorRect: IRect) => void;
+    onRequestTextInput: IEditorFreeTextOptions['onRequestTextInput'];
+    onRequestDeleteConfirm?: (id: string) => Promise<boolean>;
+}
+export declare class Painter {
+    private userName;
+    private konvaCanvasStore;
+    private editorStore;
+    private currentAnnotation;
+    private store;
+    private selector;
+    private tempDataTransfer;
+    private callbacks;
+    private getStylusModeEnabled?;
+    constructor({ userName, callbacks, getStylusModeEnabled, }: {
+        userName: string;
+        callbacks: PainterCallbacks;
+        getStylusModeEnabled?: () => boolean;
+    });
+    private editFreeText;
+    private bindGlobalEvents;
+    private globalKeyUpHandler;
+    private createKonvaStage;
+    private applyStylusTouchAction;
+    private removeStylusTouchAction;
+    private saveToStore;
+    private updateStore;
+    /**
+     * Convert a Konva stage-relative rect to viewport-relative coordinates
+     * by combining with the stage container's DOM position.
+     */
+    private toViewportRect;
+    private parseStampData;
+    private findEditorForGroupId;
+    private findEditor;
+    private enableEditor;
+    private enablePainting;
+    private reDrawAnnotation;
+    private drawAnnotation;
+    private deleteAnnotation;
+    private setMode;
+    private disablePainting;
+    /**
+     * Toggle hit detection on annotation layers.
+     * When a drawing tool is active, disable listening on the entire layer
+     * so Konva skips the expensive hit canvas redraw on every touchmove.
+     * Re-enable when switching to select/hand mode where clicks need to work.
+     */
+    private setShapeGroupsListening;
+    private saveTempDataTransfer;
+    private clearTempDataTransfer;
+    /**
+     * Programmatic imports/additions (replace/merge/redo) add Konva groups
+     * directly, so selector handlers need to be rebound when hand/select mode
+     * is currently active.
+     */
+    private refreshSelectorForPages;
+    refreshStylusMode(): void;
+    initCanvasForPage(pageNumber: number, container: HTMLDivElement, width: number, height: number, scale: number): void;
+    destroyCanvasForPage(pageNumber: number): void;
+    activate(annotation: IAnnotationType | null, dataTransfer: string | null): void;
+    activateMarquee(): void;
+    activateEraser(): void;
+    highlightRange(range: Range, annotation: IAnnotationType): void;
+    selectAnnotation(id: string): void;
+    initAnnotations(annotations: IAnnotationStore[]): Promise<void>;
+    update(id: string, updates: Partial<IAnnotationStore>): void;
+    delete(id: string, emit?: boolean): void;
+    updateAnnotationStyle(annotationStore: IAnnotationStore, style: IAnnotationStyle): void;
+    reAddAnnotation(annotation: IAnnotationStore): void;
+    getData(): IAnnotationStore[];
+    getAnnotation(id: string): IAnnotationStore | undefined;
+    clearAllAnnotations(emit?: boolean): void;
+    replaceAnnotations(annotations: IAnnotationStore[]): void;
+    mergeAnnotations(annotations: IAnnotationStore[]): void;
+    getCanvasState(): Record<number, string>;
+    destroy(): void;
+}