@embedpdf/plugin-annotation 1.0.11 → 1.0.13

package/dist/shared-preact/components/annotations/line.d.ts

@@ -0,0 +1,33 @@
+import { MouseEvent } from '../../../preact/adapter.ts';
+import { Rect, LinePoints, LineEndings, PdfAnnotationBorderStyle } from '@embedpdf/models';
+interface LineProps {
+    /** interior colour */
+    color?: string;
+    /** 0 – 1 */
+    opacity?: number;
+    /** Stroke width in PDF units */
+    strokeWidth: number;
+    /** Stroke colour (falls back to PDFium default black) */
+    strokeColor?: string;
+    /** Stroke style */
+    strokeStyle?: PdfAnnotationBorderStyle;
+    /** Stroke dash array */
+    strokeDashArray?: number[];
+    /** Bounding box of the annotation */
+    rect: Rect;
+    /** Line start / end points (page units) */
+    linePoints: LinePoints;
+    /** Line endings (eg. OpenArrow / Butt) */
+    lineEndings?: LineEndings;
+    /** Current page zoom factor */
+    scale: number;
+    /** Click handler (used for selection) */
+    onClick?: (e: MouseEvent<SVGElement>) => void;
+    /** Whether the annotation is selected */
+    isSelected: boolean;
+}
+/**
+ * Renders a PDF Line annotation as SVG (with arrow/butt endings).
+ */
+export declare function Line({ color, opacity, strokeWidth, strokeColor, strokeStyle, strokeDashArray, rect, linePoints, lineEndings, scale, onClick, isSelected, }: LineProps): JSX.Element;
+export {};

package/dist/shared-preact/components/annotations/polygon-paint.d.ts

@@ -0,0 +1,9 @@
+interface PolygonPaintProps {
+    pageIndex: number;
+    scale: number;
+    pageWidth: number;
+    pageHeight: number;
+    cursor?: string;
+}
+export declare const PolygonPaint: ({ pageIndex, scale, pageWidth, pageHeight, cursor, }: PolygonPaintProps) => import("preact").JSX.Element | null;
+export {};

package/dist/shared-preact/components/annotations/polygon.d.ts

@@ -0,0 +1,17 @@
+import { MouseEvent } from '../../../preact/adapter.ts';
+import { Rect, Position, PdfAnnotationBorderStyle } from '@embedpdf/models';
+interface PolygonProps {
+    rect: Rect;
+    vertices: Position[];
+    color?: string;
+    strokeColor?: string;
+    opacity?: number;
+    strokeWidth: number;
+    strokeStyle?: PdfAnnotationBorderStyle;
+    strokeDashArray?: number[];
+    scale: number;
+    isSelected: boolean;
+    onClick?: (e: MouseEvent<SVGElement>) => void;
+}
+export declare function Polygon({ rect, vertices, color, strokeColor, opacity, strokeWidth, strokeStyle, strokeDashArray, scale, isSelected, onClick, }: PolygonProps): JSX.Element;
+export {};

package/dist/shared-preact/components/annotations/polyline-paint.d.ts

@@ -0,0 +1,10 @@
+interface PolylinePaintProps {
+    pageIndex: number;
+    scale: number;
+    pageWidth: number;
+    pageHeight: number;
+    /** Optional preview cursor */
+    cursor?: string;
+}
+export declare const PolylinePaint: ({ pageIndex, scale, pageWidth, pageHeight, cursor, }: PolylinePaintProps) => import("preact").JSX.Element | null;
+export {};

package/dist/shared-preact/components/annotations/polyline.d.ts

@@ -0,0 +1,17 @@
+import { MouseEvent } from '../../../preact/adapter.ts';
+import { Rect, Position, LineEndings } from '@embedpdf/models';
+interface PolylineProps {
+    rect: Rect;
+    vertices: Position[];
+    color?: string;
+    strokeColor?: string;
+    opacity?: number;
+    strokeWidth: number;
+    scale: number;
+    isSelected: boolean;
+    onClick?: (e: MouseEvent<SVGElement>) => void;
+    /** Optional start & end endings */
+    lineEndings?: LineEndings;
+}
+export declare function Polyline({ rect, vertices, color, strokeColor, opacity, strokeWidth, scale, isSelected, onClick, lineEndings, }: PolylineProps): JSX.Element;
+export {};

