npm - @skyprint/image2pdf-expo - Versions diffs - 0.1.0 - Mend

@skyprint/image2pdf-expo 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (18) hide show

package/README.md +136 -0
package/assets/README.md +29 -0
package/assets/bridge.bundle +253 -0
package/assets/bridge.html +18 -0
package/assets/image2pdf.bundle +992 -0
package/assets/image2pdf.d.ts +147 -0
package/assets/image2pdf_bg.wasm +0 -0
package/assets/image2pdf_bg.wasm.d.ts +24 -0
package/package.json +45 -0
package/src/Bridge.tsx +169 -0
package/src/assets.d.ts +9 -0
package/src/debugLog.ts +12 -0
package/src/index.ts +20 -0
package/src/loadBridgeBundle.ts +79 -0
package/src/protocol.ts +43 -0
package/src/readUriBase64.ts +39 -0
package/src/types.ts +33 -0
package/src/useImage2Pdf.tsx +296 -0

package/assets/image2pdf.d.ts ADDED Viewed

@@ -0,0 +1,147 @@
+/* tslint:disable */
+/* eslint-disable */
+export function Pdf_BytesToDocument(input: string): Promise<string>;
+/**
+ * Parses the input PDF file (as a base64 encoded string), outputs the parsed
+ * PDF (and any warnings) as a JSON object
+ *
+ * ```js,no_run,ignore
+ * let input = JSON.encode({ pdf_base64: atob(my_pdf) });
+ * let doc = JSON.parse(Pdf_BytesToPdfDocument(input));
+ * console.log(doc.pdf);
+ * console.log(doc.warnings);
+ * // {
+ * //   status: 0,
+ * //   data: {
+ * //     metadata: ...,
+ * //     resources: ...,
+ * //     bookmarks: ...,
+ * //     pages: [{ media_box, trim_box, crop_box, ops }]
+ * //    }
+ * // }
+ * ```
+ */
+export function Pdf_BytesToDocumentSync(input: string): string;
+export function Pdf_DocumentToBytes(input: string): Promise<string>;
+/**
+ * Takes a `PdfDocument` JS object and returns the base64 PDF bytes
+ */
+export function Pdf_DocumentToBytesSync(input: string): string;
+export function Pdf_HtmlToDocument(input: string): Promise<string>;
+/**
+ * Parses the input HTML, converts it to PDF pages and outputs the generated
+ * PDF as a JSON object
+ *
+ * ```js,no_run,ignore
+ * let html = "<!doctype html><html><body><h1>Hello!</h1></body></html>";
+ * let input = JSON.encode({ html: html, title "My PDF!" });
+ * let document = JSON.parse(Pdf_HtmlToPdfDocument(input));
+ * console.log(document);
+ * // {
+ * //   status: 0,
+ * //   data: {
+ * //     metadata: ...,
+ * //     resources: ...,
+ * //     bookmarks: ...,
+ * //     pages: [{ media_box, trim_box, crop_box, ops }]
+ * //    }
+ * // }
+ * ```
+ */
+export function Pdf_HtmlToDocumentSync(input: string): string;
+export function Pdf_PageToSvg(input: string): Promise<string>;
+/**
+ * Takes a `PdfPage` JS object and outputs the SVG string for that page
+ */
+export function Pdf_PageToSvgSync(input: string): string;
+export function Pdf_ResourcesForPage(input: string): Promise<string>;
+/**
+ * Helper function that takes a PDF page and outputs a list of all
+ * images IDs / fonts IDs that have to be gathered from the documents
+ * resources in order to render this page.
+ */
+export function Pdf_ResourcesForPageSync(input: string): string;
+/**
+ * Convert a list of encoded image buffers into a single PDF.
+ *
+ * # Parameters
+ * - `images` — a JS `Array` of `Uint8Array`, one per image. Each buffer must be
+ *   a complete, self-contained image file (the same bytes you'd get from
+ *   `fs.readFileSync` or `File.arrayBuffer()`).
+ * - `options` — a JS object matching the `ConvertOptions` shape, or `undefined`
+ *   to use defaults (A4 page, 10 mm margin, 75 DPI).
+ *
+ * # Returns
+ * Raw PDF bytes as `Vec<u8>`, exposed to JS as a `Uint8Array`.
+ *
+ * # Errors
+ * Returns a `JsValue` carrying a readable error message on decode failure,
+ * unsupported format, or PDF write error.
+ */
+export function convert(images: Array<any>, options: any): Uint8Array;
+/**
+ * Wasm entry-point. Installs a panic hook that prints Rust panics into the
+ * browser console instead of failing silently with `unreachable`.
+ */
+export function start(): void;
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly convert: (a: number, b: number, c: number) => void;
+    readonly start: () => void;
+    readonly Pdf_BytesToDocument: (a: number, b: number) => number;
+    readonly Pdf_BytesToDocumentSync: (a: number, b: number, c: number) => void;
+    readonly Pdf_DocumentToBytes: (a: number, b: number) => number;
+    readonly Pdf_DocumentToBytesSync: (a: number, b: number, c: number) => void;
+    readonly Pdf_HtmlToDocument: (a: number, b: number) => number;
+    readonly Pdf_HtmlToDocumentSync: (a: number, b: number, c: number) => void;
+    readonly Pdf_PageToSvg: (a: number, b: number) => number;
+    readonly Pdf_PageToSvgSync: (a: number, b: number, c: number) => void;
+    readonly Pdf_ResourcesForPage: (a: number, b: number) => number;
+    readonly Pdf_ResourcesForPageSync: (a: number, b: number, c: number) => void;
+    readonly __wasm_bindgen_func_elem_9463: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_9473: (a: number, b: number, c: number, d: number) => void;
+    readonly __wbindgen_export: (a: number, b: number) => number;
+    readonly __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_export3: (a: number) => void;
+    readonly __wbindgen_export4: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_export5: (a: number, b: number) => void;
+    readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
+    readonly __wbindgen_start: () => void;
+}
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

