renderpdf-js 0.1.0 → 0.2.1

package/dist/layout.d.ts

@@ -8,6 +8,8 @@ import type { LayoutSnapshot } from './types.js';
 export declare function snapshotLayout(root: HTMLElement, fonts: readonly RegisteredFont[], options?: {
     /** Strict mode keeps native errors unless a boundary has explicit data-raster markup. */
     fallback?: 'auto' | 'strict';
+    /** Reserve and replay a native THEAD on each body continuation page. */
+    repeatTableHeaders?: boolean;
 }): Promise<LayoutSnapshot>;
 /** Measure settled browser resources synchronously so a source guard can share the same task.
  * @param root Connected, visible HTMLElement with its fonts and source images already prepared.
@@ -17,4 +19,6 @@ export declare function snapshotLayout(root: HTMLElement, fonts: readonly Regist
 export declare function measurePreparedLayout(root: HTMLElement, fonts: readonly RegisteredFont[], options?: {
     /** Strict mode keeps native errors unless a boundary has explicit data-raster markup. */
     fallback?: 'auto' | 'strict';
+    /** Reserve and replay a native THEAD on each body continuation page. */
+    repeatTableHeaders?: boolean;
 }): LayoutSnapshot;

package/dist/page-bands.d.ts

@@ -0,0 +1,24 @@
+import type { PageGeometry, RegisteredFont, RenderPDFOptions } from './api-types.js';
+/** Copied, validated inputs for one repeated text band. */
+export interface PageText {
+    /** Caller text with supported page placeholders preserved until pagination finishes. */
+    readonly text: string;
+    /** Reserved height in CSS pixels. */
+    readonly height: number;
+    /** Exact face also supplied to the source renderer. */
+    readonly font: RegisteredFont;
+    /** Font size in CSS pixels. */
+    readonly fontSize: number;
+    /** Horizontal placement inside the original page margins. */
+    readonly align: 'left' | 'center' | 'right';
+}
+/** Reserve page text outside the source area without changing the caller's DOM layout. */
+export declare function resolvePageBands(
+/** Original physical page and outer margins. */
+page: PageGeometry, 
+/** Validated options whose font handles remain immutable. */
+options: RenderPDFOptions): {
+    content: PageGeometry;
+    header: PageText | undefined;
+    footer: PageText | undefined;
+};

package/dist/page.d.ts