package/dist/shared-preact/components/annotations/square-paint.d.ts

@@ -0,0 +1,10 @@
+interface SquarePaintProps {
+    pageIndex: number;
+    scale: number;
+    pageWidth: number;
+    pageHeight: number;
+    /** Optional preview cursor */
+    cursor?: string;
+}
+export declare const SquarePaint: ({ pageIndex, scale, pageWidth, pageHeight, cursor, }: SquarePaintProps) => import("preact").JSX.Element | null;
+export {};

package/dist/shared-preact/components/annotations/square.d.ts

@@ -0,0 +1,29 @@
+import { MouseEvent } from '../../../preact/adapter.ts';
+import { PdfAnnotationBorderStyle, Rect } from '@embedpdf/models';
+interface SquareProps {
+    /** Fill colour – defaults to PDFium’s black if omitted */
+    color?: string;
+    /** Stroke colour – defaults to same as fill when omitted */
+    strokeColor?: string;
+    /** 0 – 1 */
+    opacity?: number;
+    /** Stroke width in PDF units */
+    strokeWidth: number;
+    /** Stroke type – defaults to solid when omitted */
+    strokeStyle?: PdfAnnotationBorderStyle;
+    /** Stroke dash array – defaults to undefined when omitted */
+    strokeDashArray?: number[];
+    /** Bounding box of the annotation (PDF units) */
+    rect: Rect;
+    /** Current page zoom factor */
+    scale: number;
+    /** Click handler (used for selection) */
+    onClick?: (e: MouseEvent<SVGElement>) => void;
+    /** Cursor shown over the annotation */
+    cursor?: string;
+}
+/**
+ * Renders a PDF Square annotation (rectangle) as SVG.
+ */
+export declare function Square({ color, strokeColor, opacity, strokeWidth, strokeStyle, strokeDashArray, rect, scale, onClick, cursor, }: SquareProps): JSX.Element;
+export {};

package/dist/shared-preact/components/annotations.d.ts

@@ -0,0 +1,11 @@
+import { SelectionMenu } from '../types';
+interface AnnotationsProps {
+    pageIndex: number;
+    scale: number;
+    rotation: number;
+    pageWidth: number;
+    pageHeight: number;
+    selectionMenu?: SelectionMenu;
+}
+export declare function Annotations(annotationsProps: AnnotationsProps): import("preact").JSX.Element;
+export {};

package/dist/shared-preact/components/counter-rotate-container.d.ts

@@ -0,0 +1,32 @@
+import { Rect, Rotation } from '@embedpdf/models';
+import { ReactNode, CSSProperties, PointerEvent } from '../../preact/adapter.ts';
+interface CounterRotateProps {
+    rect: Rect;
+    rotation: Rotation;
+}
+interface CounterTransformResult {
+    matrix: string;
+    width: number;
+    height: number;
+}
+/**
+ * Given an already-placed rect (left/top/width/height in px) and the page rotation,
+ * return the counter-rotation matrix + adjusted width/height.
+ *
+ * transform-origin is expected to be "0 0".
+ * left/top DO NOT change, apply them as-is.
+ */
+export declare function getCounterRotation(rect: Rect, rotation: Rotation): CounterTransformResult;
+export interface MenuWrapperProps {
+    style: CSSProperties;
+    onPointerDown: (e: PointerEvent<HTMLDivElement>) => void;
+}
+interface CounterRotateComponentProps extends CounterRotateProps {
+    children: (props: {
+        matrix: string;
+        rect: Rect;
+        menuWrapperProps: MenuWrapperProps;
+    }) => ReactNode;
+}
+export declare function CounterRotate({ children, ...props }: CounterRotateComponentProps): import("preact").JSX.Element;
+export {};

package/dist/shared-preact/components/index.d.ts

@@ -0,0 +1 @@
+export * from './annotation-layer';

package/dist/shared-preact/components/render-annotation.d.ts

@@ -0,0 +1,11 @@
+import { HTMLAttributes, CSSProperties } from '../../preact/adapter.ts';
+import { PdfAnnotationObject } from '@embedpdf/models';
+type RenderAnnotationProps = Omit<HTMLAttributes<HTMLImageElement>, 'style'> & {
+    pageIndex: number;
+    annotation: PdfAnnotationObject;
+    scaleFactor?: number;
+    dpr?: number;
+    style?: CSSProperties;
+};
+export declare function RenderAnnotation({ pageIndex, annotation, scaleFactor, dpr, style, ...props }: RenderAnnotationProps): import("preact").JSX.Element;
+export {};

