Migrating from PDFium

# gn args out/Release
is_debug = false
is_component_build = false
pdf_enable_v8 = false # No JavaScript support.
pdf_enable_xfa = false # No XFA forms; XFA also requires JavaScript.
pdf_is_complete_lib = true # One static library to link.

#include <string.h>

#include "public/fpdfview.h"

int main(void) {
  FPDF_LIBRARY_CONFIG config;
  memset(&config, 0, sizeof(config));
  config.version = 2;
  // Zeroed fields: the default font paths, and no V8 isolate of your own.
  FPDF_InitLibraryWithConfig(&config);

  // ... load, render, edit, and save documents ...

  FPDF_DestroyLibrary();
  return 0;
}

@sdk-pdf:registry=https://registry.sdk.pdf.net
//registry.sdk.pdf.net/:_authToken=${PDF_NET_REGISTRY_TOKEN}

npm install @sdk-pdf/react

import { useMemo } from 'react'
import { CONTENT_POLICY_PRESET, InteractionTool, PdfProviders } from '@sdk-pdf/react'
import '@sdk-pdf/react/style.css'

const textSelectTool: InteractionTool = { type: 'textSelect' }
const selectTool: InteractionTool = { type: 'select' }

export function App({ documentUrl, canEdit }: { documentUrl: string; canEdit: boolean }) {
  // The PDF application re-renders whenever a PdfProviders prop changes identity.
  const config = useMemo(
    () =>
      canEdit
        ? {
            initialInteractionTool: selectTool,
            initialContentPolicy: CONTENT_POLICY_PRESET.PDF_EDITOR,
          }
        : {
            initialInteractionTool: textSelectTool,
            initialContentPolicy: CONTENT_POLICY_PRESET.PDF_VIEWER,
          },
    [canEdit]
  )

  return (
    <PdfProviders {...config}>
      <DocumentLoader url={documentUrl} />
    </PdfProviders>
  )
}

FPDF_DOCUMENT load_document(const void* data, int size, FPDF_BYTESTRING password) {
  // `data` must stay valid until FPDF_CloseDocument().
  FPDF_DOCUMENT doc = FPDF_LoadMemDocument(data, size, password);
  if (!doc) {
    switch (FPDF_GetLastError()) {
      case FPDF_ERR_PASSWORD:
        // Password required or incorrect: ask for it, then load again.
        break;
      case FPDF_ERR_FORMAT:
        // Not a PDF, or corrupted.
        break;
      case FPDF_ERR_SECURITY:
        // Unsupported security scheme.
        break;
    }
    return NULL;
  }
  return doc;
}

// When the document is no longer needed; after this, the buffer can be freed.
FPDF_CloseDocument(doc);

import { useEffect, useRef, useState } from 'react'
import { InvalidPasswordError, useLoadPdf, useResetPdf } from '@sdk-pdf/react'

function DocumentLoader({ url }: { url: string }) {
  const [loadState, loadPdf] = useLoadPdf()
  const resetPdf = useResetPdf()
  const bytesRef = useRef<Uint8Array | null>(null)
  const lastUrlRef = useRef(url)
  const [isPasswordNeeded, setIsPasswordNeeded] = useState(false)

  // A new url: unload the old document and drop its bytes, so the next open() fetches the
  // new file.
  useEffect(() => {
    if (lastUrlRef.current === url) return
    lastUrlRef.current = url
    bytesRef.current = null
    setIsPasswordNeeded(false)
    resetPdf()
  }, [url, resetPdf])

  async function open(password?: string) {
    try {
      if (!bytesRef.current) {
        const response = await fetch(url)
        // Where PDFium reports FPDF_ERR_FILE, check the response yourself.
        if (!response.ok) throw new Error(`Loading failed with status ${response.status}`)
        bytesRef.current = new Uint8Array(await response.arrayBuffer())
      }

      // The document reads from the buffer it receives: keep the original for a retry.
      await loadPdf(bytesRef.current.slice(), { password })
      setIsPasswordNeeded(false)
    } catch (error) {
      // The counterpart of FPDF_ERR_PASSWORD: ask for the password, then call
      // open(password).
      if (error instanceof InvalidPasswordError) setIsPasswordNeeded(true)
      else showError(error)
    }
  }

  if (isPasswordNeeded) return <PasswordPrompt onSubmit={open} />
  if (loadState.status === 'initial')
    return <button onClick={() => void open()}>Open</button>
  if (loadState.status === 'loading') return <p>Loading the document…</p>

  return <PdfApplication />
}

