Migrating from Aspose.PDF for .NET

dotnet add package Aspose.PDF

// Without a license, Aspose.PDF runs in evaluation mode: an evaluation watermark,
// and only the first four pages of a document are processed.
var license = new Aspose.Pdf.License();
license.SetLicense("Aspose.Pdf.lic");

@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 reviewTool: InteractionTool = { type: 'textSelect' }
const editTool: InteractionTool = { type: 'select' }

export function DocumentPage({
  documentId,
  canEdit,
}: {
  documentId: string
  canEdit: boolean
}) {
  // The PDF application re-renders whenever a PdfProviders prop changes identity.
  const config = useMemo(
    () => ({
      theme: { viewportPadding: 16 },
      // Reviewers read and fill forms; editors also change text, annotations, links, and
      // widgets.
      initialInteractionTool: canEdit ? editTool : reviewTool,
      initialContentPolicy: canEdit
        ? CONTENT_POLICY_PRESET.PDF_EDITOR
        : CONTENT_POLICY_PRESET.PDF_VIEWER,
    }),
    [canEdit]
  )

  return (
    <PdfProviders {...config}>
      <DocumentLoader documentId={documentId} canEdit={canEdit} />
    </PdfProviders>
  )
}

using System;
using System.IO;
using Aspose.Pdf;

public static class Documents
{
    public static int CountPages(Stream input, string password)
    {
        try
        {
            using (var document = string.IsNullOrEmpty(password)
                ? new Document(input)
                : new Document(input, password))
            {
                Console.WriteLine("Encrypted: {0}", document.IsEncrypted);
                return document.Pages.Count;
            }
        }
        catch (InvalidPasswordException)
        {
            // The browser asks the user again and posts the new password.
            return -1;
        }
    }
}

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

function DocumentLoader({
  documentId,
  canEdit,
}: {
  documentId: string
  canEdit: boolean
}) {
  const [loadState, loadPdf] = useLoadPdf()
  const resetPdf = useResetPdf()
  // The fetched bytes, kept for a password retry and tagged with their document.
  const bytesRef = useRef<{ documentId: string; data: Uint8Array } | null>(null)
  const [loadedDocumentId, setLoadedDocumentId] = useState<string | null>(null)
  const [needsPassword, setNeedsPassword] = useState(false)

  // Another document was requested: unload the current one, whose ids and revisions are
  // now stale.
  useEffect(() => {
    if (loadedDocumentId === null || loadedDocumentId === documentId) return
    resetPdf()
    setLoadedDocumentId(null)
    setNeedsPassword(false)
  }, [documentId, loadedDocumentId, resetPdf])

  async function open(password?: string) {
    let bytes = bytesRef.current
    if (bytes?.documentId !== documentId) {
      // Your .NET endpoint returns the stored PDF bytes.
      const response = await fetch(`/api/documents/${documentId}`)
      if (!response.ok)
        throw new Error(`The document request failed with status ${response.status}`)
      bytes = { documentId, data: new Uint8Array(await response.arrayBuffer()) }
      bytesRef.current = bytes
    }

    try {
      // loadPdf reads from the buffer it receives, so keep the original for a retry and
      // pass a copy.
      await loadPdf(bytes.data.slice(), { password })
      setLoadedDocumentId(documentId)
      setNeedsPassword(false)
    } catch (error) {
      if (error instanceof InvalidPasswordError) {
        // The password is missing or wrong: ask for it, then call open(password) again.
        setNeedsPassword(true)
        return
      }
      throw error
    }
  }

  if (needsPassword)
    return <PasswordPrompt onSubmit={(password) => open(password).catch(showError)} />
  if (loadState.status === 'loading') return <p>Loading the document…</p>
  if (loadState.status === 'ready' && loadedDocumentId === documentId) {
    return <PdfApplication documentId={documentId} canEdit={canEdit} />
  }

  return <button onClick={() => open().catch(showError)}>Open</button>
}

using System.IO;
using Aspose.Pdf;
using Aspose.Pdf.Devices;

public static class PageImages
{
    public static byte[] RenderPage(Stream input, int pageNumber)
    {
        using (var document = new Document(input))
        using (var imageStream = new MemoryStream())
        {
            var pngDevice = new PngDevice(new Resolution(150));
            // Pages are numbered from 1.
            pngDevice.Process(document.Pages[pageNumber], imageStream);
            return imageStream.ToArray();
        }
    }
}

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