package/dist/shared-preact/components/resize-handles.d.ts

@@ -0,0 +1,9 @@
+import { ResizeDirection } from '../types';
+import { PointerEvent } from '../../preact/adapter.ts';
+interface Props {
+    rotation: number;
+    outlineOffset?: number;
+    startResize: (d: ResizeDirection) => (e: PointerEvent<HTMLDivElement>) => void;
+}
+export declare function ResizeHandles({ rotation, outlineOffset, startResize }: Props): import("preact").JSX.Element;
+export {};

package/dist/shared-preact/components/text-markup/highlight.d.ts

@@ -0,0 +1,13 @@
+import { HTMLAttributes, CSSProperties, MouseEvent } from '../../../preact/adapter.ts';
+import { Rect } from '@embedpdf/models';
+type HighlightProps = Omit<HTMLAttributes<HTMLDivElement>, 'style'> & {
+    color?: string;
+    opacity?: number;
+    rects: Rect[];
+    rect?: Rect;
+    scale: number;
+    onClick?: (e: MouseEvent<HTMLDivElement>) => void;
+    style?: CSSProperties;
+};
+export declare function Highlight({ color, opacity, rects, rect, scale, onClick, style, ...props }: HighlightProps): import("preact").JSX.Element;
+export {};

package/dist/shared-preact/components/text-markup/squiggly.d.ts

@@ -0,0 +1,13 @@
+import { HTMLAttributes, CSSProperties, MouseEvent } from '../../../preact/adapter.ts';
+import { Rect } from '@embedpdf/models';
+type SquigglyProps = Omit<HTMLAttributes<HTMLDivElement>, 'style'> & {
+    color?: string;
+    opacity?: number;
+    rects: Rect[];
+    rect?: Rect;
+    scale: number;
+    onClick?: (e: MouseEvent<HTMLDivElement>) => void;
+    style?: CSSProperties;
+};
+export declare function Squiggly({ color, opacity, rects, rect, scale, onClick, style, ...props }: SquigglyProps): import("preact").JSX.Element;
+export {};

package/dist/shared-preact/components/text-markup/strikeout.d.ts

@@ -0,0 +1,13 @@
+import { HTMLAttributes, CSSProperties, MouseEvent } from '../../../preact/adapter.ts';
+import { Rect } from '@embedpdf/models';
+type StrikeoutProps = Omit<HTMLAttributes<HTMLDivElement>, 'style'> & {
+    color?: string;
+    opacity?: number;
+    rects: Rect[];
+    rect?: Rect;
+    scale: number;
+    onClick?: (e: MouseEvent<HTMLDivElement>) => void;
+    style?: CSSProperties;
+};
+export declare function Strikeout({ color, opacity, rects, rect, scale, onClick, style, ...props }: StrikeoutProps): import("preact").JSX.Element;
+export {};

package/dist/shared-preact/components/text-markup/underline.d.ts

@@ -0,0 +1,13 @@
+import { HTMLAttributes, CSSProperties, MouseEvent } from '../../../preact/adapter.ts';
+import { Rect } from '@embedpdf/models';
+type UnderlineProps = Omit<HTMLAttributes<HTMLDivElement>, 'style'> & {
+    color?: string;
+    opacity?: number;
+    rects: Rect[];
+    rect?: Rect;
+    scale: number;
+    onClick?: (e: MouseEvent<HTMLDivElement>) => void;
+    style?: CSSProperties;
+};
+export declare function Underline({ color, opacity, rects, rect, scale, onClick, style, ...props }: UnderlineProps): import("preact").JSX.Element;
+export {};

package/dist/shared-preact/components/text-markup.d.ts

@@ -0,0 +1,6 @@
+interface TextMarkupProps {
+    pageIndex: number;
+    scale: number;
+}
+export declare function TextMarkup({ pageIndex, scale }: TextMarkupProps): import("preact").JSX.Element | null;
+export {};

package/dist/shared-preact/components/vertex-editor.d.ts