import { useResetPdf } from '@sdk-pdf/react'

function CloseButton() {
  const resetPdf = useResetPdf()

  // The load state returns to 'initial', and DocumentLoader shows the Open button again.
  return <button onClick={() => resetPdf()}>Close</button>
}

// One page at `scale`: at 1.0, one bitmap pixel per point.
FPDF_PAGE page = FPDF_LoadPage(doc, page_index);
FORM_OnAfterLoadPage(page, form);

int width = (int)(FPDF_GetPageWidth(page) * scale);
int height = (int)(FPDF_GetPageHeight(page) * scale);
FPDF_BITMAP bitmap = FPDFBitmap_Create(width, height, 0);
FPDFBitmap_FillRect(bitmap, 0, 0, width, height, 0xFFFFFFFF);

// The page content and non-interactive annotations, then the form widgets.
FPDF_RenderPageBitmap(bitmap, page, 0, 0, width, height, 0, FPDF_ANNOT);
FPDF_FFLDraw(form, bitmap, page, 0, 0, width, height, 0, FPDF_ANNOT);

// BGRx pixels with `stride` bytes per row, for your toolkit to draw.
blit_bgrx(FPDFBitmap_GetBuffer(bitmap), width, height, FPDFBitmap_GetStride(bitmap));
FPDFBitmap_Destroy(bitmap);

// The page stays loaded while it's visible; FORM_OnBeforeClosePage() and
// FPDF_ClosePage() release it.

import { useViewportAutoFitScale, Viewport } from '@sdk-pdf/react'

function PdfApplication() {
  // Each document opens fitted to the viewport width.
  useViewportAutoFitScale('width')

  return (
    <div style={{ display: 'grid', gridTemplateRows: 'auto 1fr', height: '100vh' }}>
      {/* Your toolbar: the navigation, zoom, history, and save controls from this
         guide. */}
      <Toolbar />
      {/* The viewport fills its parent, so the parent needs an explicit size. */}
      <div style={{ minHeight: 0 }}>
        <Viewport />
      </div>
    </div>
  )
}

import { useEffect } from 'react'
import { useViewportFitScale, useViewportScale } from '@sdk-pdf/react'

function ZoomControls() {
  const [scale, setScale] = useViewportScale()
  const getFitScale = useViewportFitScale()

  // Every scale change, whatever the source: controls, gestures, or an auto fit.
  useEffect(() => saveZoomPreference(scale), [scale])

  function fitPage() {
    // The smaller fit shows whole pages in both directions.
    const { fitWidthScale, fitHeightScale } = getFitScale()
    setScale(Math.min(fitWidthScale, fitHeightScale))
  }

  return (
    <div role="toolbar">
      <button onClick={() => setScale(scale / 1.25)}>Zoom out</button>
      <span>{Math.round(scale * 100)}%</span>
      <button onClick={() => setScale(scale * 1.25)}>Zoom in</button>
      <button onClick={() => setScale(getFitScale().fitWidthScale)}>Fit width</button>
      <button onClick={fitPage}>Fit page</button>
    </div>
  )
}

// Your viewer keeps the current page index and scrolls to it.
static void go_to_page(Viewer* viewer, int page_index) {
  if (page_index < 0 || page_index >= FPDF_GetPageCount(viewer->doc)) {
    return;
  }
  viewer->current_page = page_index;
  scroll_to_page(viewer, page_index);
}

// A click at a point in page coordinates, from FPDF_DeviceToPage().
static void on_click(Viewer* viewer, FPDF_PAGE page, double page_x, double page_y) {
  FPDF_LINK link = FPDFLink_GetLinkAtPoint(page, page_x, page_y);
  if (!link) {
    return;
  }
  // NULL when the link carries an action instead: see FPDFLink_GetAction().
  FPDF_DEST dest = FPDFLink_GetDest(viewer->doc, link);
  if (dest) {
    go_to_page(viewer, FPDFDest_GetDestPageIndex(viewer->doc, dest));
  }
}