package/assets/image2pdf_bg.wasm ADDED Viewed

Binary file

package/assets/image2pdf_bg.wasm.d.ts ADDED Viewed

@@ -0,0 +1,24 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const convert: (a: number, b: number, c: number) => void;
+export const start: () => void;
+export const Pdf_BytesToDocument: (a: number, b: number) => number;
+export const Pdf_BytesToDocumentSync: (a: number, b: number, c: number) => void;
+export const Pdf_DocumentToBytes: (a: number, b: number) => number;
+export const Pdf_DocumentToBytesSync: (a: number, b: number, c: number) => void;
+export const Pdf_HtmlToDocument: (a: number, b: number) => number;
+export const Pdf_HtmlToDocumentSync: (a: number, b: number, c: number) => void;
+export const Pdf_PageToSvg: (a: number, b: number) => number;
+export const Pdf_PageToSvgSync: (a: number, b: number, c: number) => void;
+export const Pdf_ResourcesForPage: (a: number, b: number) => number;
+export const Pdf_ResourcesForPageSync: (a: number, b: number, c: number) => void;
+export const __wasm_bindgen_func_elem_9463: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_9473: (a: number, b: number, c: number, d: number) => void;
+export const __wbindgen_export: (a: number, b: number) => number;
+export const __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_export3: (a: number) => void;
+export const __wbindgen_export4: (a: number, b: number, c: number) => void;
+export const __wbindgen_export5: (a: number, b: number) => void;
+export const __wbindgen_add_to_stack_pointer: (a: number) => number;
+export const __wbindgen_start: () => void;

package/package.json ADDED Viewed

@@ -0,0 +1,45 @@
+{
+  "name": "@skyprint/image2pdf-expo",
+  "version": "0.1.0",
+  "description": "Expo / React Native bridge for image2pdf — converts JPG/PNG/HEIC images to a single A4 PDF entirely on-device.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git@git.duguying.net:cloudprinter/image2pdf.git",
+    "directory": "integrations/expo"
+  },
+  "main": "src/index.ts",
+  "react-native": "src/index.ts",
+  "types": "src/index.ts",
+  "files": [
+    "src",
+    "assets",
+    "README.md"
+  ],
+  "keywords": [
+    "expo",
+    "react-native",
+    "pdf",
+    "image",
+    "heic",
+    "jpg",
+    "png",
+    "wasm"
+  ],
+  "scripts": {
+    "build": "node scripts/copy-wasm.mjs",
+    "typecheck": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "expo": ">=55.0.0",
+    "expo-asset": ">=55.0.0",
+    "expo-file-system": ">=55.0.0",
+    "react": ">=19.0.0",
+    "react-native": ">=0.83.0",
+    "react-native-webview": ">=13.16.0"
+  },
+  "devDependencies": {
+    "@types/react": "~19.2.10",
+    "typescript": "~5.9.2"
+  }
+}

