@poco-ai/agentero-dsh-pdf 0.0.0-stage → 0.1.0

package/lib/client/selection-menu.d.ts

@@ -0,0 +1,30 @@
+import type { PropsLocale } from "@deepseek-ai/dsh-client-ui-slots";
+import type { HighlightColor } from "./palette";
+type PdfT = PropsLocale<"agentero.pdf">["t"];
+type SelectionMenuProps = {
+    /** Screen point near the top-center of the selection (toolbar anchor). */
+    screen: {
+        x: number;
+        y: number;
+    };
+    mode: "actions" | "comment" | "ask";
+    draft: string;
+    busy: boolean;
+    t: PdfT;
+    onCopy: () => Promise<boolean>;
+    /** Every swatch calls this with the chosen palette key. */
+    onHighlight: (color: HighlightColor) => void;
+    onComment: () => void;
+    onTranslate: () => void;
+    onAsk: () => void;
+    onDraftChange: (value: string) => void;
+    onSubmitDraft: () => void;
+};
+/**
+ * Floating action bar shown next to a text selection: overlapping highlight
+ * color dots (fan left on hover), then Translate / Comment / Copy / Quick chat / Add to chat.
+ * Copy keeps the bar open and swaps the icon for a check.
+ * The bar is pinned by its right edge so expanding colors only grow left.
+ */
+export declare function SelectionMenu({ screen, mode, draft, busy, t, onCopy, onHighlight, onComment, onTranslate, onAsk, onDraftChange, onSubmitDraft, }: SelectionMenuProps): import("react").JSX.Element;
+export {};

package/lib/client/tooltip.d.ts

@@ -0,0 +1,7 @@
+import { Tooltip as TooltipPrimitive } from "radix-ui";
+import type * as React from "react";
+declare function TooltipProvider({ delayDuration, ...props }: React.ComponentProps<typeof TooltipPrimitive.Provider>): React.JSX.Element;
+declare function Tooltip({ ...props }: React.ComponentProps<typeof TooltipPrimitive.Root>): React.JSX.Element;
+declare function TooltipTrigger({ ...props }: React.ComponentProps<typeof TooltipPrimitive.Trigger>): React.JSX.Element;
+declare function TooltipContent({ className, sideOffset, children, ...props }: React.ComponentProps<typeof TooltipPrimitive.Content>): React.JSX.Element;
+export { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger };

package/lib/client/translate-card.d.ts

@@ -0,0 +1,37 @@
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import { type ReactNode } from 'react';
+type PdfT = PropsLocale<'agentero.pdf'>['t'];
+export interface TranslateCardAnchor {
+    x: number;
+    y: number;
+}
+export interface TranslateCardProps {
+    anchor: TranslateCardAnchor;
+    result: string;
+    error: string;
+    loading: boolean;
+    pinned: boolean;
+    onTogglePin: () => void;
+    onClose: () => void;
+    t: PdfT;
+}
+/**
+ * Selection translation result. Mirrors the motif translate card: a small
+ * floating card anchored next to the selected text, with a pin that keeps the
+ * result reachable after the card is dismissed.
+ */
+export declare function TranslateCard({ anchor, result, error, loading, pinned, onTogglePin, onClose, t, }: TranslateCardProps): ReactNode;
+/**
+ * Small chip pinned to the selected text on the page itself. It lives inside
+ * the page layer, so it scrolls and zooms with the document instead of
+ * drifting across the paper when the reader moves.
+ *
+ * `x` / `y` are fractions (0–1) of the page box.
+ */
+export declare function TranslateCardPin({ x, y, onOpen, t, }: {
+    x: number;
+    y: number;
+    onOpen: (screen: TranslateCardAnchor) => void;
+    t: PdfT;
+}): ReactNode;
+export {};

package/lib/client/translation/coverage.d.ts