import { useState } from 'react'
import { useCurrentPageId, usePages, useScrollToPage } from '@sdk-pdf/react'

function GoToPage() {
  const pages = usePages()
  const currentPageId = useCurrentPageId()
  const scrollToPage = useScrollToPage()
  const [pageNumber, setPageNumber] = useState('')

  // -1 while there is no current page yet.
  const currentIndex = pages.findIndex((page) => page.id === currentPageId)

  return (
    <form
      onSubmit={(event) => {
        event.preventDefault()
        // People type 1-based numbers; the list is 0-based, like PDFium page indices.
        const page = pages[Number(pageNumber) - 1]
        if (page) scrollToPage(page.id, { behavior: 'smooth' })
      }}
    >
      <input
        aria-label="Page number"
        inputMode="numeric"
        placeholder={currentIndex === -1 ? '' : String(currentIndex + 1)}
        value={pageNumber}
        onChange={(event) => setPageNumber(event.currentTarget.value)}
      />
      <span>of {pages.length}</span>
    </form>
  )
}

// Insert a blank US Letter page (612 × 792 points) at index 2.
FPDF_PAGE blank = FPDFPage_New(doc, 2, 612, 792);
FPDF_ClosePage(blank);

// Delete the page at index 4.
FPDFPage_Delete(doc, 4);

// Move the page at index 5 to the front (experimental API).
int pages_to_move[] = {5};
FPDF_MovePages(doc, pages_to_move, 1, 0);

// Set the first page's rotation to 90 degrees clockwise: values 0 to 3 are quarter turns.
FPDF_PAGE first = FPDF_LoadPage(doc, 0);
FPDFPage_SetRotation(first, 1);
FPDF_ClosePage(first);

// Append pages 1 to 3 of another document (the range is 1-based).
FPDF_ImportPages(doc, other_doc, "1-3", FPDF_GetPageCount(doc));

import {
  usePageCreate,
  usePageDelete,
  usePageMove,
  usePages,
  useSetPageRotation,
} from '@sdk-pdf/react'

// Index-based helpers for code ported from PDFium; new code passes page ids directly.
function usePageOperations() {
  const pages = usePages()
  const createPage = usePageCreate()
  const deletePages = usePageDelete()
  const { moveBefore } = usePageMove()
  const setPageRotation = useSetPageRotation()

  return {
    // FPDFPage_New(doc, index, width, height): new pages go after a page, or at the end.
    insertBlankPage(index: number, width: number, height: number) {
      const previousPage = pages[Math.min(index, pages.length) - 1]
      const pageId = createPage(width, height, previousPage?.id)
      // Without a previous page, the new page belongs at the start.
      if (!previousPage) moveBefore(pageId)
      return pageId
    },
    // FPDFPage_Delete(doc, index)
    deletePage(index: number) {
      deletePages(pages[index].id)
    },
    // FPDF_MovePages(doc, [index], 1, 0)
    moveToFront(index: number) {
      moveBefore(pages[index].id)
    },
    // FPDFPage_SetRotation(page, quarterTurns): both set an absolute rotation.
    setRotation(index: number, quarterTurns: number) {
      setPageRotation(pages[index].id, quarterTurns * 90)
    },
  }
}

// A 120-pixel-wide thumbnail of the page at `page_index`.
FPDF_PAGE page = FPDF_LoadPage(doc, page_index);
double scale = 120.0 / FPDF_GetPageWidth(page);
int width = 120;
int height = (int)(FPDF_GetPageHeight(page) * scale);

FPDF_BITMAP thumbnail = FPDFBitmap_Create(width, height, 0);
FPDFBitmap_FillRect(thumbnail, 0, 0, width, height, 0xFFFFFFFF);
// Without FPDF_FFLDraw, form widgets don't appear.
FPDF_RenderPageBitmap(thumbnail, page, 0, 0, width, height, 0, FPDF_ANNOT);
FPDF_ClosePage(page);