function PdfApplication({
  documentId,
  canEdit,
}: {
  documentId: string
  canEdit: boolean
}) {
  // Opens each document fitted to the viewport width.
  useViewportAutoFitScale('width')

  return (
    <div style={{ display: 'grid', gridTemplateColumns: '180px 1fr', height: '100vh' }}>
      <PagesPanel canEdit={canEdit} />
      <div style={{ display: 'grid', gridTemplateRows: 'auto 1fr', minHeight: 0 }}>
        <header>
          {/* Editing controls only for editors: the content policy is a mode, not a
             permission. */}
          {canEdit && <InsertToolbar />}
          <SaveControls documentId={documentId} />
        </header>
        {/* The viewport fills its parent, so the parent needs an explicit size. */}
        <div style={{ minHeight: 0 }}>
          <Viewport />
        </div>
      </div>
    </div>
  )
}

using System;
using Aspose.Pdf;

public static class PageOperations
{
    public static void Rearrange(Document document)
    {
        Console.WriteLine("Pages: {0}", document.Pages.Count);

        // A blank page at position 2, and another at the end.
        document.Pages.Insert(2);
        var lastPage = document.Pages.Add();
        // A4 in points: 1 inch is 72 points.
        lastPage.SetPageSize(597.6, 842.4);

        document.Pages[1].Rotate = Rotation.on90;

        // Moves page 3 to the end: add it again, then delete the original.
        document.Pages.Add(document.Pages[3]);
        document.Pages.Delete(3);
    }
}

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

function PagesPanel({ canEdit }: { canEdit: boolean }) {
  const pages = usePages()
  const scrollToPage = useScrollToPage()
  const createPage = usePageCreate()
  const deletePages = usePageDelete()
  const { moveBefore, moveAfter } = usePageMove()
  const setPageRotation = useSetPageRotation()

  return (
    <nav>
      {pages.map((page, index) => (
        <div key={page.id}>
          <button onClick={() => scrollToPage(page.id)}>
            {/* The render resolution follows the canvas CSS size: style .thumbnail to the
               width you need. */}
            <PageCanvas
              pageId={page.id}
              className="thumbnail"
              role="img"
              aria-label={`Page ${index + 1}`}
            />
          </button>
          {canEdit && (
            <div role="toolbar">
              {/* Absolute degrees, like assigning page.Rotate: add to the current angle
                 yourself. */}
              <button onClick={() => setPageRotation(page.id, page.rotation + 90)}>
                Rotate
              </button>
              <button
                disabled={index === 0}
                onClick={() => moveBefore(page.id, pages[index - 1]?.id)}
              >
                Move up
              </button>
              <button
                disabled={index === pages.length - 1}
                onClick={() => moveAfter(page.id, pages[index + 1]?.id)}
              >
                Move down
              </button>
              <button disabled={pages.length <= 1} onClick={() => deletePages(page.id)}>
                Delete
              </button>
              {/* Like Pages.Insert(index + 2): a blank page right after this one, in
                 user-space units. */}
              <button onClick={() => createPage(595, 842, page.id)}>
                Insert blank page
              </button>
            </div>
          )}
        </div>
      ))}
    </nav>
  )
}

using System.IO;
using Aspose.Pdf;

public static class DocumentAssembly
{
    public static byte[] Merge(Stream first, Stream second)
    {
        using (var document1 = new Document(first))
        using (var document2 = new Document(second))
        using (var output = new MemoryStream())
        {
            document1.Pages.Add(document2.Pages);
            document1.Save(output);
            return output.ToArray();
        }
    }

    public static byte[] ExtractPages(Stream input, int[] pageNumbers)
    {
        using (var source = new Document(input))
        using (var result = new Document())
        using (var output = new MemoryStream())
        {
            foreach (var pageNumber in pageNumbers)
            {
                result.Pages.Add(source.Pages[pageNumber]);
            }
            result.Save(output);
            return output.ToArray();
        }
    }
}

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

// The counterpart of ExtractPages, with page ids instead of page numbers.
function useExtractPages() {
  const { prepareDocument } = useDocumentSaving()

  return async (pageIds: string[]) => {
    // The loaded document stays as it is; a page id may appear only once.
    const bytes = await prepareDocument({ pageIds })
    return new Blob([bytes as BlobPart], { type: 'application/pdf' })
  }
}

using System;
using Aspose.Pdf;
using Aspose.Pdf.Forms;

public static class ContractForm
{
    public static void Prefill(Document document, string customerName)
    {
        // true searches the whole field hierarchy, which a full name such as
        // customer.name needs.
        if (document.Form.HasField("customer.name", true))
        {
            var nameField = document.Form["customer.name"] as TextBoxField;
            nameField.Value = customerName;
        }

        var termsField = document.Form["terms.accepted"] as CheckboxField;
        termsField.Checked = false;

        foreach (Field field in document.Form)
        {
            Console.WriteLine("{0}: {1}", field.FullName, field.Value);
        }
    }
}