@@ -0,0 +1,15 @@
+import type { CharacterCoverage, CharacterDisposition } from "./types";
+import { type Character, type Paragraph } from "./types";
+/** Use engine angles; retain a conservative fallback for older cached IR. */
+export declare function rotatedCharacterIndexes(chars: readonly Character[]): Set<number>;
+/** Split fallback lines at spatial gaps so separate plot labels never join. */
+export declare function fallbackCharacterGroups(chars: readonly Character[]): Character[][];
+export declare function characterCoverage(chars: readonly Character[], paragraphs: readonly Paragraph[], preserved: ReadonlyMap<number, CharacterDisposition>): CharacterCoverage[];
+/** Rendering observes inherited clipping that PDFium text extraction omits.
+ * This is a conservative ink check, not reconstruction of the clipping path.
+ */
+export declare function nonPaintingCharacters(chars: readonly Character[], image: {
+    width: number;
+    height: number;
+    data: Uint8ClampedArray;
+}, pageWidth: number, pageHeight: number): Set<number>;

package/lib/client/translation/extract.d.ts

@@ -0,0 +1,7 @@
+import type { PdfDocumentObject, PdfEngine } from "@embedpdf/models";
+import type { LayoutTranslateItem, PdfLayoutRegion } from "./regions";
+import { type Box, type Character, type Paragraph, type ReflowDocument } from "./types";
+/** Detect visual formula islands, including adjacent scripts and punctuation. */
+export declare function paragraphFromCharacters(id: string, pageIndex: number, box: Box, chars: Character[], formulaBoxes: Box[], heading: boolean): Paragraph;
+/** Index-based extraction avoids matching normalized run strings to geometry. */
+export declare function extractReflowDocument(engine: PdfEngine, doc: PdfDocumentObject, items: readonly LayoutTranslateItem[], regions: readonly PdfLayoutRegion[], signal?: AbortSignal): Promise<ReflowDocument>;

package/lib/client/translation/fonts.d.ts

@@ -0,0 +1,6 @@
+import type { ReflowFonts } from './layout';
+import type { FontKey } from './types';
+export declare const fontFamily = "\"Noto Serif CJK SC\", \"Songti SC\", \"SimSun\", serif";
+export declare function fontCss(key: FontKey, size: number): string;
+/** Measure the same browser font that paints the page overlay. No font download required. */
+export declare function browserReflowFonts(): ReflowFonts;

package/lib/client/translation/layout.d.ts

@@ -0,0 +1,19 @@
+/** Browser metrics replace pdf-lib fonts; placement and fitting are unchanged. */
+export interface PDFFont {
+    encodeText(text: string): unknown;
+    widthOfTextAtSize(text: string, size: number): number;
+    heightAtSize(size: number, options?: {
+        descender: boolean;
+    }): number;
+}
+import { type Box, type FontKey, type PageLayout, type Paragraph, type ParagraphLayout, type PlacedUnit, type ReflowDocument, type ReflowPage } from "./types";
+export type ReflowFonts = Record<FontKey, PDFFont>;
+type Unit = Omit<PlacedUnit, "x" | "y"> & {
+    cjk: boolean;
+    space: boolean;
+};
+export declare function translationUnits(p: Paragraph, text: string, fonts: ReflowFonts): Unit[];
+export declare function layoutParagraph(p: Paragraph, text: string, page: ReflowPage, fonts: ReflowFonts, initialScale?: number, occupied?: Box[]): ParagraphLayout;
+/** Full-document pass, then a translated-unit-weighted common scale pass. */
+export declare function layoutReflowDocument(ir: ReflowDocument, translations: ReadonlyMap<string, string>, fonts: ReflowFonts, commonScale?: boolean): PageLayout[];
+export {};

package/lib/client/translation/page-overlay.d.ts

@@ -0,0 +1,10 @@
+import { type ReactNode } from 'react';
+import type { TranslatedPage } from './use-page-translation';
+import type { PdfPaperTone } from '../page-theme';
+/** Same page boxes and reflow units as motif; source PDF pixels stay underneath. */
+export declare const PageTranslationOverlay: import("react").MemoExoticComponent<({ state, width, height, tone }: {
+    state: TranslatedPage | undefined;
+    width: number;
+    height: number;
+    tone: PdfPaperTone;
+}) => ReactNode>;

