@skyprint/image2pdf-expo 0.1.0

package/src/useImage2Pdf.tsx

@@ -0,0 +1,296 @@
+/**
+ * `useImage2Pdf()` — the public hook. Hides the WebView and the request/
+ * response protocol behind a single `convert(imageUris, options?)` call
+ * returning a `ConvertResult`.
+ *
+ * State machine:
+ *   idle → ready → adding → finalizing → done → idle
+ *   any → error → idle
+ *
+ * Callers should treat `convert()` as single-shot: if invoked while busy,
+ * it throws — the bridge is not designed for concurrent conversions.
+ */
+
+import { useCallback, useEffect, useRef, useState } from 'react';
+// SDK 55+: legacy helpers moved out of the default `expo-file-system` entry.
+import * as FileSystem from 'expo-file-system/legacy';
+
+import { Image2PdfBridge, type Image2PdfBridgeHandle } from './Bridge';
+import { debugLog, debugWarn } from './debugLog';
+import { B64_CHUNK_SIZE, readUriAsBase64 } from './readUriBase64';
+import type { ConvertOptions, ConvertResult } from './types';
+import type { WvToRn } from './protocol';
+
+type Status = 'idle' | 'ready' | 'adding' | 'finalizing' | 'done' | 'error';
+
+interface PendingFinalize {
+  resolve: (r: ConvertResult) => void;
+  reject: (e: Error) => void;
+}
+
+interface ConvertSession {
+  requestId: string;
+  uris: string[];
+  /** Index of the add we're waiting on (0 .. uris.length-1), then uris.length when all added. */
+  pendingIndex: number;
+  options?: ConvertOptions;
+  startedAt: number;
+}
+
+export interface UseImage2PdfReturn {
+  /** Convert the listed image file URIs to a PDF. */
+  convert(imageUris: string[], options?: ConvertOptions): Promise<ConvertResult>;
+  /** The bridge component to mount once. Place it near the top of your tree. */
+  Bridge: React.FC;
+  /** Current status. */
+  status: Status;
+  /** Last error, if any. Cleared on the next successful convert(). */
+  error: Error | null;
+  /** Last result, if any. */
+  result: ConvertResult | null;
+}
+
+let idCounter = 0;
+const nextId = () => `${Date.now()}-${++idCounter}`;
+
+export function useImage2Pdf(): UseImage2PdfReturn {
+  const bridgeRef = useRef<Image2PdfBridgeHandle>(null);
+  const pendingRef = useRef<PendingFinalize | null>(null);
+  const sessionRef = useRef<ConvertSession | null>(null);
+  const wasmReadyRef = useRef(false);
+  const [status, setStatus] = useState<Status>('idle');
+  const [error, setError] = useState<Error | null>(null);
+  const [result, setResult] = useState<ConvertResult | null>(null);
+
+  const failConvert = useCallback((err: Error) => {
+    debugWarn('convert failed:', err.message);
+    sessionRef.current = null;
+    const pending = pendingRef.current;
+    pendingRef.current = null;
+    pending?.reject(err);
+    setError(err);
+    setStatus('error');
+  }, []);
+
+  const postAdd = useCallback(
+    async (session: ConvertSession, index: number) => {
+      const id = `${session.requestId}-${index}`;
+      const uri = session.uris[index];
+      try {
+        debugLog('RN reading image', { id, uri });
+        const t0 = Date.now();
+        const b64 = await readUriAsBase64(uri);
+        const total = Math.ceil(b64.length / B64_CHUNK_SIZE);
+        for (let i = 0; i < total; i++) {
+          bridgeRef.current?.post({
+            type: 'addBytes',
+            id,
+            index: i,
+            total,
+            data: b64.slice(i * B64_CHUNK_SIZE, (i + 1) * B64_CHUNK_SIZE),
+          });
+        }
+        debugLog('RN→WV addBytes', { id, chunks: total, b64Len: b64.length, ms: Date.now() - t0 });
+      } catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        failConvert(new Error(`failed to read image (${id}): ${message}`));
+      }
+    },
+    [failConvert],
+  );
+
+  const postFinalize = useCallback((session: ConvertSession) => {
+    debugLog('RN→WV finalize', {
+      requestId: session.requestId,
+      images: session.uris.length,
+      msSinceStart: Date.now() - session.startedAt,
+    });
+    setStatus('finalizing');
+    bridgeRef.current?.post({
+      type: 'finalize',
+      requestId: session.requestId,
+      options: session.options,
+    });
+  }, []);
+
+  // Bridges message events into a Promise + state-machine transition.
+  const handleMessage = useCallback(
+    (msg: WvToRn) => {
+      switch (msg.type) {
+        case 'log':
+          debugLog('[WV]', msg.message);
+          break;
+
+        case 'ready':
+          debugLog('WV→RN ready');
+          wasmReadyRef.current = true;
+          setStatus('ready');
+          break;
+
+        case 'addOk': {
+          debugLog('WV→RN addOk', msg.id);
+          const session = sessionRef.current;
+          if (!session) {
+            debugWarn('addOk with no active session', msg.id);
+            break;
+          }
+          const expectedId = `${session.requestId}-${session.pendingIndex}`;
+          if (msg.id !== expectedId) {
+            debugWarn('addOk id mismatch', { got: msg.id, expected: expectedId });
+            break;
+          }
+          session.pendingIndex += 1;
+          debugLog('addOk progress', `${session.pendingIndex}/${session.uris.length}`);
+          if (session.pendingIndex < session.uris.length) {
+            void postAdd(session, session.pendingIndex);
+          } else {
+            postFinalize(session);
+          }
+          break;
+        }
+
+        case 'addErr': {
+          debugWarn('WV→RN addErr', msg.id, msg.message);
+          const session = sessionRef.current;
+          if (session && msg.id.startsWith(session.requestId)) {
+            failConvert(new Error(`image add failed (${msg.id}): ${msg.message}`));
+          }
+          break;
+        }
+
+        case 'done': {
+          debugLog('WV→RN done', {
+            requestId: msg.requestId,
+            pages: msg.pages,
+            bytes: msg.bytes,
+            b64Len: msg.pdfBase64.length,
+          });
+          const pending = pendingRef.current;
+          if (!pending) {
+            debugWarn('stray done message:', msg.requestId);
+            return;
+          }
+          pendingRef.current = null;
+          sessionRef.current = null;
+          (async () => {
+            try {
+              const outUri = `${FileSystem.cacheDirectory}image2pdf-${msg.requestId}.pdf`;
+              debugLog('writing PDF to cache', outUri);
+              const t0 = Date.now();
+              await FileSystem.writeAsStringAsync(outUri, msg.pdfBase64, {
+                encoding: 'base64',
+              });
+              debugLog('writeAsStringAsync ok', { ms: Date.now() - t0 });
+              const fileInfo = await FileSystem.getInfoAsync(outUri);
+              debugLog('getInfoAsync', fileInfo);
+              const res: ConvertResult = {
+                uri: outUri,
+                bytes: fileInfo.exists ? (fileInfo.size ?? msg.bytes) : msg.bytes,
+                pages: msg.pages,
+                durationMs: 0,
+              };
+              pending.resolve(res);
+              setResult(res);
+              setStatus('done');
+              debugLog('convert complete', res);
+            } catch (e) {
+              const err = e instanceof Error ? e : new Error(String(e));
+              debugWarn('post-done file write failed:', err.message);
+              pending.reject(err);
+              setError(err);
+              setStatus('error');
+            }
+          })();
+          break;
+        }
+
+        case 'error': {
+          debugWarn('WV→RN error', msg.requestId, msg.message);
+          sessionRef.current = null;
+          const pending = pendingRef.current;
+          pendingRef.current = null;
+          const err = new Error(msg.message);
+          pending?.reject(err);
+          setError(err);
+          setStatus('error');
+          break;
+        }
+      }
+    },
+    [failConvert, postAdd, postFinalize],
+  );
+
+  const convert = useCallback(
+    async (imageUris: string[], options?: ConvertOptions): Promise<ConvertResult> => {
+      if (!bridgeRef.current) {
+        throw new Error('Image2PdfBridge is not mounted; render <result.Bridge /> first');
+      }
+      if (status !== 'ready' && status !== 'done' && status !== 'error') {
+        throw new Error(
+          status === 'idle'
+            ? 'Image2PdfBridge is still loading wasm (wait for status=ready)'
+            : `Image2PdfBridge is busy (status=${status})`,
+        );
+      }
+      if (imageUris.length === 0) {
+        throw new Error('at least one image is required');
+      }
+
+      const requestId = nextId();
+      debugLog('convert start', { requestId, count: imageUris.length, uris: imageUris });
+
+      setError(null);
+      setStatus('adding');
+
+      return new Promise<ConvertResult>((resolve, reject) => {
+        const t0 = Date.now();
+        pendingRef.current = {
+          resolve: (r) => resolve({ ...r, durationMs: Date.now() - t0 }),
+          reject,
+        };
+        sessionRef.current = {
+          requestId,
+          uris: imageUris,
+          pendingIndex: 0,
+          options,
+          startedAt: Date.now(),
+        };
+
+        debugLog('RN→WV reset');
+        bridgeRef.current!.post({ type: 'reset' });
+        void postAdd(sessionRef.current, 0);
+      });
+    },
+    [status, postAdd],
+  );
+
+  // Dev: warn if finalize hangs (wasm / base64 / postMessage).
+  useEffect(() => {
+    if (status !== 'finalizing') return;
+    const session = sessionRef.current;
+    const t = setTimeout(() => {
+      debugWarn('still finalizing after 30s', {
+        requestId: session?.requestId,
+        pending: !!pendingRef.current,
+      });
+    }, 30_000);
+    return () => clearTimeout(t);
+  }, [status]);
+
+  const stableHandler = useCallback(handleMessage, [handleMessage]);
+  const Bridge = useCallback(
+    () => <Image2PdfBridge ref={bridgeRef} onMessage={stableHandler} />,
+    [stableHandler],
+  );
+
+  useEffect(() => {
+    if (status === 'done' || (status === 'error' && wasmReadyRef.current)) {
+      const t = setTimeout(() => {
+        setStatus((s) => (s === 'done' || s === 'error' ? 'ready' : s));
+      }, 200);
+      return () => clearTimeout(t);
+    }
+  }, [status]);
+
+  return { convert, Bridge, status, error, result };
+}