// Your cache owns the bitmap until FPDFBitmap_Destroy().
cache_thumbnail(page_index, thumbnail);

import { PageCanvas, useCurrentPageId, usePages, useScrollToPage } from '@sdk-pdf/react'

function ThumbnailsSidebar() {
  const pages = usePages()
  const currentPageId = useCurrentPageId()
  const scrollToPage = useScrollToPage()

  return (
    <nav aria-label="Pages">
      {pages.map((page, index) => (
        <button
          key={page.id}
          aria-current={page.id === currentPageId ? 'page' : undefined}
          onClick={() => scrollToPage(page.id)}
        >
          {/* Style .thumbnail to 120px wide: the render resolution follows the CSS
             size. */}
          <PageCanvas
            pageId={page.id}
            className="thumbnail"
            role="img"
            aria-label={`Page ${index + 1}`}
          />
        </button>
      ))}
    </nav>
  )
}

#include <string.h>

#include "public/fpdf_formfill.h"

static FPDF_FORMFILLINFO form_info;

FPDF_FORMHANDLE init_forms(FPDF_DOCUMENT doc) {
  memset(&form_info, 0, sizeof(form_info));
  form_info.version = 1;
  // Your viewer's callbacks: repaint an area, set the cursor, run timers, and look up
  // pages.
  form_info.FFI_Invalidate = on_invalidate;
  form_info.FFI_SetCursor = on_set_cursor;
  form_info.FFI_SetTimer = on_set_timer;
  form_info.FFI_KillTimer = on_kill_timer;
  form_info.FFI_GetPage = on_get_page;
  // Called when any field value changes.
  form_info.FFI_OnChange = on_change;

  // form_info must stay valid until FPDFDOC_ExitFormFillEnvironment().
  FPDF_FORMHANDLE form = FPDFDOC_InitFormFillEnvironment(doc, &form_info);
  FPDF_SetFormFieldHighlightColor(form, FPDF_FORMFIELD_UNKNOWN, 0xFFE4DD);
  return form;
}

// After FPDF_LoadPage(), and before FPDF_ClosePage():
FORM_OnAfterLoadPage(page, form);
FORM_OnBeforeClosePage(page, form);

// Your window's input, with positions converted by FPDF_DeviceToPage():
FORM_OnMouseMove(form, page, modifiers, page_x, page_y);
FORM_OnLButtonDown(form, page, modifiers, page_x, page_y);
FORM_OnLButtonUp(form, page, modifiers, page_x, page_y);
FORM_OnKeyDown(form, page, key_code, modifiers);
FORM_OnChar(form, page, char_code, modifiers);

import {
  CheckboxWidget,
  TextWidget,
  useScrollToBlock,
  useWidgets,
  useWidgetValue,
  Widget,
} from '@sdk-pdf/react'

function FormFieldList() {
  const { widgets, isLoaded } = useWidgets()
  const scrollToBlock = useScrollToBlock()

  // The list is partial until every page with widgets has loaded.
  if (!isLoaded) return <p>Loading the form…</p>

  return (
    <ul>
      {widgets.map((widget) => (
        <li key={widget.id}>
          {/* Jump to the widget in the main view. */}
          <button
            onClick={() =>
              scrollToBlock(widget.id, { behavior: 'smooth', vertical: 'center' })
            }
          >
            {widget.fieldName}
          </button>
          <FieldInput widget={widget} />
        </li>
      ))}
    </ul>
  )
}

function FieldInput({ widget }: { widget: Widget }) {
  switch (widget.widgetType) {
    case 'text':
      return <TextInput widget={widget} />
    case 'checkbox':
      return <CheckboxInput widget={widget} />
    default:
      return null
  }
}

function TextInput({ widget }: { widget: TextWidget }) {
  // Typing in the main view and undo update the value here too.
  const [value, setValue] = useWidgetValue(widget)

  return (
    <input
      aria-label={widget.fieldName}
      value={value}
      onChange={(event) => setValue(event.currentTarget.value)}
    />
  )
}