package/lib/client/translation/reading-order.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Reading order for PDF text runs inside one layout box.
+ *
+ * A bolder or larger word sticks up, so its top is higher than the words
+ * beside it, while the bottoms still share a baseline. Group by that bottom,
+ * left to right, then the next line down.
+ */
+export type ReadingBox = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export type ReadingLine<T> = {
+    items: T[];
+    top: number;
+    bottom: number;
+};
+export declare function groupReadingLines<T>(items: readonly T[], boxOf: (item: T) => ReadingBox): ReadingLine<T>[];
+export declare function orderByReadingLine<T>(items: readonly T[], boxOf: (item: T) => ReadingBox): T[];

package/lib/client/translation/regions.d.ts

@@ -0,0 +1,17 @@
+import type { PdfTextRun } from '@embedpdf/models';
+import { type Box } from './types';
+export interface PdfLayoutRegion {
+    id: string;
+    pageIndex: number;
+    kind: string;
+    label: string;
+    score: number;
+    readingOrder: number;
+    rect: Box;
+    bbox: Box;
+}
+export type LayoutTranslateItem = Pick<PdfLayoutRegion, 'id' | 'pageIndex' | 'kind' | 'bbox'>;
+/** Motif stores normalized boxes in source/layout.json. Ignore unusable records. */
+export declare function parseLayoutRegions(raw: unknown): PdfLayoutRegion[];
+/** Text-only fallback: baseline grouping from motif, split columns before joining paragraphs. */
+export declare function regionsFromRuns(runs: readonly PdfTextRun[], pageIndex: number, width: number, height: number): PdfLayoutRegion[];

package/lib/client/translation/translate-paragraph.d.ts

@@ -0,0 +1,5 @@
+import { type Paragraph } from './types';
+type Translate = (text: string, signal?: AbortSignal) => Promise<string>;
+/** Motif's protected-spans fallback: keep formula/style boundaries outside the model. */
+export declare function translateParagraph(paragraph: Paragraph, translate: Translate, signal: AbortSignal): Promise<string>;
+export {};

package/lib/client/translation/types.d.ts

@@ -0,0 +1,107 @@
+/** Coordinates throughout the IR are page points, top-left origin. */
+export type Box = {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+};
+export type CharacterStyle = {
+    font: string;
+    size: number;
+    bold: boolean;
+    italic: boolean;
+    color: {
+        r: number;
+        g: number;
+        b: number;
+    };
+};
+export type CharacterDisposition = "translated" | "formula" | "table" | "excluded" | "rotated" | "unresolved" | "nonpainting" | "clipped";
+export type CharacterCoverage = {
+    index: number;
+    text: string;
+    disposition: CharacterDisposition;
+    paragraphId?: string;
+};
+export type Character = {
+    clipBoxes?: number[][];
+    renderMode?: number;
+    textAngle?: number;
+    textMatrix?: number[];
+    textObjectId?: number;
+    index: number;
+    text: string;
+    box: Box;
+    visualBox: Box;
+    style: CharacterStyle;
+};
+export type Formula = {
+    id: string;
+    text: string;
+    box: Box;
+    characterIndexes: number[];
+    baselineOffset: number;
+};
+export type Paragraph = {
+    id: string;
+    pageIndex: number;
+    box: Box;
+    characters: Character[];
+    formulas: Formula[];
+    styles: Record<string, CharacterStyle>;
+    source: string;
+    protectedText: string;
+    style: CharacterStyle;
+    firstLineIndent: number;
+    heading: boolean;
+    /** Table cells cannot borrow neighboring cell space. */
+    fixedBox?: boolean;
+    /** Available placement space, distinct from the source text removal bounds. */
+    layoutBox?: Box;
+    origin?: "detected" | "table" | "fallback";
+};
+export type ReflowPage = {
+    index: number;
+    width: number;
+    height: number;
+    paragraphs: Paragraph[];
+    obstacles: Box[];
+    coverage?: CharacterCoverage[];
+};
+export type ReflowDocument = {
+    version: 1;
+    pages: ReflowPage[];
+};
+export type FontKey = "regular" | "bold" | "italic" | "boldItalic" | "cjk" | "cjkBold";
+export type PlacedUnit = {
+    text: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    font: FontKey;
+    fontSize: number;
+    formula?: Formula;
+    color: CharacterStyle["color"];
+};
+export type ParagraphLayout = {
+    id: string;
+    pageIndex: number;
+    sourceBox: Box;
+    box: Box;
+    scale: number;
+    units: PlacedUnit[];
+    fits: boolean;
+};
+export type PageLayout = {
+    index: number;
+    width: number;
+    height: number;
+    paragraphs: ParagraphLayout[];
+};
+export declare const formulaToken: (id: string) => string;
+export declare function unionBoxes(boxes: readonly Box[]): Box;
+export declare function intersects(a: Box, b: Box): boolean;
+/** Formula and style tags are a structural contract, not ordinary prose. */
+export declare function validReflowTranslation(p: Paragraph, text: string): boolean;
+export declare function reflowDisplayText(p: Paragraph, text: string): string;

