teamsync-pdf-viewer 1.1.0 → 1.2.0

package/CHANGELOG.md

@@ -2,6 +2,35 @@
 
 All notable changes to `teamsync-pdf-viewer` are documented here.
 
+## [1.2.0] — 2026-08-31
+
+### Added
+- **`AnnotationManager`** (`instance.annotationManager`, also `instance.Core.annotationManager`):
+  the canonical annotation list with undo/redo, granular `annotationChanged` events
+  (`add` | `modify` | `delete`, with an `imported` flag), authorship stamping
+  (`currentUser`), edit permissions (read-only viewer, read-only annotation, other authors —
+  `permissions.canEditOthers`) and programmatic `addAnnotations` / `updateAnnotation` /
+  `deleteAnnotations` / `getAnnotationById`.
+- **Native XFDF**: `annotationManager.importAnnotations(xfdf)` and
+  `exportAnnotations({ annotList?, useDisplayAuthor? })` (bare fragments per annotation, or a full
+  document). Reads Acrobat/Apryse XFDF (square, circle, line/arrow, ink, highlight quads, freetext,
+  callout, sticky note, stamp with image data, link) and keeps everything else as read-only
+  `opaque` annotations that re-export verbatim; unknown attributes/children (e.g. Apryse
+  `trn-custom-data`) are preserved across a round-trip. Stable UUID ids double as the XFDF `name`.
+- **Page geometry module** (`createPageGeometry`, `rectToPdf`, `quadPointsToRects`, …): the single
+  authority for base-page-space ↔ PDF-user-space conversion, mirroring pdf.js's viewport transform.
+- **Print** (menu item enabled, `instance.print()`): the exported document is printed through the
+  browser's PDF viewer in a hidden frame.
+- `instance.on('annotationChanged', …)` typed event; `Annotation.author/authorId/createdAt/
+  modifiedAt/readOnly/strokes/rects` fields; multi-stroke ink and multi-rect highlights render.
+
+### Fixed
+- Export geometry: annotations are baked exactly where they were drawn (any page size, CropBox
+  offset or intrinsic /Rotate) — replaces the hard-coded `scale = 1.5` conversion.
+- Mixed page sizes: layout, scrolling, hit-testing and fit-to-width/page now use per-page
+  dimensions instead of page 1's.
+- Annotation ids were timestamps (collision-prone); now `crypto.randomUUID()`.
+
 ## [1.1.0] — 2026-08-31
 
 ### Breaking

package/README.md

@@ -34,8 +34,13 @@ Client-side PDF viewing, annotation, search, redaction and watermarking for Reac
   keyboard shortcuts apply to the focused viewer only, and importing the package is side-effect free
   (safe under SSR).
 