function CheckboxInput({ widget }: { widget: CheckboxWidget }) {
  const [isChecked, setIsChecked] = useWidgetValue(widget)

  return (
    <input
      type="checkbox"
      aria-label={widget.fieldName}
      checked={isChecked}
      onChange={(event) => setIsChecked(event.currentTarget.checked)}
    />
  )
}

#include <stdlib.h>

#include "public/fpdf_text.h"

FPDF_TEXTPAGE text_page = FPDFText_LoadPage(page);
int count = FPDFText_CountChars(text_page);

// `count` UCS-2 values plus a terminator.
unsigned short* text = malloc((count + 1) * sizeof(unsigned short));
FPDFText_GetText(text_page, 0, count, text);

// Every match on the page, with rectangles to highlight.
FPDF_SCHHANDLE search = FPDFText_FindStart(text_page, query, 0, 0);
while (FPDFText_FindNext(search)) {
  int start = FPDFText_GetSchResultIndex(search);
  int length = FPDFText_GetSchCount(search);
  int rect_count = FPDFText_CountRects(text_page, start, length);
  for (int i = 0; i < rect_count; i++) {
    double left, top, right, bottom;
    FPDFText_GetRect(text_page, i, &left, &top, &right, &bottom);
    add_highlight(page_index, left, top, right, bottom);
  }
}
FPDFText_FindClose(search);

free(text);
FPDFText_ClosePage(text_page);

import { useDocumentSearch } from '@sdk-pdf/react'

function SearchBar() {
  const {
    criteria,
    matches,
    activeMatchIndex,
    status,
    setSearchCriteria,
    goToNextMatch,
    goToPreviousMatch,
  } = useDocumentSearch()

  return (
    <div role="search">
      <input
        value={criteria.query}
        onChange={(event) =>
          setSearchCriteria({ ...criteria, query: event.currentTarget.value })
        }
      />
      <label>
        <input
          type="checkbox"
          checked={criteria.isWholeWord}
          onChange={(event) =>
            setSearchCriteria({ ...criteria, isWholeWord: event.currentTarget.checked })
          }
        />
        Whole words
      </label>
      <span>
        {status === 'searching'
          ? 'Searching…'
          : `${activeMatchIndex + 1} of ${matches.length}`}
      </span>
      <button disabled={matches.length === 0} onClick={goToPreviousMatch}>
        Previous
      </button>
      <button disabled={matches.length === 0} onClick={goToNextMatch}>
        Next
      </button>
    </div>
  )
}

// FPDF_WIDESTRING text is UTF-16LE.
static const FPDF_WCHAR kApproved[] = {'A', 'p', 'p', 'r', 'o', 'v', 'e', 'd', 0};

// A line of text in a standard font, moved to (72, 720) in page coordinates.
FPDF_PAGEOBJECT text = FPDFPageObj_NewTextObj(doc, "Helvetica", 12.0f);
FPDFText_SetText(text, kApproved);
FPDFPageObj_Transform(text, 1, 0, 0, 1, 72, 720);
FPDFPage_InsertObject(page, text);

// A JPEG image, placed and sized with a transform matrix.
FPDF_PAGEOBJECT image = FPDFPageObj_NewImageObj(doc);
FPDFImageObj_LoadJpegFileInline(NULL, 0, image, &jpeg_access);
FPDFImageObj_SetMatrix(image, 200, 0, 0, 100, 72, 500);
FPDFPage_InsertObject(page, image);

// Remove the first page object; the caller owns it afterwards (experimental API).
FPDF_PAGEOBJECT first = FPDFPage_GetObject(page, 0);
if (FPDFPage_RemoveObject(page, first)) {
  FPDFPageObj_Destroy(first);
}

// Without this, the changes are lost on save or reload.
FPDFPage_GenerateContent(page);

import { useParagraphCreate, useProgrammaticEditor } from '@sdk-pdf/react'

// Replaces FPDFPageObj_NewTextObj, FPDFText_SetText, and FPDFPage_InsertObject.
function useAddText() {
  const createParagraph = useParagraphCreate()
  const { getParagraphEditor } = useProgrammaticEditor()

  return async (pageId: string, text: string) => {
    // The position in user-space units.
    const paragraphId = await createParagraph(pageId, 72, 720)
    const editor = getParagraphEditor(paragraphId)
    // The paragraph may be gone already: deleted by an undo.
    if (!editor) return undefined

    editor.selectAll()
    editor.deleteAll()
    editor.insertText(text)
    return paragraphId
  }
}