@@ -0,0 +1,19 @@
+import { JSX } from '../../preact/adapter.ts';
+import { Position, Rect } from '@embedpdf/models';
+export interface VertexEditorProps {
+    /** Bounding box (PDF units) of the annotation            */
+    rect: Rect;
+    /** Page rotation (0-3)                                    */
+    rotation: number;
+    /** Current zoom factor                                   */
+    scale: number;
+    /** Array of vertices in PDF units                        */
+    vertices: Position[];
+    /** Called *every* drag frame with new vertices           */
+    onEdit: (v: Position[]) => void;
+    /** Called once at end of drag to commit changes          */
+    onCommit: (v: Position[]) => void;
+    /** Size of handle in CSS px                              */
+    handleSize?: number;
+}
+export declare function VertexEditor({ rect, rotation, scale, vertices, onEdit, onCommit, handleSize, }: VertexEditorProps): JSX.Element;

package/dist/shared-preact/hooks/index.d.ts

@@ -0,0 +1 @@
+export * from './use-annotation';

package/dist/shared-preact/hooks/use-annotation.d.ts

@@ -0,0 +1,11 @@
+import { AnnotationPlugin } from '../../lib/index.ts';
+export declare const useAnnotationPlugin: () => {
+    plugin: AnnotationPlugin | null;
+    isLoading: boolean;
+    ready: Promise<void>;
+};
+export declare const useAnnotationCapability: () => {
+    provides: Readonly<import('../../lib/index.ts').AnnotationCapability> | null;
+    isLoading: boolean;
+    ready: Promise<void>;
+};

package/dist/shared-preact/hooks/use-drag-resize.d.ts

@@ -0,0 +1,31 @@
+import { PointerEvent } from '../../preact/adapter.ts';
+import { PdfAnnotationObject, Position, Rect } from '@embedpdf/models';
+import { TrackedAnnotation } from '../../lib/index.ts';
+import { ResizeDirection } from '../types';
+import { ComputePatch } from '../patchers';
+interface UseDragResizeOpts<T extends PdfAnnotationObject> {
+    scale: number;
+    pageWidth: number;
+    pageHeight: number;
+    rotation: number;
+    tracked: TrackedAnnotation<T>;
+    isSelected: boolean;
+    isDraggable: boolean;
+    isResizable: boolean;
+    computePatch?: ComputePatch<T>;
+    computeVertices?: (a: T) => Position[];
+    currentRect: Rect;
+    setCurrentRect: (r: Rect) => void;
+    setCurrentVertices: (v: Position[]) => void;
+    setPreviewObject: (p: Partial<T> | null) => void;
+    commit: (patch: Partial<T>) => void;
+}
+export declare function useDragResize<T extends PdfAnnotationObject>({ scale, pageWidth, pageHeight, rotation, tracked, isSelected, isDraggable, isResizable, computePatch, computeVertices, currentRect, setCurrentRect, setCurrentVertices, setPreviewObject, commit, }: UseDragResizeOpts<T>): {
+    rootHandlers: {
+        onPointerDown: (e: PointerEvent<HTMLDivElement>) => void;
+        onPointerMove: (e: PointerEvent<HTMLDivElement>) => void;
+        onPointerUp: () => void;
+    };
+    startResize: (direction: ResizeDirection) => (e: PointerEvent<HTMLDivElement>) => void;
+};
+export {};

package/dist/shared-preact/index.d.ts

@@ -0,0 +1,2 @@
+export * from './hooks';
+export * from './components';

package/dist/shared-preact/patch-ink.d.ts

@@ -0,0 +1,16 @@
+import { PdfInkAnnoObject } from '@embedpdf/models';
+import { ComputePatch } from './patchers';
+/**
+ * Computes a patch for resizing an ink annotation.
+ * - Scales all points in inkList to fit the new rect.
+ * - Scales strokeWidth proportionally (using average scale factor).
+ * - Handles non-uniform scaling (stretch).
+ * - Optionally preserves aspect ratio (set uniform=true).
+ *
+ * @param original The original ink annotation object.
+ * @param newRect The new bounding rect after resize.
+ * @param direction The resize handle direction (affects origin adjustments if needed).
+ * @param uniform If true, constrains to uniform scaling (uses min scale factor).
+ * @returns Partial patch { rect, inkList, strokeWidth } to apply.
+ */
+export declare const patchInk: ComputePatch<PdfInkAnnoObject>;