// Lower-left x and y, then upper-right x and y, in points.
var notesField = new TextBoxField(document.Pages[1], new Rectangle(72, 600, 300, 624));
notesField.PartialName = "notes";
document.Form.Add(notesField, 1);

// Keeps the field but blocks filling it.
notesField.ReadOnly = true;

// Or replace every field with its value.
document.Flatten();

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

function isTextWidget(widget: Widget): widget is TextWidget {
  return widget.widgetType === 'text'
}

function isCheckboxWidget(widget: Widget): widget is CheckboxWidget {
  return widget.widgetType === 'checkbox'
}

// The counterpart of document.Form["customer.name"] and document.Form["terms.accepted"],
// as bound inputs.
function ContractFields() {
  const { widgets, isLoaded } = useWidgets()

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

  const nameWidget = widgets
    .filter(isTextWidget)
    .find((widget) => widget.fieldName === 'customer.name')
  const termsWidget = widgets
    .filter(isCheckboxWidget)
    .find((widget) => widget.fieldName === 'terms.accepted')

  return (
    <form>
      {nameWidget && <NameInput widget={nameWidget} />}
      {termsWidget && <TermsCheckbox widget={termsWidget} />}
    </form>
  )
}

function NameInput({ widget }: { widget: TextWidget }) {
  // Like TextBoxField.Value, kept in sync with typing in the main view and undo.
  const [value, setValue] = useWidgetValue(widget)

  return (
    <label>
      Customer name
      <input value={value} onChange={(event) => setValue(event.currentTarget.value)} />
    </label>
  )
}

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

  return (
    <label>
      <input
        type="checkbox"
        checked={isChecked}
        onChange={(event) => setIsChecked(event.currentTarget.checked)}
      />
      I accept the terms
    </label>
  )
}

function useAddNotesField() {
  const createWidgets = useWidgetsCreate()

  return async (pageId: string) => {
    // new Rectangle(72, 600, 300, 624) as a position and a size, measured from the
    // bottom-left corner of the page.
    const [widget] = await createWidgets({
      pageId,
      widgetType: 'text',
      x: 72,
      y: 600,
      width: 300 - 72,
      height: 624 - 600,
      fieldName: 'notes',
    })
    return widget
  }
}

function useLockForm() {
  const getWidgets = useWidgetsGetter()
  const setWidgetProps = useSetWidgetProps()

  return async () => {
    // getWidgets loads every page with widgets first, so the list is complete.
    const widgets = await getWidgets()
    // Like setting ReadOnly on every field; excludeFromHistory keeps undo from unlocking
    // the form.
    // Resolves when the widgets show the new state.
    await setWidgetProps(
      widgets.map((widget) => widget.id),
      { isReadOnly: true },
      { excludeFromHistory: true }
    )
  }
}

using Aspose.Pdf;
using Aspose.Pdf.Text;

public static class DocumentText
{
    public static string ReadAll(Document document)
    {
        var textAbsorber = new TextAbsorber();
        document.Pages.Accept(textAbsorber);
        return textAbsorber.Text;
    }

    public static void ReplacePlaceholder(
        Document document, string placeholder, string value)
    {
        var absorber = new TextFragmentAbsorber(placeholder);
        document.Pages.Accept(absorber);

        foreach (var textFragment in absorber.TextFragments)
        {
            textFragment.Text = value;
        }
    }
}

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

function useReplacePlaceholder() {
  const { getAllParagraphIds, getPlainTextParagraphs, getParagraphEditor } =
    useProgrammaticEditor()

  return async (placeholder: string, value: string) => {
    // Loads every page in turn, which takes a while on a large document;
    // getParagraphsByPage(pageId) reads a single page.
    const paragraphs = await getPlainTextParagraphs(await getAllParagraphIds())

    for (const paragraph of paragraphs) {
      if (!paragraph.content.includes(placeholder)) continue

      // The paragraph may be gone: deleted by an undo since it was read.
      const editor = getParagraphEditor(paragraph.id)
      if (!editor) continue

      editor.selectAll()
      editor.deleteAll()
      editor.insertText(paragraph.content.replaceAll(placeholder, value))
    }
  }
}

using System.IO;
using Aspose.Pdf;
using Aspose.Pdf.Text;

public static class Approval
{
    public static void Mark(Document document, Stream logoStream)
    {
        var page = document.Pages[1];

        var textFragment = new TextFragment("Approved by J. Doe");
        textFragment.Position = new Position(100, 600);
        textFragment.TextState.FontSize = 12;
        new TextBuilder(page).AppendText(textFragment);

        // Lower-left x and y, then upper-right x and y, in points.
        page.AddImage(logoStream, new Rectangle(400, 700, 550, 780));

        var stamp = new TextStamp("CONFIDENTIAL");
        // Lays the stamp under the page content.
        stamp.Background = true;
        stamp.XIndent = 100;
        stamp.YIndent = 100;
        stamp.Rotate = Rotation.on90;
        page.AddStamp(stamp);
    }
}

