@rajeev02/document 0.1.0

package/src/editor/index.ts

@@ -0,0 +1,352 @@
+/**
+ * @rajeev02/document — Editor
+ * PDF annotation, highlight, text, stamps, form filling, page management
+ */
+
+export type AnnotationTool =
+  | "highlight"
+  | "underline"
+  | "strikethrough"
+  | "freehand"
+  | "text_note"
+  | "text_box"
+  | "rectangle"
+  | "circle"
+  | "arrow"
+  | "stamp"
+  | "eraser";
+
+export interface Annotation {
+  id: string;
+  tool: AnnotationTool;
+  pageNumber: number;
+  /** Position relative to page (0-1 normalized) */
+  position: { x: number; y: number };
+  size?: { width: number; height: number };
+  color: string;
+  opacity: number;
+  /** Text content (for notes, text boxes) */
+  text?: string;
+  /** Font size for text */
+  fontSize?: number;
+  /** Freehand path points */
+  path?: { x: number; y: number }[];
+  /** Pen thickness for freehand/shapes */
+  strokeWidth?: number;
+  /** Stamp type */
+  stampType?: StampType;
+  createdAt: number;
+  modifiedAt: number;
+}
+
+export type StampType =
+  | "approved"
+  | "rejected"
+  | "draft"
+  | "confidential"
+  | "reviewed"
+  | "final"
+  | "copy"
+  | "void"
+  | "urgent"
+  | "custom";
+
+export interface FormField {
+  id: string;
+  type: "text" | "checkbox" | "radio" | "select" | "date" | "signature";
+  label: string;
+  pageNumber: number;
+  position: { x: number; y: number };
+  size: { width: number; height: number };
+  value?: string;
+  required: boolean;
+  options?: string[];
+}
+
+export interface DocumentPage {
+  pageNumber: number;
+  width: number;
+  height: number;
+  thumbnailUri?: string;
+  annotations: Annotation[];
+  rotation: number;
+}
+
+/**
+ * Document Editor Controller
+ */
+export class DocumentEditorController {
+  private sourceUri: string;
+  private pages: DocumentPage[] = [];
+  private annotations: Annotation[] = [];
+  private formFields: FormField[] = [];
+  private currentPage: number = 1;
+  private zoom: number = 1.0;
+  private activeTool: AnnotationTool | null = null;
+  private activeColor: string = "#FFFF00"; // Yellow highlight
+  private activeStrokeWidth: number = 2;
+  private history: Annotation[][] = [];
+  private historyIndex: number = -1;
+  private listeners: Set<(event: DocEditorEvent) => void> = new Set();
+
+  constructor(sourceUri: string, totalPages: number = 1) {
+    this.sourceUri = sourceUri;
+    for (let i = 1; i <= totalPages; i++) {
+      this.pages.push({
+        pageNumber: i,
+        width: 595,
+        height: 842,
+        annotations: [],
+        rotation: 0,
+      });
+    }
+  }
+
+  // ---- NAVIGATION ----
+  goToPage(page: number): void {
+    this.currentPage = Math.max(1, Math.min(page, this.pages.length));
+  }
+  nextPage(): void {
+    this.goToPage(this.currentPage + 1);
+  }
+  prevPage(): void {
+    this.goToPage(this.currentPage - 1);
+  }
+  getCurrentPage(): number {
+    return this.currentPage;
+  }
+  getTotalPages(): number {
+    return this.pages.length;
+  }
+  setZoom(zoom: number): void {
+    this.zoom = Math.max(0.5, Math.min(5.0, zoom));
+  }
+  getZoom(): number {
+    return this.zoom;
+  }
+
+  // ---- TOOLS ----
+  setActiveTool(tool: AnnotationTool | null): void {
+    this.activeTool = tool;
+  }
+  getActiveTool(): AnnotationTool | null {
+    return this.activeTool;
+  }
+  setActiveColor(color: string): void {
+    this.activeColor = color;
+  }
+  setStrokeWidth(width: number): void {
+    this.activeStrokeWidth = width;
+  }
+
+  // ---- ANNOTATIONS ----
+  addAnnotation(
+    annotation: Omit<Annotation, "id" | "createdAt" | "modifiedAt">,
+  ): string {
+    const id = `ann_${Date.now()}_${Math.random().toString(36).substr(2, 4)}`;
+    const full: Annotation = {
+      ...annotation,
+      id,
+      createdAt: Date.now(),
+      modifiedAt: Date.now(),
+    };
+    this.annotations.push(full);
+    this.saveHistory();
+    this.emit({ type: "annotation_added", annotation: full });
+    return id;
+  }
+
+  /** Quick highlight at position on current page */
+  addHighlight(x: number, y: number, width: number, height: number): string {
+    return this.addAnnotation({
+      tool: "highlight",
+      pageNumber: this.currentPage,
+      position: { x, y },
+      size: { width, height },
+      color: this.activeColor,
+      opacity: 0.4,
+    });
+  }
+
+  /** Add text note */
+  addTextNote(x: number, y: number, text: string): string {
+    return this.addAnnotation({
+      tool: "text_note",
+      pageNumber: this.currentPage,
+      position: { x, y },
+      text,
+      color: "#FEF3C7",
+      opacity: 1,
+      fontSize: 12,
+    });
+  }
+
+  /** Add text box */
+  addTextBox(
+    x: number,
+    y: number,
+    width: number,
+    height: number,
+    text: string,
+  ): string {
+    return this.addAnnotation({
+      tool: "text_box",
+      pageNumber: this.currentPage,
+      position: { x, y },
+      size: { width, height },
+      text,
+      color: "#000000",
+      opacity: 1,
+      fontSize: 14,
+    });
+  }
+
+  /** Add stamp */
+  addStamp(x: number, y: number, stampType: StampType): string {
+    return this.addAnnotation({
+      tool: "stamp",
+      pageNumber: this.currentPage,
+      position: { x, y },
+      size: { width: 0.2, height: 0.06 },
+      color: stampType === "approved" ? "#10B981" : "#EF4444",
+      opacity: 0.9,
+      stampType,
+    });
+  }
+
+  /** Add freehand drawing */
+  addFreehand(path: { x: number; y: number }[]): string {
+    return this.addAnnotation({
+      tool: "freehand",
+      pageNumber: this.currentPage,
+      position: path[0] ?? { x: 0, y: 0 },
+      path,
+      color: this.activeColor,
+      opacity: 1,
+      strokeWidth: this.activeStrokeWidth,
+    });
+  }
+
+  removeAnnotation(id: string): void {
+    this.annotations = this.annotations.filter((a) => a.id !== id);
+    this.saveHistory();
+    this.emit({ type: "annotation_removed", annotationId: id });
+  }
+
+  getAnnotations(pageNumber?: number): Annotation[] {
+    if (pageNumber)
+      return this.annotations.filter((a) => a.pageNumber === pageNumber);
+    return [...this.annotations];
+  }
+
+  clearAnnotations(pageNumber?: number): void {
+    if (pageNumber)
+      this.annotations = this.annotations.filter(
+        (a) => a.pageNumber !== pageNumber,
+      );
+    else this.annotations = [];
+    this.saveHistory();
+  }
+
+  // ---- PAGE MANAGEMENT ----
+  rotatePage(pageNumber: number, degrees: number): void {
+    const page = this.pages.find((p) => p.pageNumber === pageNumber);
+    if (page) page.rotation = (page.rotation + degrees) % 360;
+  }
+
+  deletePage(pageNumber: number): void {
+    if (this.pages.length <= 1) return;
+    this.pages = this.pages.filter((p) => p.pageNumber !== pageNumber);
+    this.annotations = this.annotations.filter(
+      (a) => a.pageNumber !== pageNumber,
+    );
+    // Renumber
+    this.pages.forEach((p, i) => {
+      p.pageNumber = i + 1;
+    });
+  }
+
+  reorderPages(fromIndex: number, toIndex: number): void {
+    if (
+      fromIndex < 0 ||
+      toIndex < 0 ||
+      fromIndex >= this.pages.length ||
+      toIndex >= this.pages.length
+    )
+      return;
+    const [page] = this.pages.splice(fromIndex, 1);
+    this.pages.splice(toIndex, 0, page);
+    this.pages.forEach((p, i) => {
+      p.pageNumber = i + 1;
+    });
+  }
+
+  // ---- FORM FILLING ----
+  setFormFieldValue(fieldId: string, value: string): void {
+    const field = this.formFields.find((f) => f.id === fieldId);
+    if (field) field.value = value;
+  }
+
+  getFormFields(): FormField[] {
+    return [...this.formFields];
+  }
+  loadFormFields(fields: FormField[]): void {
+    this.formFields = fields;
+  }
+
+  // ---- UNDO/REDO ----
+  undo(): boolean {
+    if (this.historyIndex <= 0) return false;
+    this.historyIndex--;
+    this.annotations = [...this.history[this.historyIndex]];
+    return true;
+  }
+
+  redo(): boolean {
+    if (this.historyIndex >= this.history.length - 1) return false;
+    this.historyIndex++;
+    this.annotations = [...this.history[this.historyIndex]];
+    return true;
+  }
+
+  canUndo(): boolean {
+    return this.historyIndex > 0;
+  }
+  canRedo(): boolean {
+    return this.historyIndex < this.history.length - 1;
+  }
+
+  /** Export state for saving */
+  getEditState(): Record<string, unknown> {
+    return {
+      sourceUri: this.sourceUri,
+      annotations: this.annotations,
+      formFields: this.formFields,
+      pages: this.pages,
+    };
+  }
+
+  on(listener: (event: DocEditorEvent) => void): () => void {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+
+  private saveHistory(): void {
+    this.history = this.history.slice(0, this.historyIndex + 1);
+    this.history.push([...this.annotations]);
+    this.historyIndex = this.history.length - 1;
+  }
+
+  private emit(event: DocEditorEvent): void {
+    for (const l of this.listeners) {
+      try {
+        l(event);
+      } catch {}
+    }
+  }
+}
+
+export type DocEditorEvent =
+  | { type: "annotation_added"; annotation: Annotation }
+  | { type: "annotation_removed"; annotationId: string }
+  | { type: "page_changed"; page: number };

package/src/index.ts

@@ -0,0 +1,44 @@
+/**
+ * @rajeev02/document
+ * Document Picker, Editor & Signature
+ * File picker, PDF annotation, stamps, form filling, digital signatures
+ *
+ * @author Rajeev Kumar Joshi
+ * @license MIT
+ */
+
+// Picker
+export {
+  categorizeFile,
+  getMimeTypesForCategory,
+  formatFileSize,
+  getFileExtension,
+  getFileIcon,
+  getPickerPreset,
+} from "./picker";
+export type {
+  DocumentSource,
+  DocumentCategory,
+  PickerConfig,
+  PickedDocument,
+} from "./picker";
+
+// Editor
+export { DocumentEditorController } from "./editor";
+export type {
+  AnnotationTool,
+  Annotation,
+  StampType,
+  FormField,
+  DocumentPage,
+  DocEditorEvent,
+} from "./editor";
+
+// Signature
+export { SignatureManager, getSignatureSizePresets } from "./signature";
+export type {
+  SignatureType,
+  SignatureData,
+  SignaturePlacement,
+  SignatureConfig,
+} from "./signature";

package/src/picker/index.ts

@@ -0,0 +1,246 @@
+/**
+ * @rajeev02/document — Picker
+ * Universal document picker: gallery, camera, files, cloud, recent, multi-select
+ */
+
+export type DocumentSource =
+  | "gallery"
+  | "camera"
+  | "files"
+  | "google_drive"
+  | "dropbox"
+  | "onedrive"
+  | "icloud"
+  | "recent";
+export type DocumentCategory =
+  | "image"
+  | "video"
+  | "audio"
+  | "pdf"
+  | "document"
+  | "spreadsheet"
+  | "presentation"
+  | "archive"
+  | "any";
+
+export interface PickerConfig {
+  /** Allowed sources */
+  sources: DocumentSource[];
+  /** Allowed file categories */
+  categories: DocumentCategory[];
+  /** Custom MIME types (e.g., ['application/pdf', 'image/jpeg']) */
+  mimeTypes?: string[];
+  /** Allow multiple selection */
+  multiple: boolean;
+  /** Max files in multi-select */
+  maxFiles?: number;
+  /** Max file size per file (bytes) */
+  maxSizeBytes?: number;
+  /** Total max size (bytes) */
+  totalMaxSizeBytes?: number;
+  /** Enable camera document scanning mode */
+  enableDocumentScan?: boolean;
+  /** Compress images before returning */
+  compressImages?: boolean;
+  /** Max image dimension after compression */
+  maxImageDimension?: number;
+}
+
+export interface PickedDocument {
+  id: string;
+  name: string;
+  uri: string;
+  mimeType: string;
+  sizeBytes: number;
+  category: DocumentCategory;
+  source: DocumentSource;
+  /** Image/video width */
+  width?: number;
+  /** Image/video height */
+  height?: number;
+  /** Video/audio duration ms */
+  durationMs?: number;
+  /** Thumbnail URI */
+  thumbnailUri?: string;
+  /** Last modified timestamp */
+  modifiedAt?: number;
+  /** File extension */
+  extension: string;
+}
+
+/** MIME type to category mapping */
+export function categorizeFile(mimeType: string): DocumentCategory {
+  if (mimeType.startsWith("image/")) return "image";
+  if (mimeType.startsWith("video/")) return "video";
+  if (mimeType.startsWith("audio/")) return "audio";
+  if (mimeType === "application/pdf") return "pdf";
+  if (
+    mimeType.includes("word") ||
+    mimeType.includes("document") ||
+    mimeType.includes("text")
+  )
+    return "document";
+  if (
+    mimeType.includes("sheet") ||
+    mimeType.includes("excel") ||
+    mimeType.includes("csv")
+  )
+    return "spreadsheet";
+  if (mimeType.includes("presentation") || mimeType.includes("powerpoint"))
+    return "presentation";
+  if (
+    mimeType.includes("zip") ||
+    mimeType.includes("rar") ||
+    mimeType.includes("tar") ||
+    mimeType.includes("7z")
+  )
+    return "archive";
+  return "any";
+}
+
+/** Get MIME types for a category */
+export function getMimeTypesForCategory(category: DocumentCategory): string[] {
+  switch (category) {
+    case "image":
+      return [
+        "image/jpeg",
+        "image/png",
+        "image/gif",
+        "image/webp",
+        "image/heic",
+        "image/heif",
+        "image/bmp",
+        "image/svg+xml",
+      ];
+    case "video":
+      return [
+        "video/mp4",
+        "video/quicktime",
+        "video/x-msvideo",
+        "video/webm",
+        "video/3gpp",
+      ];
+    case "audio":
+      return [
+        "audio/mpeg",
+        "audio/wav",
+        "audio/ogg",
+        "audio/aac",
+        "audio/flac",
+        "audio/x-m4a",
+      ];
+    case "pdf":
+      return ["application/pdf"];
+    case "document":
+      return [
+        "application/msword",
+        "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+        "text/plain",
+        "text/rtf",
+        "application/rtf",
+      ];
+    case "spreadsheet":
+      return [
+        "application/vnd.ms-excel",
+        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        "text/csv",
+      ];
+    case "presentation":
+      return [
+        "application/vnd.ms-powerpoint",
+        "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+      ];
+    case "archive":
+      return [
+        "application/zip",
+        "application/x-rar-compressed",
+        "application/x-7z-compressed",
+        "application/gzip",
+      ];
+    case "any":
+      return ["*/*"];
+    default:
+      return ["*/*"];
+  }
+}
+
+/** Format file size for display */
+export function formatFileSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  if (bytes < 1024 * 1024 * 1024)
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+}
+
+/** Get file extension from name or URI */
+export function getFileExtension(nameOrUri: string): string {
+  const parts = nameOrUri.split(".");
+  return parts.length > 1
+    ? parts[parts.length - 1].toLowerCase().split("?")[0]
+    : "";
+}
+
+/** Get icon name for file category (for UI rendering) */
+export function getFileIcon(category: DocumentCategory): string {
+  const icons: Record<DocumentCategory, string> = {
+    image: "image",
+    video: "film",
+    audio: "music",
+    pdf: "file-text",
+    document: "file-text",
+    spreadsheet: "table",
+    presentation: "monitor",
+    archive: "archive",
+    any: "file",
+  };
+  return icons[category] ?? "file";
+}
+
+/** Default picker configs for common use cases */
+export function getPickerPreset(
+  preset: "photo" | "video" | "document" | "kyc_document" | "any",
+): PickerConfig {
+  switch (preset) {
+    case "photo":
+      return {
+        sources: ["gallery", "camera"],
+        categories: ["image"],
+        multiple: false,
+        compressImages: true,
+        maxImageDimension: 2048,
+        maxSizeBytes: 10 * 1024 * 1024,
+      };
+    case "video":
+      return {
+        sources: ["gallery", "camera"],
+        categories: ["video"],
+        multiple: false,
+        maxSizeBytes: 100 * 1024 * 1024,
+      };
+    case "document":
+      return {
+        sources: ["files", "google_drive", "recent"],
+        categories: ["pdf", "document", "spreadsheet"],
+        multiple: true,
+        maxFiles: 10,
+        maxSizeBytes: 25 * 1024 * 1024,
+      };
+    case "kyc_document":
+      return {
+        sources: ["camera", "gallery"],
+        categories: ["image", "pdf"],
+        multiple: false,
+        enableDocumentScan: true,
+        compressImages: true,
+        maxSizeBytes: 5 * 1024 * 1024,
+      };
+    case "any":
+      return {
+        sources: ["files", "gallery", "camera", "google_drive", "recent"],
+        categories: ["any"],
+        multiple: true,
+        maxFiles: 20,
+      };
+  }
+}