package/dist/shared-preact/patchers.d.ts

@@ -0,0 +1,9 @@
+import { PdfAnnotationObject, Rect, Position } from '@embedpdf/models';
+import { ResizeDirection } from './types';
+export interface PatchContext {
+    rect: Rect;
+    vertices?: Position[];
+    direction?: ResizeDirection;
+    uniform?: boolean;
+}
+export type ComputePatch<T extends PdfAnnotationObject> = (original: T, ctx: PatchContext) => Partial<T>;

package/dist/shared-preact/types.d.ts

@@ -0,0 +1,12 @@
+import { Rect } from '@embedpdf/models';
+import { TrackedAnnotation } from '../lib/index.ts';
+import { JSX } from '../preact/adapter.ts';
+import { MenuWrapperProps } from './components/counter-rotate-container';
+export type ResizeDirection = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right' | 'none';
+export interface SelectionMenuProps {
+    annotation: TrackedAnnotation;
+    selected: boolean;
+    rect: Rect;
+    menuWrapperProps: MenuWrapperProps;
+}
+export type SelectionMenu = (props: SelectionMenuProps) => JSX.Element;

package/dist/shared-preact/vertex-patchers.d.ts

@@ -0,0 +1,10 @@
+import { PdfAnnotationSubtype, PdfAnnotationObject, PdfLineAnnoObject, PdfPolylineAnnoObject, PdfPolygonAnnoObject, Rect, Position } from '@embedpdf/models';
+export interface PatchContext {
+    rect: Rect;
+    vertices?: Position[];
+}
+export type PatchFn<T extends PdfAnnotationObject> = (original: T, ctx: PatchContext) => Partial<T>;
+export declare const patchLine: PatchFn<PdfLineAnnoObject>;
+export declare const patchPolyline: PatchFn<PdfPolylineAnnoObject>;
+export declare const patchPolygon: PatchFn<PdfPolygonAnnoObject>;
+export declare function getPatchFn(type: PdfAnnotationSubtype): PatchFn<PdfLineAnnoObject> | PatchFn<PdfPolylineAnnoObject> | PatchFn<PdfPolygonAnnoObject> | undefined;

package/dist/shared-react/components/annotation-container.d.ts

@@ -0,0 +1,24 @@
+import { JSX, HTMLAttributes, CSSProperties } from '../../react/adapter.ts';
+import { TrackedAnnotation } from '../../lib/index.ts';
+import { PdfAnnotationObject, Position } from '@embedpdf/models';
+import { SelectionMenuProps } from '../../shared/types';
+import { ComputePatch } from '../patchers';
+type AnnotationContainerProps<T extends PdfAnnotationObject> = Omit<HTMLAttributes<HTMLDivElement>, 'style' | 'children'> & {
+    scale: number;
+    isSelected?: boolean;
+    pageIndex: number;
+    pageWidth: number;
+    pageHeight: number;
+    rotation: number;
+    trackedAnnotation: TrackedAnnotation<T>;
+    children: JSX.Element | ((annotation: T) => JSX.Element);
+    style?: CSSProperties;
+    isDraggable?: boolean;
+    isResizable?: boolean;
+    outlineOffset?: number;
+    selectionMenu?: (props: SelectionMenuProps) => JSX.Element;
+    computeVertices?: (annotation: T) => Position[];
+    computePatch?: ComputePatch<T>;
+};
+export declare function AnnotationContainer<T extends PdfAnnotationObject>({ scale, pageIndex, rotation, pageWidth, pageHeight, trackedAnnotation, children, style, outlineOffset, isSelected, isDraggable, isResizable, computeVertices, computePatch, selectionMenu, ...props }: AnnotationContainerProps<T>): JSX.Element;
+export {};

package/dist/shared-react/components/annotation-layer.d.ts

