@build-qube/papyra-native-wasm32-wasi 0.0.4 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@build-qube/papyra-native-wasm32-wasi",
-  "version": "0.0.4",
+  "version": "0.2.0",
   "main": "papyra.wasi.cjs",
   "files": [
     "papyra.wasm32-wasi.wasm",

package/papyra.wasi-browser.js

@@ -601,8 +601,12 @@ try {
   throw __attachCleanupErrors(error, cleanupErrors)
 }
 export default __napiModule.exports
+export const PageImage = __napiModule.exports.PageImage
 export const PdfDocument = __napiModule.exports.PdfDocument
 export const backendName = __napiModule.exports.backendName
 export const configureThreadPool = __napiModule.exports.configureThreadPool
+export const encodeBitmap = __napiModule.exports.encodeBitmap
+export const encodeBitmapSync = __napiModule.exports.encodeBitmapSync
+export const ImageFormat = __napiModule.exports.ImageFormat
 export const reserveMemory = __napiModule.exports.reserveMemory
 export const runtime = __napiModule.exports.runtime

package/papyra.wasi.cjs

@@ -1,4 +1,4 @@
-// napi-rs-artifact-metadata:{"version":2,"rootEntry":"index.js","exports":["PdfDocument","backendName","configureThreadPool","reserveMemory","runtime"],"managedRootEntries":["browser.js","index.js","papyra.wasm","papyra.debug.wasm"]}
+// napi-rs-artifact-metadata:{"version":2,"rootEntry":"index.js","exports":["PageImage","PdfDocument","backendName","configureThreadPool","encodeBitmap","encodeBitmapSync","ImageFormat","reserveMemory","runtime"],"managedRootEntries":["browser.js","index.js","papyra.wasm","papyra.debug.wasm"]}
 /* eslint-disable */
 /* prettier-ignore */
 
@@ -921,8 +921,12 @@ try {
   throw rollback.error
 }
 module.exports = __napiModule.exports
+module.exports.PageImage = __napiModule.exports.PageImage
 module.exports.PdfDocument = __napiModule.exports.PdfDocument
 module.exports.backendName = __napiModule.exports.backendName
 module.exports.configureThreadPool = __napiModule.exports.configureThreadPool
+module.exports.encodeBitmap = __napiModule.exports.encodeBitmap
+module.exports.encodeBitmapSync = __napiModule.exports.encodeBitmapSync
+module.exports.ImageFormat = __napiModule.exports.ImageFormat
 module.exports.reserveMemory = __napiModule.exports.reserveMemory
 module.exports.runtime = __napiModule.exports.runtime

package/papyra.wasi.d.cts

@@ -1,16 +1,83 @@
 /* auto-generated by NAPI-RS */
 /* eslint-disable */
+/**
+ * A rendered page kept in Rust, encoded on demand.
+ *
+ * The pixels deliberately never cross into JS. A 42x30in drawing at 150 DPI is 6.5 MB
+ * raw and a fraction of that encoded, so for export the raw buffer is pure overhead.
+ * There is no accessor for it: use `renderPageAsync` when you want the pixels, this
+ * when you want a file.
+ */
+export declare class PageImage {
+  get width(): number
+  get height(): number
+  /** Size of the *raw* bitmap held in Rust. Encoded output is much smaller. */
+  get byteLength(): number
+  /** Encode off the JS thread. */
+  encode(format: ImageFormat, quality?: number | undefined | null, signal?: AbortSignal | undefined | null): Promise<Uint8Array>
+  /**
+   * Blocks the calling thread. Routed through the same `Task` as the async path so
+   * the two cannot drift.
+   */
+  encodeSync(format: ImageFormat, quality?: number | undefined | null): Uint8Array
+  /**
+   * Encode straight to a `data:` URL, so neither the pixels nor the encoded bytes
+   * cross the boundary — only the finished string does.
+   */
+  toDataUrl(format: ImageFormat, quality?: number | undefined | null, signal?: AbortSignal | undefined | null): Promise<string>
+}
+
 export declare class PdfDocument {
   /** Load a PDF from raw bytes. */
   static load(data: Uint8Array): PdfDocument
   /** Load an encrypted PDF. */
   static loadWithPassword(data: Uint8Array, password: string): PdfDocument
   get pageCount(): number
+  /** The PDF specification version the file declares, e.g. `"1.7"`. */
+  get pdfVersion(): string | null
   pageSize(index: number): PageDimensions
   /** Render one page on the calling thread. Blocks; prefer `renderPageAsync`. */
   renderPage(index: number, dpi?: number | undefined | null): RenderedPage
   /** Render one page off the JS thread. Several of these run concurrently. */
   renderPageAsync(index: number, dpi?: number | undefined | null): Promise<RenderedPage>
+  /** Render one page and keep it in Rust, for encoding. The pixels never reach JS. */
+  renderPageImageAsync(index: number, dpi?: number | undefined | null, signal?: AbortSignal | undefined | null): Promise<PageImage>
+  /**
+   * Convert one page to a standalone SVG document, off the JS thread.
+   *
+   * There is no DPI: an SVG carries the page's own point dimensions and rasterises at
+   * whatever size it is drawn.
+   */
+  renderPageSvgAsync(index: number, whiteBackground?: boolean | undefined | null, signal?: AbortSignal | undefined | null): Promise<string>
+  /** Extract the text of one page, off the JS thread. */
+  pageTextAsync(index: number): Promise<PageText>
+  /** Extract `[start, end)` in one async task, parallelised internally with rayon. */
+  pageTextsAsync(start: number, end: number): Promise<Array<PageText>>
+  /**
+   * Read the document outline (bookmarks), in pre-order.
+   *
+   * Resolves to an empty array when the document has no outline, which is the
+   * common case.
+   */
+  outline(): Promise<Array<OutlineEntry>>
+  /**
+   * Read the document information dictionary.
+   *
+   * Synchronous: hayro parses it while loading, so this only decodes eight strings.
+   */
+  info(): DocumentInfo
+  /**
+   * Read the links on one page.
+   *
+   * Resolves to an empty array for a page with no links, which is most pages.
+   */
+  pageLinks(index: number): Promise<Array<PageLink>>
+  /**
+   * Read the label printed on each page, one entry per page.
+   *
+   * Resolves to an empty array when the document defines no `/PageLabels`.
+   */
+  pageLabels(): Promise<Array<string>>
   /** Render `[start, end)` in one async task, parallelised internally with rayon. */
   renderPagesAsync(start: number, end: number, dpi?: number | undefined | null): Promise<Array<RenderedPage>>
 }
@@ -27,6 +94,70 @@ export declare function backendName(): string
  */
 export declare function configureThreadPool(threads: number, stackSizeMb?: number | undefined | null): number
 
+/** The document information dictionary. Every field is independently optional. */
+export interface DocumentInfo {
+  title?: string
+  author?: string
+  subject?: string
+  keywords?: string
+  /** The application that authored the original document, e.g. `AutoCAD`. */
+  creator?: string
+  /** The application that wrote the PDF itself, e.g. `Ghostscript`. */
+  producer?: string
+  /** ISO 8601, converted from the PDF's own date form. */
+  created?: string
+  modified?: string
+}
+
+/** Encode a raw RGBA8 buffer off the JS thread. */
+export declare function encodeBitmap(data: Uint8Array, width: number, height: number, stride: number, format: ImageFormat, quality?: number | undefined | null, signal?: AbortSignal | undefined | null): Promise<Uint8Array>
+
+/** Blocks the calling thread. Same `Task` as [`encode_bitmap`]. */
+export declare function encodeBitmapSync(data: Uint8Array, width: number, height: number, stride: number, format: ImageFormat, quality?: number | undefined | null): Uint8Array
+
+/**
+ * Container for encoded output. Every encoder here is pure Rust, which is what keeps
+ * the wasm target buildable — so there is no lossy WebP and no AVIF.
+ */
+export declare const enum ImageFormat {
+  /** Lossless VP8L. ~3x smaller than PNG on page content, for about the same cost. */
+  WebP = 'webp',
+  /** Lossless, universally supported. */
+  Png = 'png',
+  /** The only lossy option, and the only one with a quality knob. No alpha. */
+  Jpeg = 'jpeg'
+}
+
+/**
+ * Where an outline entry points. Coordinates are PDF points from the page's
+ * bottom-left; `null` means "leave this axis unchanged".
+ */
+export interface OutlineDestination {
+  /** 0-based page index. */
+  page: number
+  /** `"XYZ"`, `"Fit"`, `"FitH"`, `"FitV"`, `"FitR"`, `"FitB"`, `"FitBH"` or `"FitBV"`. */
+  kind: string
+  left?: number
+  top?: number
+  right?: number
+  bottom?: number
+  /** Absent for every kind but `"XYZ"`, where a zoom of 0 also reads as absent. */
+  zoom?: number
+}
+
+/** One outline entry. Flat and in pre-order; `level` carries the tree. */
+export interface OutlineEntry {
+  title: string
+  /** Nesting depth. Top-level bookmarks are 0. */
+  level: number
+  /** `null` for a container with no destination, or one that leaves this document. */
+  dest?: OutlineDestination
+  bold: boolean
+  italic: boolean
+  /** The entry should start expanded. */
+  open: boolean
+}
+
 export interface PageDimensions {
   /** Width in PDF points (1/72 inch). */
   width: number
@@ -34,6 +165,43 @@ export interface PageDimensions {
   height: number
 }
 
+/**
+ * One link annotation.
+ *
+ * The rectangle is in the page-as-rendered space — pixels from the top-left at
+ * 72 DPI, rotation and crop box applied — so it is the same space as `PageText` and
+ * scales to any render with one multiply.
+ */
+export interface PageLink {
+  x0: number
+  y0: number
+  x1: number
+  y1: number
+  /** Set when the link points into this document; `uri` is then absent. */
+  dest?: OutlineDestination
+  /** Set when the link points at a URI; `dest` is then absent. */
+  uri?: string
+  /** The annotation's `/Contents` — its tooltip. Usually absent. */
+  alt?: string
+}
+
+/**
+ * The text of one page.
+ *
+ * Coordinates are the page as rendered at 72 DPI — pixels from the top-left with y
+ * increasing downwards, rotation and crop box applied — so scaling to any other
+ * render is one multiply.
+ */
+export interface PageText {
+  lines: Array<TextLine>
+  /**
+   * Glyphs drawn that no encoding could map back to Unicode. Non-zero with no lines
+   * means the page has text that cannot be searched, which is a different answer
+   * than a page with no text at all.
+   */
+  undecodedGlyphs: number
+}
+
 export interface RenderedPage {
   width: number
   height: number
@@ -56,3 +224,30 @@ export declare function reserveMemory(megabytes: number): number
 
 /** `"native"` or `"wasm"`. The wrapper uses this to pick a concurrency strategy. */
 export declare function runtime(): string
+
+/**
+ * A run of glyphs sharing one baseline.
+ *
+ * Geometry runs along the baseline rather than being a rectangle per character: a
+ * page is thousands of glyphs, and four numbers each is far more than a search needs.
+ * One origin, one direction and a list of distances reconstructs any substring's
+ * quadrilateral exactly, rotated text included.
+ */
+export interface TextLine {
+  text: string
+  /**
+   * Distance along the baseline to the start of each character, plus the end of the
+   * last — one more entry than the string has characters.
+   */
+  offsets: Float32Array
+  /** Start of the baseline. */
+  x: number
+  y: number
+  /** Unit vector along the baseline. `(1, 0)` for ordinary horizontal text. */
+  dx: number
+  dy: number
+  /** Extent above the baseline, perpendicular to it. */
+  ascent: number
+  /** Extent below the baseline. */
+  descent: number
+}