package/lib/client/translation/use-page-translation.d.ts

@@ -0,0 +1,23 @@
+import type { PdfDocumentObject, PdfEngine } from '@embedpdf/models';
+import { type ParagraphLayout, type ReflowPage } from './types';
+export interface TranslatedPage {
+    source: ReflowPage;
+    layouts: ParagraphLayout[];
+    formulas: Map<string, string>;
+    translations: Map<string, string>;
+    error: string;
+    done: boolean;
+}
+export declare function usePageTranslation(options: {
+    open: boolean;
+    currentPage: number;
+    document: PdfDocumentObject | null | undefined;
+    engine: PdfEngine;
+    loadLayout: (signal?: AbortSignal) => Promise<unknown>;
+    translate: (text: string, signal?: AbortSignal) => Promise<string>;
+}): {
+    pages: ReadonlyMap<number, TranslatedPage>;
+    running: boolean;
+    error: string;
+    retry: () => void;
+};

package/lib/client/zoom.d.ts

@@ -0,0 +1,32 @@
+export declare const PDF_ZOOM_MIN = 0.5;
+export declare const PDF_ZOOM_MAX = 3;
+/** Parse a user-entered percentage and clamp it to the viewer's zoom range. */
+export declare function parsePdfZoomPercentage(value: string): number | null;
+/**
+ * Preview scale for a zoom gesture (magnification relative to the zoom it
+ * started from), kept inside the viewer range so the preview matches the zoom
+ * that gets committed on release.
+ */
+export declare function clampZoomPreviewScale(scale: number, baseZoom: number): number;
+/**
+ * Translate that keeps a point of the transformed element under the pointer.
+ * Used with `transform-origin: 0 0` so a pinch scales around the fingers
+ * instead of the viewport center; `localX` / `localY` are the pointer position
+ * in the element's coordinate space before the transform is applied.
+ */
+export declare function zoomPreviewTranslate(localX: number, localY: number, scale: number): {
+    x: number;
+    y: number;
+};
+/**
+ * Follow the reader's centered-page geometry while the document is narrower
+ * than its reading area, then blend to the gesture point as it overflows.
+ */
+export declare function zoomPreviewTranslateForViewport(localX: number, localY: number, scale: number, elementWidth: number, viewportWidth: number): {
+    x: number;
+    y: number;
+};
+/** Step the viewer zoom by 10 percentage points, staying inside the range. */
+export declare function stepPdfZoom(zoom: number, direction: -1 | 1): number;
+/** Keep one decimal place when needed without showing a trailing `.0`. */
+export declare function formatPdfZoomPercentage(zoom: number): string;