-Not yet supported: printing (planned for 1.2), AcroForm filling, rendering of annotations already
-embedded in the PDF, document outline/bookmarks, password prompts (password-protected files raise
+- **Annotation API** — `instance.annotationManager`: undo/redo, granular `annotationChanged`
+  events, authorship + edit permissions, programmatic add/update/delete and **native XFDF**
+  import/export (Acrobat/Apryse-compatible; unknown markup is preserved as read-only pass-through).
+- **Print** — via the menu or `instance.print()`.
+
+Not yet supported: AcroForm filling, rendering of annotations already embedded in the PDF (only
+XFDF-imported ones), document outline/bookmarks, password prompts (password-protected files raise
 `onPasswordRequired`).
 
 ---
@@ -162,6 +167,9 @@ instance.destroy(); // unmounts and releases every listener
 | `autoFocus` | `boolean` | `false` | Focus the viewer on mount (keyboard shortcuts). |
 | `plugins` | `ViewerPlugin[]` | `[]` | Extension plugins. |
 
+`permissions.canEditOthers` (default `false`) lets a user edit or delete annotations authored by
+someone else; annotations carry `author`/`authorId` from `currentUser`.
+
 Callbacks: `onReady(instance)`, `onDocumentLoaded({ url, numPages })`,
 `onDocumentLoadError(error, retry(newUrl?), { url, passwordRequired })`, `onFirstPageRendered`,
 `onPasswordRequired`, `onPageChange(page, numPages)`, `onAnnotationsChange(annotations)`.
@@ -172,7 +180,12 @@ Callbacks: `onReady(instance)`, `onDocumentLoaded({ url, numPages })`,
   `firstPageRendered`, `pageChanged`, `annotationsChanged`, `toolChanged`, `destroy`.
 - `loadDocument(url)` — load or reload (resolves on load, rejects on error).
 - `getFileData({ explicitAnnotations? })` — export the document as `Uint8Array`.
-- `getAnnotations()`, `getCurrentPage()`, `getPageCount()`, `getPdfDocument()`.
+- `getAnnotations()`, `getCurrentPage()`, `getPageCount()`, `getPdfDocument()`, `print()`.
+- `annotationManager` — `getAnnotationsList()`, `getAnnotationById(id)`, `addAnnotations(list)`,
+  `updateAnnotation(id, patch)`, `deleteAnnotations(ids, { force })`, `undo()`/`redo()`,
+  `importAnnotations(xfdf)`, `exportAnnotations({ annotList?, useDisplayAuthor? })`,
+  `setCurrentUser(name, id?)`, `setReadOnly(bool)`, `canEdit(annotation)`,
+  `addEventListener('annotationChanged', ({ annotations, action, imported }) => …)`.
 - `destroy()` — unmount (imperative API) and release every listener.
 - `UI.*` / `Core.*` — legacy facades (`UI.openElements`, `UI.fitWidth`,
   `Core.annotationManager.exportAnnotations()`, `Core.documentViewer.getDocument().getFileData()`).
@@ -216,6 +229,13 @@ src/
 └── demo/                 # demo & iframe-package bootstrap (not published)
 ```
 
+### Releasing
+
+1. Bump `version` in `package.json` + add a `CHANGELOG.md` entry, merge to `main`.
+2. Either push a tag `vX.Y.Z` on that commit, or run the **Publish to npm** workflow manually
+   with the ref to publish. The workflow re-runs the full verification chain, checks the version
+   is not already on the registry, and publishes with provenance (needs the `NPM_TOKEN` secret).
+
 ### Iframe package (script-tag hosts)
 
 `npm run build:app` produces a self-contained viewer; `public/webviewer.js` wraps it in an iframe

package/dist/src/annotations/AnnotationManager.d.ts

@@ -0,0 +1,90 @@
+import { PDFDocumentProxy } from 'pdfjs-dist';
+import { Annotation, AnnotationInput } from './types';
+import { XfdfExportOptions } from './xfdf';
+export type AnnotationAction = 'add' | 'modify' | 'delete';
+export interface AnnotationChangedEvent {
+    annotations: Annotation[];
+    action: AnnotationAction;
+    /** True when the change came from importAnnotations()/programmatic APIs flagged as imported. */
+    imported: boolean;
+}
+export interface CommitOptions {
+    /** Mark the change as an import round-trip (not persisted by host bridges, not undoable). */
+    imported?: boolean;
+    /** Bypass read-only / authorship checks (programmatic host operations). */
+    force?: boolean;
+    /** Record in the undo history (default: true unless imported). */
+    undoable?: boolean;
+}
+export interface ViewerUserInfo {
+    id?: string;
+    name?: string;
+}
+type ChangedListener = (event: AnnotationChangedEvent) => void;
+export declare class AnnotationManager {
+    private list;
+    private past;
+    private future;
+    private changedListeners;
+    private listListeners;
+    private user;
+    private readOnly;
+    private canEditOthers;
+    private resolver;
+    setDocument(doc: PDFDocumentProxy | null): void;
+    hasDocument(): boolean;
+    setCurrentUser(name: string, id?: string): void;
+    setCurrentUserInfo(user: ViewerUserInfo | undefined): void;
+    getCurrentUser(): string;
+    getCurrentUserInfo(): ViewerUserInfo;
+    setReadOnly(readOnly: boolean): void;
+    isReadOnly(): boolean;
+    /** Allow editing/deleting annotations authored by other users (default false). */
+    setCanEditOthers(value: boolean): void;
+    /** Whether the current user may modify or delete this annotation through the UI. */
+    canEdit(a: Annotation): boolean;
+    canAdd(): boolean;
+    /** The current list. The array reference is stable until the next change. */
+    getAnnotationsList(): Annotation[];
+    getAnnotationById(id: string): Annotation | undefined;
+    /** React `useSyncExternalStore` pair. */
+    subscribe: (listener: () => void) => (() => void);
+    getSnapshot: () => Annotation[];
+    addEventListener(type: 'annotationChanged', listener: ChangedListener): () => void;
+    removeEventListener(type: 'annotationChanged', listener: ChangedListener): void;
+    /** Apryse-compat no-op: React re-renders from the list. */
+    drawAnnotationsFromList(_annotations: Annotation[]): void;
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+    undo(): boolean;
+    redo(): boolean;
+    /**
+     * Replace the whole list (the UI's edit path). Diffs against the current list, enforces
+     * permissions (rejected edits keep the previous version), records history and emits one
+     * `annotationChanged` event per action.
+     */
+    commit(next: Annotation[], opts?: CommitOptions): Annotation[];
+    addAnnotations(inputs: AnnotationInput[], opts?: CommitOptions): Annotation[];
+    updateAnnotation(id: string, patch: Partial<AnnotationInput>, opts?: CommitOptions): Annotation | undefined;
+    deleteAnnotations(targets: Array<Annotation | string>, opts?: CommitOptions): void;
+    /** Remove every annotation (e.g. on document switch). Not undoable, emits deletes as imported. */
+    clear(): void;
+    /**
+     * Import an XFDF document or bare fragments. Annotations whose `name` already exists are
+     * replaced (modify), new ones added; the change is flagged `imported` and is not undoable.
+     * Returns the imported annotations as they now exist in the list.
+     */
+    importAnnotations(xfdf: string): Promise<Annotation[]>;
+    /**
+     * Export as XFDF. With `annotList`, returns the bare fragment(s) for those annotations (the
+     * form hosts persist per annotation); without it, a complete XFDF document.
+     */
+    exportAnnotations(opts?: XfdfExportOptions): Promise<string>;
+    /** Legacy bespoke JSON export (pre-1.2 `exportAnnotations()` shape). */
+    exportAnnotationsLegacyJson(): string;
+    private requireResolver;
+    private apply;
+    private stampNew;
+    private emit;
+}
+export {};

package/dist/src/annotations/geometry.d.ts

@@ -0,0 +1,51 @@
+import { PDFDocumentProxy, PDFPageProxy } from 'pdfjs-dist';
+export type Matrix = [number, number, number, number, number, number];
+export interface PageGeometry {
+    /** 1-based page number */
+    pageNumber: number;
+    /** PDF user-space bounding box [x0, y0, x1, y1] (the CropBox pdf.js renders). */
+    viewBox: [number, number, number, number];
+    /** Intrinsic page rotation (/Rotate), normalized to 0/90/180/270. */
+    rotate: number;
+    /** Base page size in points (already swapped for 90/270). */
+    width: number;
+    height: number;
+    /** Base-space (viewer) -> PDF user-space transform is the inverse of this viewport transform. */
+    transform: Matrix;
+}
+export interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface Point {
+    x: number;
+    y: number;
+}
+/** PDF rectangle as XFDF writes it: [llx, lly, urx, ury]. */
+export type PdfRect = [number, number, number, number];
+/** Build the geometry for a page from its viewBox and intrinsic rotation (mirrors pdf.js PageViewport at scale 1). */
+export declare function createPageGeometry(pageNumber: number, viewBox: [number, number, number, number], rotate: number): PageGeometry;
+export declare function geometryFromPage(page: PDFPageProxy): PageGeometry;
+/** Small per-document cache so callers can resolve geometry for many annotations cheaply. */
+export declare function createGeometryResolver(pdfDoc: PDFDocumentProxy): (pageNumber: number) => Promise<PageGeometry>;
+export type GeometryResolver = (pageNumber: number) => Promise<PageGeometry>;
+export declare function toPdfPoint(g: PageGeometry, p: Point): Point;
+export declare function fromPdfPoint(g: PageGeometry, p: Point): Point;
+/** Viewer rect (top-left origin) -> PDF rect [llx, lly, urx, ury]. */
+export declare function rectToPdf(g: PageGeometry, r: Rect): PdfRect;
+/** PDF rect [llx, lly, urx, ury] -> viewer rect (top-left origin). */
+export declare function rectFromPdf(g: PageGeometry, r: PdfRect): Rect;
+export declare function pathToPdf(g: PageGeometry, points: Point[]): Point[];
+export declare function pathFromPdf(g: PageGeometry, points: Point[]): Point[];
+/**
+ * XFDF QuadPoints for a viewer rect: x1,y1 (upper-left) x2,y2 (upper-right) x3,y3 (lower-left)
+ * x4,y4 (lower-right) in PDF space — the order Acrobat and Apryse write for text markup.
+ */
+export declare function rectToQuadPoints(g: PageGeometry, r: Rect): number[];
+/** Bounding viewer rect of one or more XFDF quads (8 numbers each). */
+export declare function quadPointsToRects(g: PageGeometry, quads: number[]): Rect[];
+export declare function unionRects(rects: Rect[]): Rect;
+/** Round to 3 decimals for XFDF output (Apryse writes 3, Acrobat up to 6). */
+export declare const fmt: (n: number) => string;

package/dist/src/annotations/ids.d.ts

@@ -0,0 +1,6 @@
+/**
+ * © 2026 AngelBot Ai Pvt Ltd. All rights reserved.
+ * Stable, collision-free annotation ids. They double as the XFDF `name` attribute, which hosts use
+ * to match persisted rows to live annotations, so they must never be timestamps.
+ */
+export declare function newAnnotationId(): string;

package/dist/src/annotations/types.d.ts

@@ -6,7 +6,13 @@
  * /Rotate applied (top-left origin, PDF points). UI rotation applied by the viewer is composed on
  * top of this space at render time, so stored annotations are independent of the current view.
  */
-export type AnnotationType = 'rectangle' | 'ellipse' | 'line' | 'arrow' | 'freehand' | 'text' | 'note' | 'callout' | 'signature' | 'highlight' | 'digital_signature_placeholder' | 'link';
+export type AnnotationType = 'rectangle' | 'ellipse' | 'line' | 'arrow' | 'freehand' | 'text' | 'note' | 'callout' | 'signature' | 'highlight' | 'digital_signature_placeholder' | 'link'
+/**
+ * An annotation imported from XFDF that this viewer cannot edit or render natively (e.g.
+ * underline, squiggly, polygon, redaction). It is drawn as a read-only outline at its bounding
+ * box and re-exported verbatim (`rawXfdf`) so nothing is lost on a save round-trip.
+ */
+ | 'opaque';
 export interface AnnotationPoint {
     x: number;
     y: number;
@@ -42,4 +48,25 @@ export interface Annotation {
     authorId?: string;
     /** When true the annotation cannot be moved, edited or deleted in the UI. */
     readOnly?: boolean;
+    /** Multi-stroke ink (each stroke a polyline). `points` holds the first stroke for legacy consumers. */
+    strokes?: AnnotationPoint[][];
+    /** ISO-8601 timestamps (XFDF creationdate / date). */
+    createdAt?: string;
+    modifiedAt?: string;
+    /** Subject / XFDF element name of an opaque annotation (informational). */
+    opaqueKind?: string;
+    /** Verbatim XFDF element for `opaque` annotations. */
+    rawXfdf?: string;
+    /**
+     * XFDF attributes and child elements this viewer does not model (e.g. Apryse `trn-custom-data`,
+     * `defaultappearance`). Preserved on import and re-emitted on export so other viewers keep
+     * their metadata across a round-trip.
+     */
+    xfdfExtras?: {
+        attrs?: Record<string, string>;
+        children?: string[];
+    };
 }
+export type AnnotationInput = Omit<Annotation, 'id'> & {
+    id?: string;
+};

package/dist/src/annotations/xfdf.d.ts

@@ -0,0 +1,18 @@
+import { Annotation } from './types';
+import { GeometryResolver } from './geometry';
+export declare const XFDF_NS = "http://ns.adobe.com/xfdf/";
+export interface XfdfExportOptions {
+    /** Annotations to serialize (default: all given). */
+    annotList?: Annotation[];
+    /** Write the author's display name into `title` (default true). */
+    useDisplayAuthor?: boolean;
+}
+/** ISO-8601 -> PDF date `D:YYYYMMDDHHmmSS+HH'mm'`. */
+export declare function toPdfDate(iso: string | undefined): string;
+/** PDF date -> ISO-8601 (best effort; returns undefined when unparseable). */
+export declare function fromPdfDate(pdf: string | null | undefined): string | undefined;
+/** Serialize one annotation to an XFDF element (no envelope). */
+export declare function annotationToXfdfFragment(a: Annotation, resolve: GeometryResolver, opts?: XfdfExportOptions): Promise<string>;
+/** Serialize annotations to a complete XFDF document. */
+export declare function annotationsToXfdf(annotations: Annotation[], resolve: GeometryResolver, opts?: XfdfExportOptions): Promise<string>;
+export declare function parseXfdf(xml: string, resolve: GeometryResolver): Promise<Annotation[]>;

package/dist/src/components/DocumentViewer.d.ts

@@ -1,5 +1,6 @@
 import { default as React } from 'react';
 import { Annotation } from '../annotations/types';
+import { AnnotationManager } from '../annotations/AnnotationManager';
 import { Redaction, WatermarkOptions, SDKPermissions, PdfAssetPaths } from '../core/types';
 import * as pdfjsLib from 'pdfjs-dist';
 export interface DocumentLoadErrorInfo {
@@ -10,6 +11,8 @@ interface DocumentViewerProps {
     leftSidebarOpen: boolean;
     rightSidebarOpen: boolean;
     activeTab: string;
+    /** Canonical annotation list, history, permissions and XFDF (owned by the viewer instance). */
+    annotationManager: AnnotationManager;
     initialDoc?: string;
     /** Bump to force a reload of the same URL (retry after a load error). */
     loadNonce?: number;
@@ -43,5 +46,5 @@ interface DocumentViewerProps {
     initialPage?: number;
     permissions?: SDKPermissions;
 }
-export default function DocumentViewer({ leftSidebarOpen, rightSidebarOpen, activeTab, initialDoc, loadNonce, withCredentials, assets, sidebars, redactions, regexRedactions, scale, setScale, sidebarTab, setSidebarTab, onAnnotationsChange, onRedactionsChange, onDocumentLoaded, onLoadError, onFirstPageRendered, onPageChange, pageTransition, pageLayout, rotation, setRotation, watermark, watermarkText, enableAnnotations: _enableAnnotations, initialPage, permissions }: DocumentViewerProps): React.JSX.Element;
+export default function DocumentViewer({ leftSidebarOpen, rightSidebarOpen, activeTab, annotationManager, initialDoc, loadNonce, withCredentials, assets, sidebars, redactions, regexRedactions, scale, setScale, sidebarTab, setSidebarTab, onAnnotationsChange, onRedactionsChange, onDocumentLoaded, onLoadError, onFirstPageRendered, onPageChange, pageTransition, pageLayout, rotation, setRotation, watermark, watermarkText, enableAnnotations: _enableAnnotations, initialPage, permissions }: DocumentViewerProps): React.JSX.Element;
 export {};

package/dist/src/components/Header.d.ts

@@ -16,6 +16,7 @@ interface HeaderProps {
     onDownload: () => void;
     onFullScreen: () => void;
     onSaveAs: () => void;
+    onPrint?: () => void;
     onOpenSettings: () => void;
     onOpenAbout: () => void;
     onOpenSidebarTab: (tab: 'Comments' | 'Search') => void;
@@ -31,5 +32,5 @@ interface HeaderProps {
     plugins?: ViewerPlugin[];
     permissions?: SDKPermissions;
 }
-export default function Header({ activeTab, setActiveTab, leftSidebarOpen, setLeftSidebarOpen, rightSidebarOpen, setRightSidebarOpen: _setRightSidebarOpen, sidebarTab, scale, onZoomIn, onZoomOut, onZoomSet, onDownload, onFullScreen, onSaveAs, onOpenSettings, onOpenAbout, onOpenSidebarTab, pageTransition, setPageTransition, pageLayout, setPageLayout, rotation, setRotation, signatureCount, enableAnnotations, enableSign, plugins, permissions }: HeaderProps): React.JSX.Element;
+export default function Header({ activeTab, setActiveTab, leftSidebarOpen, setLeftSidebarOpen, rightSidebarOpen, setRightSidebarOpen: _setRightSidebarOpen, sidebarTab, scale, onZoomIn, onZoomOut, onZoomSet, onDownload, onFullScreen, onSaveAs, onPrint, onOpenSettings, onOpenAbout, onOpenSidebarTab, pageTransition, setPageTransition, pageLayout, setPageLayout, rotation, setRotation, signatureCount, enableAnnotations, enableSign, plugins, permissions }: HeaderProps): React.JSX.Element;
 export {};

package/dist/src/core/ViewerInstance.d.ts

@@ -1,6 +1,7 @@
 import { ViewerBus } from './eventBus';
 import { ExportOptions } from './export';
 import { Annotation } from '../annotations/types';
+import { AnnotationManager } from '../annotations/AnnotationManager';
 import { Redaction, WatermarkOptions, ViewerEventMap, ViewerEventType } from './types';
 /**
  * © 2026 AngelBot Ai Pvt Ltd. All rights reserved.
@@ -23,12 +24,14 @@ export interface ViewerBinding {
 }
 export declare class WebViewerInstance {
     readonly bus: ViewerBus;
+    /** Annotation list, history, permissions and XFDF import/export. */
+    readonly annotationManager: AnnotationManager;
     /** Root element of the viewer once mounted. */
     element: HTMLElement | null;
     private binding;
     private unmountRoot;
     private destroyed;
-    constructor(bus: ViewerBus);
+    constructor(bus: ViewerBus, annotationManager?: AnnotationManager);
     /** @internal */
     _bind(binding: ViewerBinding, element: HTMLElement | null): void;
     /** @internal */
@@ -54,6 +57,8 @@ export declare class WebViewerInstance {
     getCurrentPage(): number;
     getPageCount(): number;
     getAnnotations(): Annotation[];
+    /** Print the exported document (annotations, redactions and watermark baked in). */
+    print(): void;
     /**
      * Build the exported PDF (annotations + watermark baked, redacted pages rasterized).
      * Uses the bytes of the loaded document; never re-fetches the URL.
@@ -74,11 +79,8 @@ export declare class WebViewerInstance {
         fitToPage: () => void;
     };
     readonly Core: {
-        annotationManager: {
-            /** Legacy: returns the bespoke JSON annotation list. XFDF import/export arrives in 1.2.0. */
-            exportAnnotations: () => string;
-            getAnnotationsList: () => Annotation[];
-        };
+        /** The real AnnotationManager (XFDF import/export, granular events, permissions). */
+        readonly annotationManager: AnnotationManager;
         documentViewer: {
             addEventListener: (event: string, callback: (detail: unknown) => void) => (() => void);
             removeEventListener: (event: string, callback: (detail: unknown) => void) => void;

package/dist/src/core/export.d.ts

@@ -1,10 +1,13 @@
 import { Annotation } from '../annotations/types';
 import { Redaction, WatermarkOptions } from './types';
+import { GeometryResolver } from '../annotations/geometry';
 /** Refuse to build documents larger than this in the browser (memory safety). */
 export declare const MAX_EXPORT_BYTES: number;
 export interface ExportInput {
     /** Returns the original document bytes (prefer `pdfDocument.getData()`). */
     getSourceBytes: () => Promise<Uint8Array | ArrayBuffer>;
+    /** Page geometry resolver (from the loaded pdf.js document). Derived from the bytes when absent. */
+    getPageGeometry?: GeometryResolver;
     annotations: Annotation[];
     redactions: Redaction[];
     watermark?: WatermarkOptions;
@@ -14,7 +17,7 @@ export interface ExportInput {
 export interface ExportOptions {
     /** Bake exactly these annotations instead of the live list. */
     explicitAnnotations?: Annotation[];
-    /** Accepted for API compatibility. Honoured from 1.2.0 (native XFDF import). */
+    /** Accepted for API compatibility; annotations are always taken from the live list / explicitAnnotations. */
     xfdfString?: string;
 }
 export declare function buildPdfBytes(input: ExportInput, options?: ExportOptions): Promise<Uint8Array>;

package/dist/src/core/print.d.ts

@@ -0,0 +1,12 @@
+/**
+ * © 2026 AngelBot Ai Pvt Ltd. All rights reserved.
+ * Printing: the exported document (annotations / redactions / watermark baked in) is loaded into a
+ * hidden iframe and printed through the browser's PDF viewer. Falls back to opening the PDF in a
+ * new tab when the frame cannot print (e.g. the browser has no inline PDF viewer).
+ */
+export interface PrintOptions {
+    title?: string;
+    /** How long the hidden frame is kept alive for the print dialog (default 60s). */
+    timeoutMs?: number;
+}
+export declare function printPdfBytes(bytes: Uint8Array, opts?: PrintOptions): Promise<void>;

package/dist/src/core/types.d.ts

@@ -1,5 +1,6 @@
 import { ViewerPlugin } from '../plugins/types';
 import { Annotation } from '../annotations/types';
+import { AnnotationChangedEvent } from '../annotations/AnnotationManager';
 import { PdfAssetPaths } from './pdfAssets';
 export type { PdfAssetPaths };
 export interface Redaction {
@@ -24,6 +25,8 @@ export interface SDKPermissions {
     canEditAnnotations?: boolean;
     canDeleteAnnotations?: boolean;
     canRedact?: boolean;
+    /** Allow editing/deleting annotations authored by other users (default false). */
+    canEditOthers?: boolean;
 }
 export interface ViewerUser {
     id: string;
@@ -95,6 +98,8 @@ export interface ViewerEventMap {
     annotationsChanged: {
         annotations: Annotation[];
     };
+    /** Granular add / modify / delete (with the `imported` flag) from the AnnotationManager. */
+    annotationChanged: AnnotationChangedEvent;
     toolChanged: {
         tool: string | null;
     };

package/dist/src/index.d.ts

@@ -16,5 +16,14 @@ export type { BusListener } from './core/eventBus';
 export { buildPdfBytes, MAX_EXPORT_BYTES } from './core/export';
 export type { ExportInput, ExportOptions } from './core/export';
 export type { WebViewerOptions, Redaction, WatermarkOptions, SDKPermissions, ViewerUser, InitialScale, ViewerEventMap, ViewerEventType, } from './core/types';
-export type { Annotation, AnnotationType, AnnotationPoint } from './annotations/types';
+export type { Annotation, AnnotationType, AnnotationPoint, AnnotationInput } from './annotations/types';
+export { AnnotationManager } from './annotations/AnnotationManager';
+export type { AnnotationAction, AnnotationChangedEvent, CommitOptions, ViewerUserInfo } from './annotations/AnnotationManager';
+export { newAnnotationId } from './annotations/ids';
+export { createPageGeometry, geometryFromPage, createGeometryResolver, toPdfPoint, fromPdfPoint, rectToPdf, rectFromPdf, rectToQuadPoints, quadPointsToRects, } from './annotations/geometry';
+export type { PageGeometry, GeometryResolver, PdfRect, Rect, Point } from './annotations/geometry';
+export { annotationsToXfdf, annotationToXfdfFragment, parseXfdf, toPdfDate, fromPdfDate, XFDF_NS } from './annotations/xfdf';
+export type { XfdfExportOptions } from './annotations/xfdf';
+export { printPdfBytes } from './core/print';
+export type { PrintOptions } from './core/print';
 export * from './plugins/types';