import {
  CONTENT_POLICY_PRESET,
  InteractionTool,
  stageImage,
  useInteractionTool,
  useSetInteractionMode,
} from '@sdk-pdf/react'

const selectTool: InteractionTool = { type: 'select' }
const addTextTool: InteractionTool = { type: 'addText' }

function InsertToolbar() {
  const interactionTool = useInteractionTool()
  const setInteractionMode = useSetInteractionMode()

  async function placeImage(file: File) {
    // Any image the browser can decode, where PDFium loads JPEG files or bitmaps.
    const image = await stageImage(file)
    // The next click on a page places the image as a stamp annotation.
    // Placing images is editing, so switch the policy with the tool.
    setInteractionMode({ type: 'addImage', image }, CONTENT_POLICY_PRESET.PDF_EDITOR)
  }

  return (
    <div role="toolbar">
      {/* Select, move, and resize blocks: the counterpart of your FPDFPageObj_Transform
         UI. */}
      <button
        aria-pressed={interactionTool.type === 'select'}
        onClick={() => setInteractionMode(selectTool, CONTENT_POLICY_PRESET.PDF_EDITOR)}
      >
        Select
      </button>
      <button
        aria-pressed={interactionTool.type === 'addText'}
        onClick={() => setInteractionMode(addTextTool, CONTENT_POLICY_PRESET.PDF_EDITOR)}
      >
        Add text
      </button>
      <label>
        Add image
        <input
          type="file"
          accept="image/*"
          onChange={(event) => {
            const file = event.currentTarget.files?.[0]
            if (file) placeImage(file).catch(showError)
          }}
        />
      </label>
    </div>
  )
}

// Toolbar buttons: undo and redo inside the focused form field.
static void on_undo(Viewer* viewer) {
  if (FORM_CanUndo(viewer->form, viewer->focused_page)) {
    FORM_Undo(viewer->form, viewer->focused_page);
  }
}

static void on_redo(Viewer* viewer) {
  if (FORM_CanRedo(viewer->form, viewer->focused_page)) {
    FORM_Redo(viewer->form, viewer->focused_page);
  }
}

// FPDF_FORMFILLINFO.FFI_OnChange: some field value changed.
static void on_change(FPDF_FORMFILLINFO* info) {
  set_unsaved_changes(1);
}

import { useMemo } from 'react'
import { useHotkeys, useUndoRedo } from '@sdk-pdf/react'

function HistoryButtons() {
  const { undo, redo, canUndo, canRedo } = useUndoRedo()

  // Window-level shortcuts; the mapping must be memoized.
  useHotkeys(useMemo(() => ({ 'Mod-z': undo, 'Shift-Mod-z': redo }), [undo, redo]))

  return (
    <div role="toolbar">
      <button disabled={!canUndo} onClick={undo}>
        Undo
      </button>
      <button disabled={!canRedo} onClick={redo}>
        Redo
      </button>
    </div>
  )
}

#include <stdio.h>

#include "public/fpdf_save.h"

typedef struct {
  FPDF_FILEWRITE base;  // First member, so PDFium's pointer is also ours.
  FILE* file;
} FileWriter;

static int write_block(FPDF_FILEWRITE* self, const void* data, unsigned long size) {
  FileWriter* writer = (FileWriter*)self;
  return fwrite(data, 1, size, writer->file) == size;
}

FPDF_BOOL save_document(FPDF_DOCUMENT doc, FILE* file) {
  FileWriter writer = {{1, write_block}, file};  // FPDF_FILEWRITE version 1.
  // Flags: 0, or FPDF_INCREMENTAL or FPDF_NO_INCREMENTAL (not both),
  // optionally combined with FPDF_REMOVE_SECURITY.
  return FPDF_SaveAsCopy(doc, &writer.base, 0);
}

import { useRef, useState } from 'react'
import {
  useDocumentRevision,
  useDocumentRevisionGetter,
  useDocumentSaving,
} from '@sdk-pdf/react'