@@ -1,5 +1,9 @@
-import type { PageGeometry, RenderPDFOptions } from './api-types.js';
-/** Resolve physical paper dimensions and validate the small public option surface. */
-export declare function resolvePage(
+import type { PageGeometry, PDFPageOptions, RenderPDFOptions } from './api-types.js';
+/** Resolve physical paper dimensions without requiring DOM content or registered fonts. */
+export declare function resolvePageGeometry(
 /** Caller-owned options; resolving them never changes their values. */
+options: PDFPageOptions): PageGeometry;
+/** Validate HTML rendering settings around the shared physical page geometry. */
+export declare function resolvePage(
+/** Caller-owned HTML rendering options. */
 options: RenderPDFOptions): PageGeometry;

package/dist/pagination.d.ts

@@ -1,11 +1,15 @@
 import type { RenderWarning } from './diagnostics.js';
-import type { LayoutSnapshot } from './types.js';
+import type { LayoutSnapshot, TableHeader } from './types.js';
 /** One source-coordinate interval mapped into a PDF page. */
 export interface PageSlice {
     /** Inclusive source top in CSS pixels. */
     start: number;
     /** Exclusive source bottom in CSS pixels. */
     end: number;
+    /** Original header replayed before this continuation interval; absent on its first page. */
+    header?: TableHeader;
+    /** Reserved repeated band, counting any leading source row gap only once. */
+    headerHeight?: number;
 }
 /** Map one continuous source into pages with required cuts and best-effort CSS avoidance. */
 export declare function paginate(

package/dist/pdf.d.ts

@@ -1,4 +1,5 @@
-import type { PageGeometry, RegisteredFont } from './api-types.js';
+import type { PageGeometry, PDFMetadata, RegisteredFont, RenderProgress } from './api-types.js';
+import type { PageText } from './page-bands.js';
 import type { PageSlice } from './pagination.js';
 import type { LayoutSnapshot } from './types.js';
 /** Bounded writer settings independent of DOM layout measurement. */
@@ -9,6 +10,14 @@ export interface PDFWriteOptions {
     includeRasterText?: boolean;
     /** Stop before beginning subsequent asynchronous writing stages. */
     signal?: AbortSignal;
+    /** Copied plain text placed above the source, outside its page clip. */
+    header?: PageText;
+    /** Copied plain text placed below the source, outside its page clip. */
+    footer?: PageText;
+    /** Owned Unicode document properties, resolved before preparation begins. */
+    metadata?: Readonly<PDFMetadata>;
+    /** Internal awaited reporter; public application callbacks remain synchronous. */
+    reportProgress?: (progress: RenderProgress) => Promise<void>;
 }
 /** Serialized PDF and the exact source intervals used for page ownership. */
 export interface PDFWriteResult {

package/dist/progress.d.ts

@@ -0,0 +1,11 @@
+import type { RenderProgress } from './api-types.js';
+/** One export owns its callback error and optional browser scheduling state. */
+export declare function createProgressReporter(
+/** Synchronous application listener, absent when progress was not requested. */
+callback: ((progress: RenderProgress) => void) | undefined, 
+/** Optional cooperative cancellation shared with the rendering pipeline. */
+signal?: AbortSignal): {
+    report: ((progress: RenderProgress) => Promise<void>) | undefined;
+    /** Preserve application exceptions across lower-level PDF adapter error wrapping. */
+    rethrow(error: unknown): never;
+};

package/dist/table-borders.d.ts

@@ -0,0 +1,52 @@
+import type { BorderOperation, Bounds } from './types.js';
+/** One authored border competing for a measured collapsed grid edge. */
+export interface TableBorderCandidate {
+    /** Horizontal or vertical source-coordinate grid line. */
+    direction: 'horizontal' | 'vertical';
+    /** Fixed grid coordinate perpendicular to the edge. */
+    position: number;
+    /** Inclusive coordinate along the edge. */
+    start: number;
+    /** Exclusive coordinate along the edge. */
+    end: number;
+    /** Computed thickness; hidden borders retain priority even when their computed width is zero. */
+    width: number;
+    /** Supported CSS border style; hidden suppresses every competing border. */
+    style: 'solid' | 'none' | 'hidden';
+    /** Browser-resolved color of this candidate. */
+    color: string;
+    /** Cells outrank the table when equally wide solid borders compete. */
+    owner: 'cell' | 'table';
+    /** Owner's top grid coordinate, used for the upper-cell tie break. */
+    row: number;
+    /** Owner's left grid coordinate, used for the left-cell tie break in LTR tables. */
+    column: number;
+}
+/** Native border paint and replay limits for one measured collapsed table. */
+export interface CollapsedTablePaint {
+    /** Nonoverlapping final fills in border conflict priority order. */
+    operations: BorderOperation[];
+    /** Header grid bounds expanded through the outer top, left and right half-borders. */
+    headerBounds?: Bounds;
+    /** Continuations can reuse half-boundaries only when their horizontal winners agree. */
+    repeatSafe: boolean;
+}
+/** Resolve pure measured-border inputs without depending on browser or PDF globals.
+ * @param candidates Competing authored borders with already measured grid coordinates.
+ */
+export declare function resolveCollapsedBorders(candidates: readonly TableBorderCandidate[]): BorderOperation[];
+/** Find native HTML table parts whose borders participate in one collapsed grid.
+ * @param element Current element from the existing static layout traversal.
+ * @param style Already computed style for this element.
+ */
+export declare function collapsedTableOwner(element: HTMLElement, style: CSSStyleDeclaration): HTMLTableElement | undefined;
+/** Enforce the deliberately bounded collapsed-border contributions before native box emission.
+ * @param element Native table part whose sides will be resolved together after its cells.
+ * @param style Browser-computed authored sides, independent of the winning shared border.
+ */
+export declare function validateCollapsedTablePart(element: HTMLElement, style: CSSStyleDeclaration): void;
+/** Measure cell centerlines and resolve the native table's single border paint layer.
+ * @param table Connected native collapsed table with existing browser-calculated column widths.
+ * @param origin Source root rectangle defining the shared CSS pixel coordinate system.
+ */
+export declare function measureCollapsedTableBorders(table: HTMLTableElement, origin: DOMRect): CollapsedTablePaint;

package/dist/text.d.ts

@@ -32,6 +32,15 @@ export declare class PositionedFont {
      * @param kerning Whether CSS admits kerning for this line.
      */
     shape(text: string, kerning?: boolean): readonly PositionedGlyph[];
+    /** Measure shaped advance and ink extents so repeated page text cannot overflow its band.
+     * @param text Complete single line using this exact embedded font.
+     */
+    measure(text: string): {
+        left: number;
+        right: number;
+        ascent: number;
+        descent: number;
+    };
     /** Preserve extraction for every used shaped glyph, including uncoded ligatures.
      * @param document Export document owning the public font reference and object context.
      */

package/dist/tiff.d.ts

@@ -0,0 +1,23 @@
+/** A single unrotated TIFF raster; the PDF writer applies its explicit orientation matrix. */
+export interface TiffFrame {
+    /** Original stored columns, before orientation. */
+    width: number;
+    /** Original stored rows, before orientation. */
+    height: number;
+    /** Straight-alpha eight-bit RGBA pixels owned by this decode. */
+    rgba: Uint8Array;
+    /** TIFF orientation in the inclusive range one through eight. */
+    orientation: number;
+}
+/** Bounded metadata access without retaining decoded rasters for every page. */
+export interface TiffDocument {
+    /** Number of image-bearing main IFDs in their original linked order. */
+    readonly pageCount: number;
+    /** Decode one requested frame; no previous frame raster is retained. */
+    decodeFrame(index: number): Promise<TiffFrame>;
+}
+/** Open only metadata first; decode requested scan frames individually through public UTIF APIs.
+ * @param input Complete caller-owned TIFF bytes; the adapter keeps an independent encoded copy.
+ * @param signal Cooperative cancellation before metadata work and each synchronous frame decode.
+ */
+export declare function openTiff(input: Uint8Array, signal?: AbortSignal): Promise<TiffDocument>;

package/dist/types.d.ts

@@ -57,6 +57,19 @@ export interface BoxOperation {
     /** Uniform border width in CSS pixels. */
     borderWidth: number;
 }
+/** One disjoint solid fill belonging to a resolved collapsed table border. */
+export interface BorderOperation {
+    /** Discriminant for native filled-border dispatch. */
+    kind: 'border';
+    /** Actual positive painted rectangle, including the half-width outside its grid line. */
+    bounds: Bounds;
+    /** Browser-computed winning border color, including any alpha component. */
+    color: string;
+    /** Winning CSS border thickness before crossing rectangles are partitioned. */
+    width: number;
+    /** Grid direction retained independently of the final clipped fill rectangle. */
+    direction: 'horizontal' | 'vertical';
+}
 /** An explicitly isolated DOM subtree captured at its paint-order position. */
 export interface RasterOperation {
     /** Discriminant for ordered paint dispatch. */
@@ -76,7 +89,18 @@ export interface ImageOperation {
     element: HTMLImageElement;
 }
 /** A flattened, ordered experiment display list, not a general CSS paint tree. */
-export type PaintOperation = TextOperation | BoxOperation | RasterOperation | ImageOperation;
+export type PaintOperation = TextOperation | BoxOperation | BorderOperation | RasterOperation | ImageOperation;
+/** Native table header replayed above each continuation interval without changing source geometry. */
+export interface TableHeader {
+    /** Original THEAD border box in source CSS pixels. */
+    bounds: Bounds;
+    /** First visible body row top; the gap after THEAD belongs to every repeated header. */
+    bodyStart: number;
+    /** Last visible body row bottom, excluding any TFOOT. */
+    bodyEnd: number;
+    /** Original paint references, including ancestor boxes clipped to the header band by the writer. */
+    operations: PaintOperation[];
+}
 /** Immutable geometry metadata plus a bounded list of ordered paint operations. */
 export interface LayoutSnapshot {
     /** Measured root width in CSS pixels. */
@@ -93,4 +117,6 @@ export interface LayoutSnapshot {
     forcedBreaks?: number[];
     /** Preferred indivisible blocks; oversized preferences may relax with an explicit warning. */
     avoidBreakBounds?: Bounds[];
+    /** Explicitly requested native THEAD repetitions for nonoverlapping tables. */
+    tableHeaders?: TableHeader[];
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "renderpdf-js",
-  "version": "0.1.0",
-  "description": "Browser-only HTML to PDF renderer with explicit fonts and local raster regions",
+  "version": "0.2.1",
+  "description": "Convert HTML, PNG, JPEG and multipage TIFF to PDF in the browser.",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -16,7 +16,9 @@
     "html",
     "browser",
     "typescript",
-    "html-to-pdf"
+    "html-to-pdf",
+    "image-to-pdf",
+    "tiff-to-pdf"
   ],
   "publishConfig": {
     "access": "public",
@@ -59,7 +61,8 @@
   "dependencies": {
     "@pdf-lib/fontkit": "^1.1.1",
     "html-to-image": "^1.11.13",
-    "pdf-lib": "^1.17.1"
+    "pdf-lib": "^1.17.1",
+    "utif2": "4.1.0"
   },
   "devDependencies": {
     "@playwright/test": "^1.64.1",