@arbidocs/react 0.5.111 → 0.5.112

package/dist/annotations/index.d.cts

@@ -1,360 +0,0 @@
-import { A as Annotation, e as RedactionStatus, d as CommentReply, b as AnnotationLayer, N as NormRect } from '../model.d-CNtRWKVK.cjs';
-export { a as AnnotationKind, c as AnnotationLayerError, B as BoxAnnotation, C as CommentAnnotation, H as HighlightAnnotation, L as LAYER_SCHEMA_VERSION, R as RedactionAnnotation, S as StampAnnotation, f as annotationRects, g as clampRect, h as emptyLayer, i as isEffectiveRedaction, p as parseAnnotation, j as parseLayer } from '../model.d-CNtRWKVK.cjs';
-import { A as AnnotationStore } from '../store.d-GADDvC7w.cjs';
-export { a as AnnotationStoreOfflineError, c as createLocalStorageStore, b as createMemoryStore } from '../store.d-GADDvC7w.cjs';
-import * as React from 'react';
-import { ReactNode } from 'react';
-export { P as ProductionChoices, a as ProductionCorner, b as ProductionDialog, c as ProductionDialogProps, d as ProductionDocument, m as moveItem, q as qrCornerFor } from '../ProductionDialog.d-CpzslFn0.cjs';
-
-/**
- * Pure state for an annotation layer: actions, a reducer and undo/redo history.
- *
- * No clock and no randomness in here. Callers pass ids and timestamps in, so the reducer is
- * deterministic, trivially testable, and an agent can replay the same actions a person makes.
- */
-
-/** Fields a caller may change on any mark. Identity (`id`, `kind`, `page`) is fixed. */
-type PatchOf<A> = A extends Annotation ? Partial<Omit<A, 'id' | 'kind' | 'page' | 'createdAt'>> : never;
-type AnnotationPatch = PatchOf<Annotation>;
-type AnnotationAction = {
-    type: 'add';
-    annotation: Annotation;
-} | {
-    type: 'addMany';
-    annotations: Annotation[];
-} | {
-    type: 'update';
-    id: string;
-    patch: AnnotationPatch;
-    now: string;
-} | {
-    type: 'remove';
-    id: string;
-    now: string;
-} | {
-    type: 'setRedactionStatus';
-    ids: string[];
-    status: RedactionStatus;
-    now: string;
-    /** Who reviewed it; recorded with the time for approve/reject, cleared for pending. */
-    by?: string;
-} | {
-    type: 'reply';
-    id: string;
-    reply: CommentReply;
-    now: string;
-} | {
-    type: 'resolve';
-    id: string;
-    resolved: boolean;
-    now: string;
-} | {
-    type: 'replaceAll';
-    layer: AnnotationLayer;
-};
-interface LayerHistory {
-    present: AnnotationLayer;
-    past: AnnotationLayer[];
-    future: AnnotationLayer[];
-}
-declare function createHistory(layer: AnnotationLayer): LayerHistory;
-/** Apply one action to a layer. Returns the same object when nothing changed. */
-declare function reduceLayer(layer: AnnotationLayer, action: AnnotationAction): AnnotationLayer;
-/** Apply an action and record it for undo. A no-op action leaves history untouched. */
-declare function applyAction(history: LayerHistory, action: AnnotationAction): LayerHistory;
-declare function undo(history: LayerHistory): LayerHistory;
-declare function redo(history: LayerHistory): LayerHistory;
-declare const canUndo: (h: LayerHistory) => boolean;
-declare const canRedo: (h: LayerHistory) => boolean;
-declare function annotationsOnPage(layer: AnnotationLayer, page: number): Annotation[];
-declare function pendingRedactions(layer: AnnotationLayer): Annotation[];
-
-/**
- * Merging two writers' versions of one layer, by annotation id (a PDF annotation's `/NM`).
- *
- * Used when a save is refused because someone saved first (HTTP 409): the client re-reads the
- * latest layer ("theirs") and merges it with its own ("mine"), relative to the layer both started
- * from ("base"). Nobody's marks are lost:
- *
- * - a mark only one side has is kept, unless that side never had it and the other deleted it:
- *   a mark in `base` that `mine` no longer has was deleted here and stays deleted, and one that
- *   `theirs` no longer has was deleted there and stays deleted unless it was edited here since;
- * - a mark both sides have: the later edit (`updatedAt`) wins as a whole; a comment additionally
- *   keeps every reply either side added;
- * - `deleted` (the ids this session removed, its tombstones) always wins: a concurrent edit
- *   elsewhere does not resurrect a mark deleted here, even one `base` never saw.
- */
-
-interface MergeInput {
-    /** The layer both sides started from (the last one this client saved or loaded). */
-    base: AnnotationLayer | null;
-    mine: AnnotationLayer;
-    theirs: AnnotationLayer;
-    /** Ids this session deleted. */
-    deleted?: ReadonlySet<string>;
-}
-/** Merge two versions of a layer; the result keeps `mine`'s order, then marks only `theirs` has. */
-declare function mergeLayers({ base, mine, theirs, deleted }: MergeInput): AnnotationLayer;
-/** True when two layers hold the same marks (by id and last edit), whatever their order. */
-declare function sameMarks(a: AnnotationLayer, b: AnnotationLayer): boolean;
-
-/**
- * The redaction log of a layer: one CSV row per redaction mark (page, reason, status, who approved
- * it and when), the record a privilege or redaction log is built from.
- *
- * It never carries the redacted text: the log travels with the redacted copy, so it must not undo
- * it. Rows are in reading order (page, then top to bottom, then left to right).
- */
-
-declare const REDACTION_LOG_COLUMNS: readonly ["page", "reason", "status", "approved_by", "time"];
-interface RedactionLogRow {
-    page: number;
-    reason: string;
-    /** What the frozen copy shows for this mark. */
-    status: 'redacted (approved)' | 'redacted (not reviewed)' | 'not redacted (rejected)';
-    /** Who approved it; empty when it was not approved. */
-    approvedBy: string;
-    /** When it was reviewed, or when it was made if nobody reviewed it (ISO). */
-    time: string;
-}
-declare function redactionLogRows(layer: AnnotationLayer): RedactionLogRow[];
-/** The log as CSV text (header row first, CRLF line ends as RFC 4180 has them). */
-declare function redactionLogCsv(layer: AnnotationLayer): string;
-
-/**
- * Geometry helpers: pixels <-> fractions of the displayed page, and turning a text selection's
- * many client rects into tidy line boxes.
- */
-
-interface PixelRect {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}
-interface PixelSize {
-    width: number;
-    height: number;
-}
-declare function toNorm(r: PixelRect, page: PixelSize): NormRect;
-declare function toPixels(r: NormRect, page: PixelSize): PixelRect;
-/** A drag from `a` to `b` (any direction), as a normalised rectangle. */
-declare function dragToNorm(a: {
-    x: number;
-    y: number;
-}, b: {
-    x: number;
-    y: number;
-}, page: PixelSize): NormRect;
-declare function isTooSmall(r: NormRect): boolean;
-declare function containsPoint(r: NormRect, x: number, y: number): boolean;
-declare function intersects(a: NormRect, b: NormRect): boolean;
-/**
- * Collapse a selection's client rects into one box per text line. Browsers return a rect per
- * text node or span, often overlapping and with sub-pixel gaps; merging rects that share a line
- * and touch (or nearly touch) horizontally gives a clean, even highlight. Rects that sit on
- * different lines are left alone. Input is in the page's pixel space.
- */
-declare function mergeLineRects(input: PixelRect[], gap?: number): PixelRect[];
-
-/**
- * The contract between the annotation state (`useAnnotationLayer`) and the UI that draws it
- * (`AnnotationPageOverlay`, `AnnotationToolbar`). Components take a controller as a prop and hold
- * no annotation state of their own beyond transient drags.
- */
-
-type AnnotationTool = 'select' | 'highlight' | 'box' | 'comment' | 'stamp' | 'redact-area' | 'redact-text';
-/** Tools that colour what they make. */
-type ColoredTool = 'highlight' | 'box' | 'stamp';
-interface ToolSettings {
-    colors: Record<ColoredTool, string>;
-    stampLabel: string;
-    /** The stamp tool places this picture (one's saved signature or initials) instead of a label. */
-    stampImage: {
-        image: string;
-        label: string;
-    } | null;
-    redactionReason: string;
-    /** Box outline width in points. */
-    strokeWidth: number;
-}
-declare const DEFAULT_SETTINGS: ToolSettings;
-declare const HIGHLIGHT_COLORS: string[];
-declare const MARK_COLORS: string[];
-declare const STAMP_PRESETS: string[];
-declare const REDACTION_REASONS: string[];
-/** A mark as the UI describes it: identity, author and timestamps are added by the controller. */
-type NewMark = Annotation extends infer A ? A extends Annotation ? Omit<A, 'id' | 'author' | 'createdAt' | 'updatedAt'> : never : never;
-type LayerStatus = 'loading' | 'ready' | 'error';
-interface AnnotationController {
-    layer: AnnotationLayer;
-    status: LayerStatus;
-    /** The last load, save or validation failure, for the UI to show. */
-    error: string | null;
-    saving: boolean;
-    /** True when edits have not reached the store yet. */
-    dirty: boolean;
-    /** The device is offline (or the store unreachable): edits are kept and saved when it is back. */
-    offline: boolean;
-    /** View only (e.g. a guest on a shared document): marks show, nothing can be changed. */
-    readOnly: boolean;
-    author: string;
-    tool: AnnotationTool;
-    setTool(tool: AnnotationTool): void;
-    settings: ToolSettings;
-    setSettings(patch: Partial<ToolSettings>): void;
-    selectedId: string | null;
-    select(id: string | null): void;
-    add(mark: NewMark): string | null;
-    /** Add several marks as ONE undo step (e.g. a selection spanning pages). */
-    addMany(marks: NewMark[]): string[];
-    update(id: string, patch: AnnotationPatch): void;
-    remove(id: string): void;
-    setRedactionStatus(ids: string[], status: RedactionStatus): void;
-    reply(id: string, body: string): void;
-    resolve(id: string, resolved: boolean): void;
-    undo(): void;
-    redo(): void;
-    canUndo: boolean;
-    canRedo: boolean;
-    /** Write to the store now (before leaving the page). */
-    flush(): Promise<void>;
-}
-/** The save state in words, as the toolbar shows it. */
-declare function layerStatusText(controller: AnnotationController): string;
-
-/**
- * Annotation state for one document: loads its layer from a store, applies edits through the pure
- * reducer (so undo/redo is exact), and saves back after a short pause.
- *
- * Edits are applied from a ref, not inside a React state updater, so a mark that fails validation
- * is reported through `error` instead of throwing during render.
- *
- * With a shared store (other people edit the same layer) a save may come back merged with their
- * marks, and `pull` brings in their changes while this user is idle. Either way the remote layer is
- * REBASED in: the edits made here since are replayed on top of it with `mergeLayers`, and so is
- * every undo/redo step, so undoing never removes a colleague's mark or brings back one they deleted.
- */
-
-declare const AUTOSAVE_MS = 600;
-/** After a failed save, try again this much later (while edits are still unsaved). */
-declare const RETRY_MS = 10000;
-interface UseAnnotationLayerOptions {
-    documentId: string;
-    store: AnnotationStore;
-    /** Display name recorded as the author of new marks. */
-    author: string;
-    autosaveMs?: number;
-    /** View only: marks are shown and comments can be read, nothing can be changed. */
-    readOnly?: boolean;
-    /** False while the device is offline: edits are kept and saved when it comes back. */
-    online?: boolean;
-    /** Ask the store for others' changes this often while idle (0 = never). Needs `store.pull`. */
-    pullMs?: number;
-    now?: () => string;
-    makeId?: () => string;
-}
-declare function useAnnotationLayer({ documentId, store, author, autosaveMs, readOnly: readOnlyProp, online, pullMs, now, makeId, }: UseAnnotationLayerOptions): AnnotationController;
-
-/**
- * Turns a text selection made on the page into marks while the highlight or redact-text tool is
- * active. Only a selection that STARTED on a page counts: otherwise text left selected from an
- * earlier gesture would be marked the moment the user clicked a toolbar button.
- *
- * With a mouse the gesture is press, drag, release, so the release marks the selection. A touch
- * selection is different: the user long-presses a word, then drags the handles, and the browser
- * may cancel the pointer instead of releasing it. So for touch the selection is marked once it has
- * stopped changing for a moment. The marks are undoable, and redactions stay pending until reviewed.
- */
-
-declare function useTextSelectionMarks(controller: AnnotationController): void;
-
-/**
- * Turn a text selection into marks. The browser selects over pdf.js's text layer; each page's
- * share of the selection becomes one mark of normalised line boxes (page-relative, zoom-proof).
- *
- * `selectionToPageMarks` is pure so it can be tested without a layout engine; `readSelection`
- * is the thin DOM side that measures a real selection.
- */
-
-/** One page's slice of a selection, in client (viewport) coordinates. */
-interface PageSelection {
-    page: number;
-    /** The page's box on screen. */
-    box: PixelRect;
-    /** Client rects of the selected text on this page. */
-    rects: PixelRect[];
-    text: string;
-}
-interface PageTextMark {
-    page: number;
-    rects: NormRect[];
-    text: string;
-}
-declare function selectionToPageMarks(pages: PageSelection[]): PageTextMark[];
-/** Read the live selection as per-page slices, using the overlays in `root` to find the pages. */
-declare function readSelection(selection: Selection, root?: ParentNode): PageSelection[];
-
-interface AnnotationPageOverlayProps {
-    controller: AnnotationController;
-    pageNumber: number;
-    /** Page width in PDF points, to size strokes like an export. Defaults to US Letter. */
-    pageWidthPt?: number;
-}
-declare function AnnotationPageOverlay({ controller, pageNumber, pageWidthPt, }: AnnotationPageOverlayProps): React.JSX.Element;
-
-/**
- * Pure geometry for moving and resizing a single-rectangle mark. Kept out of the component file so
- * it can be tested and reused without a renderer.
- */
-
-type DragMode = 'move' | 'nw' | 'ne' | 'sw' | 'se';
-/** The single rectangle of a mark that can be moved and resized, or null for multi-rect marks. */
-declare function singleRect(a: Annotation): NormRect | null;
-declare const patchForRect: (a: Annotation, rect: NormRect) => {
-    rects: NormRect[];
-    rect?: undefined;
-} | {
-    rect: NormRect;
-    rects?: undefined;
-};
-/** Move or resize `origin` by a pointer delta given as fractions of the page. */
-declare function dragRect(origin: NormRect, mode: DragMode, dx: number, dy: number): NormRect;
-
-interface AnnotationToolbarProps {
-    controller: AnnotationController;
-    /** Apply the annotations and redactions to a new document copy. */
-    onFreeze?: () => void;
-    /** Extra host actions at the end of the bar (e.g. "Download with markup"). */
-    actions?: ReactNode;
-    className?: string;
-}
-declare function AnnotationToolbar({ controller, onFreeze, actions, className, }: AnnotationToolbarProps): React.JSX.Element;
-
-/** Delete, Escape, undo and redo for the annotation layer. */
-
-/** Delete, Escape, undo and redo, ignoring keystrokes meant for a text field. */
-declare function useAnnotationShortcuts(controller: AnnotationController, enabled?: boolean): void;
-
-interface FreezeChoices {
-    mode: 'vector' | 'image';
-    comments: 'omit' | 'markers' | 'appendix';
-    pendingRedactions: 'error' | 'burn';
-    /** Also save the redaction log (CSV: page, reason, status, approver, time; never the text). */
-    redactionLog: boolean;
-}
-interface FreezeDialogProps {
-    open: boolean;
-    onOpenChange: (open: boolean) => void;
-    controller: AnnotationController;
-    onConfirm: (choices: FreezeChoices) => void;
-    busy?: boolean;
-    progress?: {
-        done: number;
-        total: number;
-    } | null;
-    error?: string | null;
-}
-declare function FreezeDialog({ open, onOpenChange, controller, onConfirm, busy, progress, error, }: FreezeDialogProps): React.JSX.Element;
-
-export { AUTOSAVE_MS, Annotation, type AnnotationAction, type AnnotationController, AnnotationLayer, AnnotationPageOverlay, type AnnotationPageOverlayProps, type AnnotationPatch, AnnotationStore, type AnnotationTool, AnnotationToolbar, type AnnotationToolbarProps, CommentReply, DEFAULT_SETTINGS, type DragMode, type FreezeChoices, FreezeDialog, type FreezeDialogProps, HIGHLIGHT_COLORS, type LayerHistory, type LayerStatus, MARK_COLORS, type MergeInput, type NewMark, NormRect, type PageSelection, type PageTextMark, type PixelRect, type PixelSize, REDACTION_LOG_COLUMNS, REDACTION_REASONS, RETRY_MS, type RedactionLogRow, RedactionStatus, STAMP_PRESETS, type ToolSettings, type UseAnnotationLayerOptions, annotationsOnPage, applyAction, canRedo, canUndo, containsPoint, createHistory, dragRect, dragToNorm, intersects, isTooSmall, layerStatusText, mergeLayers, mergeLineRects, patchForRect, pendingRedactions, readSelection, redactionLogCsv, redactionLogRows, redo, reduceLayer, sameMarks, selectionToPageMarks, singleRect, toNorm, toPixels, undo, useAnnotationLayer, useAnnotationShortcuts, useTextSelectionMarks };