function SaveControls({ documentUrl }: { documentUrl: string }) {
  const revision = useDocumentRevision()
  const getRevision = useDocumentRevisionGetter()
  // The revision on the server: the loaded document's revision until the first save.
  const [savedRevision, setSavedRevision] = useState(revision)
  // One save at a time, so an overlapping save can't mark a failed upload as saved.
  const isSavingRef = useRef(false)
  const { prepareDocument, downloadDocument } = useDocumentSaving()

  // Replaces the FFI_OnChange flag: every edit, including page edits; undoing back to the
  // saved state clears it.
  const hasUnsavedChanges = revision !== savedRevision

  async function save() {
    if (!hasUnsavedChanges || isSavingRef.current) return
    isSavingRef.current = true
    try {
      // Edits made after the save starts may be missing from the saved bytes, so only
      // this revision becomes saved.
      const startRevision = getRevision()
      // Replaces FPDFPage_GenerateContent and FPDF_SaveAsCopy.
      // The bytes go to fetch, so don't hand out the loaded document's buffer.
      const bytes = await prepareDocument({ returnOriginalIfUnchanged: false })
      const response = await fetch(documentUrl, {
        method: 'PUT',
        body: bytes as BodyInit,
      })
      // A failed upload keeps the unsaved-changes indicator.
      if (!response.ok) throw new Error(`Saving failed with status ${response.status}`)

      setSavedRevision(startRevision)
    } finally {
      isSavingRef.current = false
    }
  }

  return (
    <div role="toolbar">
      <button onClick={() => save().catch(showError)}>Save</button>
      <button onClick={() => void downloadDocument()}>Download</button>
      {hasUnsavedChanges && <span>Unsaved changes</span>}
    </div>
  )
}

#include "public/fpdf_ext.h"

static void on_unsupported(UNSUPPORT_INFO* info, int type) {
  // One of FPDF_UNSP_*, such as FPDF_UNSP_DOC_XFAFORM or FPDF_UNSP_ANNOT_3DANNOT.
  log_warning("PDFium: unsupported feature", type);
}

static UNSUPPORT_INFO unsupported_info = {1, on_unsupported};

void set_up_diagnostics(void) {
  FSDK_SetUnSpObjProcessHandler(&unsupported_info);
}

FPDF_DOCUMENT open_document(const void* data, int size) {
  FPDF_DOCUMENT doc = FPDF_LoadMemDocument(data, size, NULL);
  if (!doc) {
    // FPDF_GetLastError() explains failed loads; other calls signal failure
    // through their return value.
    report_load_error(FPDF_GetLastError());
  }
  return doc;
}

import { useEffect } from 'react'
import { InvalidPasswordError, logMessages, LogLevel, useLoadPdf } from '@sdk-pdf/react'

function useSdkLogs() {
  useEffect(() => {
    // Replaces FSDK_SetUnSpObjProcessHandler; the SDK never prints to the console.
    const unsubscribe = logMessages.on('message', (logMessage) => {
      if (logMessage.level >= LogLevel.Warning)
        reportToMonitoring(logMessage.message, logMessage.data)
    })
    return () => {
      unsubscribe()
    }
  }, [])
}

function useOpenDocument() {
  const [, loadPdf] = useLoadPdf()

  return async (data: Uint8Array) => {
    try {
      // Pass a copy and keep `data` for a password retry.
      await loadPdf(data.slice())
    } catch (error) {
      // Replaces the switch on FPDF_GetLastError(): narrow with instanceof.
      if (error instanceof InvalidPasswordError) askForPassword()
      else showError(error)
    }
  }
}

FPDFText_ClosePage(text_page);
FPDFBitmap_Destroy(bitmap);

FORM_DoPageAAction(page, form, FPDFPAGE_AACTION_CLOSE);
FORM_OnBeforeClosePage(page, form);
FPDF_ClosePage(page);

FORM_DoDocumentAAction(form, FPDFDOC_AACTION_WC);
FPDFDOC_ExitFormFillEnvironment(form);
FPDF_CloseDocument(doc);

// Once per process, after closing everything else.
FPDF_DestroyLibrary();