package/src/Bridge.tsx ADDED Viewed

@@ -0,0 +1,169 @@
+/**
+ * <Image2PdfBridge /> — hidden WebView that runs the image2pdf wasm.
+ *
+ * The component renders as a 0×0 absolutely-positioned view; it does not
+ * take screen real estate. Consumers drive it via the imperative ref
+ * (returned by `useImage2Pdf`) rather than props, because the conversion
+ * flow is a multi-step request/response conversation, not a single
+ * declarative render.
+ *
+ * Why a hidden WebView and not direct WASM loading? React Native's Hermes
+ * engine (used in Expo Go) does not implement `WebAssembly`. The WebView
+ * runs WebKit/WKWebView (iOS) or Chrome/Blink (Android) which both do.
+ * Stashing the WASM inside a hidden WebView gives us access to it from
+ * the JS side via `postMessage` — the only bridge available without
+ * leaving Expo Go.
+ */
+import React, { forwardRef, useCallback, useEffect, useImperativeHandle, useRef, useState } from 'react';
+import { WebView, type WebViewMessageEvent } from 'react-native-webview';
+import type { WebView as WebViewType } from 'react-native-webview';
+import * as FileSystem from 'expo-file-system/legacy';
+import { debugLog, debugWarn } from './debugLog';
+import { loadBridgeBundle } from './loadBridgeBundle';
+import type { RnToWv, WvToRn } from './protocol';
+import { B64_CHUNK_SIZE } from './readUriBase64';
+export interface Image2PdfBridgeHandle {
+  /** Send a message into the WebView. */
+  post(message: RnToWv): void;
+  /** True once the bundle HTML URI is ready (not wasm-ready — wait for `ready` message). */
+  isReady(): boolean;
+}
+interface Props {
+  /** Optional callback for `ready` / `addOk` / `addErr` / `done` / `error`. */
+  onMessage?(msg: WvToRn): void;
+}
+export const Image2PdfBridge = forwardRef<Image2PdfBridgeHandle, Props>(function Image2PdfBridge(
+  { onMessage },
+  ref,
+) {
+  const webRef = useRef<WebViewType>(null);
+  const wasmUriRef = useRef<string | null>(null);
+  const [source, setSource] = useState<{ uri: string; allowingReadAccessToURL: string } | null>(
+    null,
+  );
+  const [loadError, setLoadError] = useState<string | null>(null);
+  const deliverWasmBytes = useCallback(async () => {
+    const wasmUri = wasmUriRef.current;
+    const web = webRef.current;
+    if (!wasmUri || !web) {
+      debugWarn('needWasm but bridge not ready');
+      web?.postMessage(JSON.stringify({ type: 'wasmErr', message: 'bridge not ready' }));
+      return;
+    }
+    try {
+      debugLog('reading wasm for WebView', wasmUri);
+      const t0 = Date.now();
+      const b64 = await FileSystem.readAsStringAsync(wasmUri, {
+        encoding: FileSystem.EncodingType.Base64,
+      });
+      const total = Math.ceil(b64.length / B64_CHUNK_SIZE);
+      for (let i = 0; i < total; i++) {
+        const chunk: RnToWv = {
+          type: 'wasmChunk',
+          index: i,
+          total,
+          data: b64.slice(i * B64_CHUNK_SIZE, (i + 1) * B64_CHUNK_SIZE),
+        };
+        web.postMessage(JSON.stringify(chunk));
+      }
+      debugLog('wasm delivered to WebView', { chunks: total, b64Len: b64.length, ms: Date.now() - t0 });
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      debugWarn('wasm delivery failed:', message);
+      web.postMessage(JSON.stringify({ type: 'wasmErr', message }));
+    }
+  }, []);
+  useEffect(() => {
+    let cancelled = false;
+    (async () => {
+      try {
+        const { htmlUri, readAccessUri, wasmUri } = await loadBridgeBundle();
+        if (!cancelled) {
+          wasmUriRef.current = wasmUri;
+          debugLog('bridge bundle ready', htmlUri, { readAccessUri, wasmUri });
+          setSource({ uri: htmlUri, allowingReadAccessToURL: readAccessUri });
+        }
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        debugWarn('bridge bundle load failed:', msg);
+        if (!cancelled) setLoadError(msg);
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+  useImperativeHandle(
+    ref,
+    () => ({
+      post(message) {
+        if (!webRef.current) {
+          debugWarn('Bridge.post before WebView mounted', message.type);
+          return;
+        }
+        debugLog('Bridge.post', message.type, message);
+        webRef.current.postMessage(JSON.stringify(message));
+      },
+      isReady() {
+        return source !== null;
+      },
+    }),
+    [source],
+  );
+  const handleMessage = (e: WebViewMessageEvent) => {
+    let parsed: WvToRn;
+    try {
+      parsed = JSON.parse(e.nativeEvent.data);
+    } catch {
+      if (__DEV__) console.warn('[image2pdf] ignoring non-JSON message:', e.nativeEvent.data);
+      return;
+    }
+    debugLog('Bridge.onMessage', parsed.type, parsed);
+    if (parsed.type === 'needWasm') {
+      void deliverWasmBytes();
+      return;
+    }
+    onMessage?.(parsed);
+  };
+  if (loadError) {
+    debugWarn('bridge not rendered:', loadError);
+    return null;
+  }
+  if (!source) {
+    return null;
+  }
+  return (
+    <WebView
+      ref={webRef}
+      originWhitelist={['*']}
+      source={source}
+      allowingReadAccessToURL={source.allowingReadAccessToURL}
+      style={{ width: 0, height: 0, position: 'absolute', top: -1, left: -1, opacity: 0 }}
+      allowFileAccess
+      allowFileAccessFromFileURLs
+      allowUniversalAccessFromFileURLs
+      mixedContentMode="always"
+      javaScriptEnabled
+      domStorageEnabled
+      onMessage={handleMessage}
+      onError={(e) => debugWarn('WebView error', e.nativeEvent)}
+      onHttpError={(e) => debugWarn('WebView HTTP error', e.nativeEvent)}
+      onLoadEnd={() => debugLog('WebView onLoadEnd', source.uri)}
+      containerStyle={{ backgroundColor: 'transparent' }}
+    />
+  );
+});

package/src/assets.d.ts ADDED Viewed

@@ -0,0 +1,9 @@
+declare module '*.bundle' {
+  const assetId: number;
+  export default assetId;
+}
+declare module '*.wasm' {
+  const assetId: number;
+  export default assetId;
+}

package/src/debugLog.ts ADDED Viewed

@@ -0,0 +1,12 @@
+/** Dev-only logging for the RN ↔ WebView bridge. Prefix grep: `[image2pdf]`. */
+export function debugLog(...args: unknown[]): void {
+  if (typeof __DEV__ !== 'undefined' && __DEV__) {
+    console.log('[image2pdf]', ...args);
+  }
+}
+export function debugWarn(...args: unknown[]): void {
+  if (typeof __DEV__ !== 'undefined' && __DEV__) {
+    console.warn('[image2pdf]', ...args);
+  }
+}

package/src/index.ts ADDED Viewed

@@ -0,0 +1,20 @@
+/**
+ * @skyprint/image2pdf-expo — public API.
+ *
+ * Mount `<result.Bridge />` once near the top of your React tree, then call
+ * `result.convert(uris, options?)` to produce a PDF.
+ *
+ *   const { convert, Bridge, status, error, result } = useImage2Pdf();
+ *   return (
+ *     <>
+ *       <Bridge />
+ *       <Button title="Convert" onPress={() => convert(pickedUris)} />
+ *     </>
+ *   );
+ */
+export { useImage2Pdf } from './useImage2Pdf';
+export { Image2PdfBridge } from './Bridge';
+export type { Image2PdfBridgeHandle } from './Bridge';
+export type { ConvertOptions, ConvertResult } from './types';
+export type { RnToWv, WvToRn } from './protocol';

package/src/loadBridgeBundle.ts ADDED Viewed

@@ -0,0 +1,79 @@
+/**
+ * Stage bridge.html + JS + wasm into one cache directory so relative
+ * `import './image2pdf.js'` and wasm `import.meta.url` resolution work inside
+ * the hidden WebView. Expo only bundles assets that are `require()`'d from RN;
+ * a lone `bridge.html` asset does NOT pull siblings along automatically.
+ */
+import { Asset } from 'expo-asset';
+import * as FileSystem from 'expo-file-system/legacy';
+import { debugLog, debugWarn } from './debugLog';
+/** Bump when bridge/wasm assets change to invalidate the on-device cache. */
+const BUNDLE_VERSION = '6';
+const BUNDLE_DIR = `${FileSystem.cacheDirectory}image2pdf-bridge/`;
+/** Metro asset modules — `.bundle` is in `assetExts`, not parsed as RN source. */
+const BUNDLE_FILES: Record<string, number> = {
+  'bridge.html': require('../assets/bridge.html'),
+  'bridge.js': require('../assets/bridge.bundle'),
+  'image2pdf.js': require('../assets/image2pdf.bundle'),
+  'image2pdf_bg.wasm': require('../assets/image2pdf_bg.wasm'),
+};
+export interface BridgeBundleSource {
+  htmlUri: string;
+  /** iOS WKWebView: sibling `file://` loads need read access to this directory. */
+  readAccessUri: string;
+  /** Staged wasm on disk — RN reads this and posts bytes into the WebView. */
+  wasmUri: string;
+}
+/**
+ * Returns `file://` URIs for bridge.html and its directory (for iOS read access).
+ */
+export async function loadBridgeBundle(): Promise<BridgeBundleSource> {
+  const stampPath = `${BUNDLE_DIR}.version`;
+  const stampInfo = await FileSystem.getInfoAsync(stampPath);
+  let cachedVersion: string | null = null;
+  if (stampInfo.exists) {
+    try {
+      cachedVersion = await FileSystem.readAsStringAsync(stampPath);
+    } catch {
+      cachedVersion = null;
+    }
+  }
+  if (cachedVersion !== BUNDLE_VERSION) {
+    debugLog('staging bridge bundle', { dir: BUNDLE_DIR, version: BUNDLE_VERSION });
+    await FileSystem.makeDirectoryAsync(BUNDLE_DIR, { intermediates: true });
+    for (const [destName, moduleId] of Object.entries(BUNDLE_FILES)) {
+      const asset = Asset.fromModule(moduleId);
+      await asset.downloadAsync();
+      if (!asset.localUri) {
+        throw new Error(`image2pdf bridge asset missing localUri: ${destName}`);
+      }
+      const dest = `${BUNDLE_DIR}${destName}`;
+      await FileSystem.copyAsync({ from: asset.localUri, to: dest });
+      debugLog('staged', destName, dest);
+    }
+    await FileSystem.writeAsStringAsync(stampPath, BUNDLE_VERSION);
+  }
+  const htmlUri = `${BUNDLE_DIR}bridge.html`;
+  const htmlInfo = await FileSystem.getInfoAsync(htmlUri);
+  if (!htmlInfo.exists) {
+    throw new Error(`bridge.html not found after staging: ${htmlUri}`);
+  }
+  return { htmlUri, readAccessUri: BUNDLE_DIR, wasmUri: `${BUNDLE_DIR}image2pdf_bg.wasm` };
+}
+/** @deprecated Use `loadBridgeBundle()` */
+export async function loadBridgeBundleUri(): Promise<string> {
+  const { htmlUri } = await loadBridgeBundle();
+  return htmlUri;
+}

package/src/protocol.ts ADDED Viewed

@@ -0,0 +1,43 @@
+/**
+ * postMessage protocol between the React Native side and the WebView running
+ * the image2pdf wasm.
+ *
+ * Wire format: each message is a single JSON object with a `type` field.
+ * Binary crosses the postMessage bridge as chunked base64 (RN→WV for images
+ * and wasm; WV→RN for the PDF). iOS WKWebView cannot `fetch()` local `file://`
+ * URIs, so RN reads files with expo-file-system and streams chunks.
+ */
+import type { ConvertOptions } from './types';
+export type RnToWv =
+  | { type: 'init'; options?: ConvertOptions }
+  /** @deprecated WebView cannot fetch local URIs on iOS — use `addBytes`. */
+  | { type: 'add'; id: string; uri: string }
+  /** Chunk of base64 image bytes for one `add` id. */
+  | { type: 'addBytes'; id: string; index: number; total: number; data: string }
+  /** Compose the PDF from all currently-loaded images. */
+  | { type: 'finalize'; requestId: string; options?: ConvertOptions }
+  /** Drop all loaded images (frees memory). */
+  | { type: 'reset' }
+  /** Chunk of base64 wasm bytes (RN cannot `fetch` file:// wasm on iOS). */
+  | { type: 'wasmChunk'; index: number; total: number; data: string }
+  /** RN failed to read staged wasm. */
+  | { type: 'wasmErr'; message: string };
+export type WvToRn =
+  | { type: 'needWasm' }
+  | { type: 'ready' }
+  | { type: 'addOk'; id: string }
+  | { type: 'addErr'; id: string; message: string }
+  | { type: 'done'; requestId: string; pdfBase64: string; pages: number; bytes: number }
+  | { type: 'error'; requestId: string; message: string }
+  /** Dev trace from bridge.js — forwarded to Metro console. */
+  | { type: 'log'; message: string };
+/** Map a (port, type) → handler structure. Internal — not exported from the package. */
+export interface ProtocolContext {
+  post(message: RnToWv): void;
+  onMessage(handler: (msg: WvToRn) => void): () => void;
+  onReady(handler: () => void): () => void;
+}

package/src/readUriBase64.ts ADDED Viewed

@@ -0,0 +1,39 @@
+/**
+ * Read a local image URI as base64 on the RN side.
+ * iOS WKWebView cannot `fetch()` picker `file://` URIs — bytes must cross via postMessage.
+ */
+import * as FileSystem from 'expo-file-system/legacy';
+/** Max base64 chars per postMessage chunk (iOS WebView limit). */
+export const B64_CHUNK_SIZE = 480_000;
+export async function readUriAsBase64(uri: string): Promise<string> {
+  try {
+    const info = await FileSystem.getInfoAsync(uri);
+    if (info.exists) {
+      return await FileSystem.readAsStringAsync(uri, {
+        encoding: FileSystem.EncodingType.Base64,
+      });
+    }
+  } catch {
+    // picker URIs are sometimes readable only via fetch
+  }
+  const res = await fetch(uri);
+  if (!res.ok) throw new Error(`read image failed: ${res.status}`);
+  return arrayBufferToBase64(await res.arrayBuffer());
+}
+function arrayBufferToBase64(buffer: ArrayBuffer): string {
+  const bytes = new Uint8Array(buffer);
+  let binary = '';
+  const chunk = 0x8000;
+  for (let i = 0; i < bytes.length; i += chunk) {
+    binary += String.fromCharCode.apply(
+      null,
+      Array.from(bytes.subarray(i, Math.min(i + chunk, bytes.length))),
+    );
+  }
+  return btoa(binary);
+}

package/src/types.ts ADDED Viewed

@@ -0,0 +1,33 @@
+/**
+ * Public options type for the Expo integration. Mirrors the Rust `ConvertOptions`
+ * shape, in camelCase so JS callers can write `{ marginMm: 5, dpi: 150 }`.
+ *
+ * This file is kept separate from `index.ts` so library consumers can import
+ * just the type without pulling in the React Native runtime.
+ */
+export interface ConvertOptions {
+  /** PDF document title. Defaults to "image2pdf". */
+  title?: string;
+  /** PDF document author metadata. */
+  author?: string;
+  /** Page margin in millimeters. Defaults to 10. */
+  marginMm?: number;
+  /**
+   * Assumed DPI for image-to-points conversion. Lower DPI = larger image on
+   * the page. Defaults to 75 (PDF default).
+   */
+  dpi?: number;
+}
+/** Returned by `useImage2Pdf().convert()`. */
+export interface ConvertResult {
+  /** `file://` URI of the saved PDF (in the cache directory). */
+  uri: string;
+  /** Size in bytes. */
+  bytes: number;
+  /** Number of pages in the generated PDF. */
+  pages: number;
+  /** Wall-clock milliseconds spent in `convert()` (WASM call only). */
+  durationMs: number;
+}