@@ -0,0 +1,13 @@
+import { HTMLAttributes, CSSProperties } from '../../react/adapter.ts';
+import { SelectionMenu } from '../types';
+type AnnotationLayerProps = Omit<HTMLAttributes<HTMLDivElement>, 'style'> & {
+    pageIndex: number;
+    scale: number;
+    pageWidth: number;
+    pageHeight: number;
+    rotation: number;
+    selectionMenu?: SelectionMenu;
+    style?: CSSProperties;
+};
+export declare function AnnotationLayer({ pageIndex, scale, pageWidth, pageHeight, rotation, selectionMenu, style, ...props }: AnnotationLayerProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared-react/components/annotations/circle-paint.d.ts

@@ -0,0 +1,10 @@
+interface CirclePaintProps {
+    pageIndex: number;
+    scale: number;
+    pageWidth: number;
+    pageHeight: number;
+    /** Optional preview cursor */
+    cursor?: string;
+}
+export declare const CirclePaint: ({ pageIndex, scale, pageWidth, pageHeight, cursor, }: CirclePaintProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/shared-react/components/annotations/circle.d.ts

@@ -0,0 +1,29 @@
+import { MouseEvent } from '../../../react/adapter.ts';
+import { PdfAnnotationBorderStyle, Rect } from '@embedpdf/models';
+interface CircleProps {
+    /** Fill colour – defaults to PDFium’s black if omitted */
+    color?: string;
+    /** Stroke colour – defaults to same as fill when omitted */
+    strokeColor?: string;
+    /** 0 – 1 */
+    opacity?: number;
+    /** Stroke width in PDF units */
+    strokeWidth: number;
+    /** Stroke type – defaults to solid when omitted */
+    strokeStyle?: PdfAnnotationBorderStyle;
+    /** Stroke dash array – defaults to undefined when omitted */
+    strokeDashArray?: number[];
+    /** Bounding box of the annotation */
+    rect: Rect;
+    /** Current page zoom factor */
+    scale: number;
+    /** Click handler (used for selection) */
+    onClick?: (e: MouseEvent<SVGElement>) => void;
+    /** Cursor shown over the annotation */
+    cursor?: string;
+}
+/**
+ * Renders a PDF Circle annotation (ellipse) as SVG.
+ */
+export declare function Circle({ color, strokeColor, opacity, strokeWidth, strokeStyle, strokeDashArray, rect, scale, onClick, cursor, }: CircleProps): JSX.Element;
+export {};

package/dist/shared-react/components/annotations/ink-paint.d.ts

@@ -0,0 +1,17 @@
+interface InkPaintProps {
+    /** Index of the page this layer lives on */
+    pageIndex: number;
+    /** Scale of the page */
+    scale: number;
+    /** Width of the page */
+    pageWidth: number;
+    /** Height of the page */
+    pageHeight: number;
+}
+/**
+ * Allows the user to draw freehand ink annotations.
+ * Hook it into the interaction-manager with modeId = 'inkPaint'.
+ * Supports multi-stroke annotations: if the user starts a new stroke within 3 seconds of releasing the previous one, it adds to the same annotation.
+ */
+export declare const InkPaint: ({ pageIndex, scale, pageWidth, pageHeight }: InkPaintProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/shared-react/components/annotations/ink.d.ts

@@ -0,0 +1,25 @@
+import { MouseEvent } from '../../../react/adapter.ts';
+import { PdfInkListObject, Rect } from '@embedpdf/models';
+interface InkProps {
+    /** Stroke colour (falls back to PDFium default black) */
+    color?: string;
+    /** 0 – 1 */
+    opacity?: number;
+    /** Line width in PDF units */
+    strokeWidth: number;
+    /** Array of strokes — exactly as in your JSON */
+    inkList: PdfInkListObject[];
+    /** Bounding box of the whole annotation */
+    rect: Rect;
+    /** Page zoom factor */
+    scale: number;
+    /** Callback for when the annotation is clicked */
+    onClick?: (e: MouseEvent<SVGPathElement>) => void;
+    /** Cursor on the ink */
+    cursor?: string;
+}
+/**
+ * Renders a PDF Ink annotation (free-hand drawing) as SVG.
+ */
+export declare function Ink({ color, opacity, strokeWidth, inkList, rect, scale, onClick, cursor, }: InkProps): JSX.Element;
+export {};

package/dist/shared-react/components/annotations/line-paint.d.ts

@@ -0,0 +1,10 @@
+interface LinePaintProps {
+    pageIndex: number;
+    scale: number;
+    pageWidth: number;
+    pageHeight: number;
+    /** Optional preview cursor */
+    cursor?: string;
+}
+export declare const LinePaint: ({ pageIndex, scale, pageWidth, pageHeight, cursor }: LinePaintProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/shared-react/components/annotations/line.d.ts

@@ -0,0 +1,33 @@
+import { MouseEvent } from '../../../react/adapter.ts';
+import { Rect, LinePoints, LineEndings, PdfAnnotationBorderStyle } from '@embedpdf/models';
+interface LineProps {
+    /** interior colour */
+    color?: string;
+    /** 0 – 1 */
+    opacity?: number;
+    /** Stroke width in PDF units */
+    strokeWidth: number;
+    /** Stroke colour (falls back to PDFium default black) */
+    strokeColor?: string;
+    /** Stroke style */
+    strokeStyle?: PdfAnnotationBorderStyle;
+    /** Stroke dash array */
+    strokeDashArray?: number[];
+    /** Bounding box of the annotation */
+    rect: Rect;
+    /** Line start / end points (page units) */
+    linePoints: LinePoints;
+    /** Line endings (eg. OpenArrow / Butt) */
+    lineEndings?: LineEndings;
+    /** Current page zoom factor */
+    scale: number;
+    /** Click handler (used for selection) */
+    onClick?: (e: MouseEvent<SVGElement>) => void;
+    /** Whether the annotation is selected */
+    isSelected: boolean;
+}
+/**
+ * Renders a PDF Line annotation as SVG (with arrow/butt endings).
+ */
+export declare function Line({ color, opacity, strokeWidth, strokeColor, strokeStyle, strokeDashArray, rect, linePoints, lineEndings, scale, onClick, isSelected, }: LineProps): JSX.Element;
+export {};

package/dist/shared-react/components/annotations/polygon-paint.d.ts

@@ -0,0 +1,9 @@
+interface PolygonPaintProps {
+    pageIndex: number;
+    scale: number;
+    pageWidth: number;
+    pageHeight: number;
+    cursor?: string;
+}
+export declare const PolygonPaint: ({ pageIndex, scale, pageWidth, pageHeight, cursor, }: PolygonPaintProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/shared-react/components/annotations/polygon.d.ts

@@ -0,0 +1,17 @@
+import { MouseEvent } from '../../../react/adapter.ts';
+import { Rect, Position, PdfAnnotationBorderStyle } from '@embedpdf/models';
+interface PolygonProps {
+    rect: Rect;
+    vertices: Position[];
+    color?: string;
+    strokeColor?: string;
+    opacity?: number;
+    strokeWidth: number;
+    strokeStyle?: PdfAnnotationBorderStyle;
+    strokeDashArray?: number[];
+    scale: number;
+    isSelected: boolean;
+    onClick?: (e: MouseEvent<SVGElement>) => void;
+}
+export declare function Polygon({ rect, vertices, color, strokeColor, opacity, strokeWidth, strokeStyle, strokeDashArray, scale, isSelected, onClick, }: PolygonProps): JSX.Element;
+export {};

package/dist/shared-react/components/annotations/polyline-paint.d.ts

@@ -0,0 +1,10 @@
+interface PolylinePaintProps {
+    pageIndex: number;
+    scale: number;
+    pageWidth: number;
+    pageHeight: number;
+    /** Optional preview cursor */
+    cursor?: string;
+}
+export declare const PolylinePaint: ({ pageIndex, scale, pageWidth, pageHeight, cursor, }: PolylinePaintProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/shared-react/components/annotations/polyline.d.ts

@@ -0,0 +1,17 @@
+import { MouseEvent } from '../../../react/adapter.ts';
+import { Rect, Position, LineEndings } from '@embedpdf/models';
+interface PolylineProps {
+    rect: Rect;
+    vertices: Position[];
+    color?: string;
+    strokeColor?: string;
+    opacity?: number;
+    strokeWidth: number;
+    scale: number;
+    isSelected: boolean;
+    onClick?: (e: MouseEvent<SVGElement>) => void;
+    /** Optional start & end endings */
+    lineEndings?: LineEndings;
+}
+export declare function Polyline({ rect, vertices, color, strokeColor, opacity, strokeWidth, scale, isSelected, onClick, lineEndings, }: PolylineProps): JSX.Element;
+export {};