import {
  CONTENT_POLICY_PRESET,
  InteractionTool,
  stageImage,
  useInteractionTool,
  useParagraphCreate,
  useProgrammaticEditor,
  useSetInteractionMode,
  useStampAnnotationCreate,
} 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) {
    // Validates and measures the image; the next click on a page places it as a stamp
    // annotation.
    const image = await stageImage(file)
    // Placing images is editing, so switch the policy with the tool.
    setInteractionMode({ type: 'addImage', image }, CONTENT_POLICY_PRESET.PDF_EDITOR)
  }

  return (
    <div role="toolbar">
      <button
        aria-pressed={interactionTool.type === 'select'}
        onClick={() => setInteractionMode(selectTool, CONTENT_POLICY_PRESET.PDF_EDITOR)}
      >
        Select
      </button>
      {/* The next click creates a paragraph and focuses it for typing. */}
      <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>
  )
}

// The counterpart of TextBuilder.AppendText at a position, with no click.
function useAddTextAt() {
  const createParagraph = useParagraphCreate()
  const { getParagraphEditor } = useProgrammaticEditor()

  return async (pageId: string, x: number, y: number, text: string) => {
    const paragraphId = await createParagraph(pageId, x, y)

    // The paragraph may be gone: deleted by an undo since it was created.
    const editor = getParagraphEditor(paragraphId)
    if (!editor) return

    editor.selectAll()
    editor.insertText(text)
  }
}

// The counterpart of page.AddImage(stream, new Rectangle(llx, lly, urx, ury)).
function useAddImageAt() {
  const createStamp = useStampAnnotationCreate()

  return async (
    pageId: string,
    blob: Blob,
    llx: number,
    lly: number,
    urx: number,
    ury: number
  ) => {
    const image = await stageImage(blob)
    // x and y are the bottom-left corner in user-space units.
    return createStamp({
      pageId,
      image,
      x: llx,
      y: lly,
      width: urx - llx,
      height: ury - lly,
    })
  }
}

using System.IO;
using Aspose.Pdf;

public static class Storage
{
    public static byte[] SaveToBytes(Document document)
    {
        using (var output = new MemoryStream())
        {
            document.Save(output);
            return output.ToArray();
        }
    }
}

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

function SaveControls({ documentId }: { documentId: 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()

  // Covers the user's edits and undo/redo: undoing back to the saved state clears it.
  const hasUnsavedChanges = revision !== savedRevision

  async function save() {
    if (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()
      // The buffer is transferred to fetch, so don't hand out the loaded document's
      // original buffer.
      const bytes = await prepareDocument({ returnOriginalIfUnchanged: false })
      const response = await fetch(`/api/documents/${documentId}`, {
        method: 'PUT',
        body: bytes as BodyInit,
      })
      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>
  )
}

using System.IO;
using Aspose.Pdf;

public static class Validation
{
    public static string Check(Stream input, string password)
    {
        try
        {
            using (var document = string.IsNullOrEmpty(password)
                ? new Document(input)
                : new Document(input, password))
            {
                return $"{document.Pages.Count} pages";
            }
        }
        catch (InvalidPasswordException)
        {
            return "The password is wrong.";
        }
        catch (InvalidPdfFileFormatException)
        {
            return "The file is not a valid PDF.";
        }
        catch (PdfException exception)
        {
            return exception.Message;
        }
    }
}

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

function useSdkDiagnostics() {
  useEffect(() => {
    // The SDK never prints to the console: subscribe, and unsubscribe on unmount.
    const unsubscribe = logMessages.on('message', (logMessage) => {
      if (logMessage.level >= LogLevel.Warning)
        reportToMonitoring(logMessage.message, logMessage.data)
    })
    return () => {
      unsubscribe()
    }
  }, [])
}

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

  return async (data: Uint8Array, password?: string) => {
    try {
      // Pass a copy and keep `data` for a password retry.
      await loadPdf(data.slice(), { password })
      return 'ready'
    } catch (error) {
      // Like catch (InvalidPasswordException): ask for the password and try again.
      if (error instanceof InvalidPasswordError) return 'needsPassword'
      throw error
    }
  }
}

using System.IO;
using Aspose.Pdf;

public static class Lifecycle
{
    public static int CountAndClose(Stream input)
    {
        // The document closes the stream itself.
        using (var document = new Document(input, true))
        {
            return document.Pages.Count;
        }
    }
}