Loading the document…
if (loadState.status === 'ready' && loadedDocumentId === documentId) { returnLoading the form…
const nameWidget = widgets .filter(isTextWidget) .find((widget) => widget.fieldName === 'customer.name') const termsWidget = widgets .filter(isCheckboxWidget) .find((widget) => widget.fieldName === 'terms.accepted') return ( ) } 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 ( ) } function TermsCheckbox({ widget }: { widget: CheckboxWidget }) { const [isChecked, setIsChecked] = useWidgetValue(widget) return ( ) } 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 } ) } } ``` ### From fields to widgets [#from-fields-to-widgets] | Concept | Aspose.PDF | @sdk-pdf/react | | ------------------- | ------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------ | | Lookup | `document.Form[name]` (throws when missing), `HasField(name, true)`, `foreach` | `useWidgets()` filtered by `fieldName` (re-renders), or `await getWidgets()` from [`useWidgetsGetter`](https://sdk.pdf.net/docs/v1/reference/useWidgetsGetter) (one-time) | | Shared value | A field with several widgets | Every widget with the same field name shows and synchronizes the same value | | Text | `TextBoxField.Value` | A `text` widget: `string` | | Checkbox | `CheckboxField.Checked` | A `checkbox` widget: `boolean` | | Radio group | `RadioButtonField`, `Options[n].Selected` | `radio` widgets sharing a `fieldName`, each with a `boolean` value | | Lists | `ComboBoxField`, `ListBoxField` | `choice` (`string`; `isCombo` for a dropdown) and `multiChoice` (the selected option indices) | | Buttons, signatures | `ButtonField`, `SignatureField` | `pushButton` and `signature` widgets, with no value | | Creation | `new TextBoxField(page, rectangle)`, `Form.Add(field, pageNumber)` | `createWidgets(props)` from [`useWidgetsCreate`](https://sdk.pdf.net/docs/v1/reference/useWidgetsCreate); a unique `fieldName` is generated when omitted | | Read-only | `field.ReadOnly = true` | `setWidgetProps(ids, { isReadOnly: true }, options?)` from [`useSetWidgetProps`](https://sdk.pdf.net/docs/v1/reference/useSetWidgetProps) | | Deletion | `Form.Delete(name)` | `deleteBlocks(widgetIds)` from [`useBlockDelete`](https://sdk.pdf.net/docs/v1/reference/useBlockDelete); delete same-named widgets together | | Flattening | `document.Flatten()`, `Form.Flatten()`, `field.Flatten()` | No equivalent | | Form data | `Form.ExportToJson`, `Form.ImportFromJson` | No equivalent | ### What to know [#what-to-know-5] * **Where prefilling goes.** There is no setter by field name: a value is read and written per widget, through a bound component like `NameInput` above. Values your server knows before the user opens the form can stay a server step: fill them with Aspose.PDF, and serve the filled file. * **A missing field isn't an exception.** Where the string indexer throws, a widget lookup simply finds nothing, so render nothing for it. * **Coordinates.** Both measure in points from the bottom-left corner of the page. Aspose.PDF takes the two corners of a rectangle, and `createWidgets` takes `x`, `y`, `width`, and `height`; check the placement on a test document before converting stored rectangles. * **Locking instead of flattening.** `isReadOnly` restricts filling the field, not authoring the widget. To flatten, keep `document.Flatten()` on the server and run it on the uploaded file. * **Reading submitted values.** There is no built-in JSON export. The filled PDF from `prepareDocument()` carries the values; read them on the server with `foreach (Field field in document.Form)` as before. * **Signatures.** `signature` widgets carry a read-only `isCryptoSigned`; the SDK never signs. * **Date fields.** A text widget's `format` exposes Acrobat date formats as `FormatType.DateTime`, recognized without running scripts; see [`FormatType`](https://sdk.pdf.net/docs/v1/reference/FormatType). ## Text extraction and replacement [#text-extraction-and-replacement] ### Before: Aspose.PDF [#before-asposepdf-6] Absorbers visit pages: `TextAbsorber` collects the text, and `TextFragmentAbsorber` finds every occurrence of a phrase as a `TextFragment` whose `Text` you can replace. `TextSearchOptions(true)` switches the phrase to a regular expression: ```csharp 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; } } } ``` ### After: @sdk-pdf/react [#after-sdk-pdfreact-6] Under `PDF_EDITOR`, users edit text in place in [`Viewport`](https://sdk.pdf.net/docs/v1/reference/Viewport). From code, [`useProgrammaticEditor`](https://sdk.pdf.net/docs/v1/reference/useProgrammaticEditor) reads the text as paragraphs and rewrites a paragraph through an editor mirror, as [Programmatic editing](https://sdk.pdf.net/docs/v1/guides/programmatic-editing) shows: ```tsx 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)) } } } ``` The counterpart of `TextAbsorber.Text` joins the same entries: `paragraphs.map((paragraph) => paragraph.content).join('\n\n')`. ### What to know [#what-to-know-6] * **Paragraphs, not fragments.** Each entry carries `id`, `content` as a plain string, the page number from 1, its box in user space as `bounds`, and the paragraph layout, such as `textAlign` and `lineHeight`, which [`useSetParagraphProps`](https://sdk.pdf.net/docs/v1/reference/useSetParagraphProps) changes. A replacement rewrites the whole paragraph text; there is no replacement of a fragment inside it. * **Search for users.** [`useDocumentSearch`](https://sdk.pdf.net/docs/v1/reference/useDocumentSearch) finds a query in the document, highlights the matches in `Viewport`, and scrolls to the active one; `isCaseSensitive` and `isWholeWord` are its options, and there are no regular expressions. Each match carries its `pageId` and `paragraphId`. For a `RegExp` from code, match `paragraph.content` yourself and scroll to it with `scrollToBlock(paragraph.id)` from [`useScrollToBlock`](https://sdk.pdf.net/docs/v1/reference/useScrollToBlock). * **Style goes through the selection.** The editor mirror has `focus`, `blur`, `selectAll`, `deleteAll`, and `insertText`, and no style operations. Where your code set `TextState` font, size, or color, users style their selection with [`useSelectionTextStyle`](https://sdk.pdf.net/docs/v1/reference/useSelectionTextStyle). * **One document.** Programmatic edits flow through the same document as user edits; `setEditorAwarenessProperties({ name, color })` gives the editor a cursor for real-time collaboration, which is coming soon. ## Add text, images, and stamps [#add-text-images-and-stamps] ### Before: Aspose.PDF [#before-asposepdf-7] New content goes onto a page at coordinates: a `TextFragment` through a `TextBuilder`, an image into a rectangle with `AddImage`, and stamps with `AddStamp`: ```csharp 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); } } ``` ### After: @sdk-pdf/react [#after-sdk-pdfreact-7] Users place new text and images with interaction tools, which also cover simple text and image stamps, and [`useSetInteractionMode`](https://sdk.pdf.net/docs/v1/reference/useSetInteractionMode) switches the tool together with the editing policy. From code, [`useParagraphCreate`](https://sdk.pdf.net/docs/v1/reference/useParagraphCreate) creates a paragraph at a position, and [`useStampAnnotationCreate`](https://sdk.pdf.net/docs/v1/reference/useStampAnnotationCreate) places an image: ```tsx 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 (
{/* The next click creates a paragraph and focuses it for typing. */}
)
}
// 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,
})
}
}
```
### What to know [#what-to-know-7]
* **Switch the policy with the tool.** Pass `PDF_EDITOR` with the editing tools, as above. `textSelect` needs read-only text: with editable text, the combination is unsupported and reports a message through [`logMessages`](https://sdk.pdf.net/docs/v1/reference/logMessages). Compare the active tool from [`useInteractionTool`](https://sdk.pdf.net/docs/v1/reference/useInteractionTool) by `.type`, as above. The mode is local to each user.
* **Images become stamp annotations.** [`stageImage(blob)`](https://sdk.pdf.net/docs/v1/reference/stageImage) validates and measures any image the browser can decode. The placement size goes on the `addImage` tool (`{ type: 'addImage', image, width?, height? }`) or on the `useStampAnnotationCreate` input, in user-space units: a single dimension keeps the aspect ratio, and with none the image keeps its natural size, fit down to the page.
* **Text from code.** `createParagraph(pageId, x, y)` takes the position in user-space units; check the placement on a test document when converting the `Position` of a text fragment. Style the text through the selection with [`useSelectionTextStyle`](https://sdk.pdf.net/docs/v1/reference/useSelectionTextStyle).
* **Selected blocks.** With the `select` tool, users select, move, and resize blocks; [`useDeleteSelection`](https://sdk.pdf.net/docs/v1/reference/useDeleteSelection), [`useDuplicateSelection`](https://sdk.pdf.net/docs/v1/reference/useDuplicateSelection), and [`useMoveSelection`](https://sdk.pdf.net/docs/v1/reference/useMoveSelection) drive your toolbar buttons and shortcuts.
* **Stamps are partly covered.** An image stamp becomes a stamp annotation from the `addImage` tool or `useStampAnnotationCreate`, and a text stamp becomes a paragraph from the `addText` tool or `createParagraph`. A stamp on every page is one call per page. Rotation, background layering, and opacity have no equivalent: apply those stamps to the uploaded file on the server.
* **Annotations.** [`useInkAnnotationCreate`](https://sdk.pdf.net/docs/v1/reference/useInkAnnotationCreate) creates an ink annotation from freehand paths, the counterpart of an `InkAnnotation`; creating other annotation types has no equivalent. Existing shapes, lines, and ink display, and [`useSelectionAnnotationProps`](https://sdk.pdf.net/docs/v1/reference/useSelectionAnnotationProps) changes their border color and width.
## Saving and downloading [#saving-and-downloading]
### Before: Aspose.PDF [#before-asposepdf-8]
After the changes, `Save` writes the complete document to a stream or a file, and other overloads write other formats:
```csharp
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();
}
}
}
```
### After: @sdk-pdf/react [#after-sdk-pdfreact-8]
[`useDocumentSaving`](https://sdk.pdf.net/docs/v1/reference/useDocumentSaving) applies the changes recorded during the session to the loaded document. The upload goes to your .NET backend, which stores the bytes. Saving doesn't reset any modified state: record the saved revision yourself:
```tsx
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 (
{hasUnsavedChanges && Unsaved changes}
)
}
```
One component owns the saved revision, so the save and the indicator compare against the same value. Render it only once the document is ready, so its first revision is the loaded document's.
### What to know [#what-to-know-8]
* **The server receives a finished PDF.** `prepareDocument()` resolves with the complete document as a `Uint8Array`; your endpoint stores the request body as it is. When the stored file still needs a server step, such as `Flatten`, `Encrypt`, a PDF/A `Convert`, or a stamp, open the uploaded bytes with `new Document(stream)` and run it as before.
* **returnOriginalIfUnchanged** defaults to `true`, returning the buffer passed to `loadPdf` when nothing changed; set it to `false` when the bytes will be transferred or mutated.
* **PDF only.** Besides `returnOriginalIfUnchanged`, the only option is `pageIds`, which saves a subset of the pages: there is no output format, encryption, or download file name. Conversions such as `SaveFormat.DocX` run on the server from the uploaded PDF.
* **Unsaved changes are new.** [`useDocumentRevision`](https://sdk.pdf.net/docs/v1/reference/useDocumentRevision) changes on every edit and returns to an earlier value on undo and redo, so comparing it with the saved revision tells whether there are unsaved changes; [`useUndoRedo`](https://sdk.pdf.net/docs/v1/reference/useUndoRedo) adds undo and redo of the user's edits. Edits within 500 ms of each other merge into one undo step: `markUndoBoundary()` from [`useUndoBoundary`](https://sdk.pdf.net/docs/v1/reference/useUndoBoundary) keeps a scripted operation, such as `useReplacePlaceholder` above, a step of its own.
* **Downloads.** `downloadDocument()` builds the same bytes and saves them on the user's device as a file.
## Errors and logging [#errors-and-logging]
### Before: Aspose.PDF [#before-asposepdf-9]
Aspose.PDF throws exceptions that derive from `PdfException`, such as `InvalidPasswordException` for a wrong password and `InvalidPdfFileFormatException` for an invalid PDF:
```csharp
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;
}
}
}
```
### After: @sdk-pdf/react [#after-sdk-pdfreact-9]
Failures are typed errors from the call that failed, and problems the SDK works around are log messages you subscribe to with [`logMessages`](https://sdk.pdf.net/docs/v1/reference/logMessages). [Error handling and logging](https://sdk.pdf.net/docs/v1/guides/error-handling-and-logging) has the full rules:
```tsx
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
}
}
}
```
### Error classes [#error-classes]
Every SDK error extends `GenericError` and carries a static `message` and an optional `data` object:
| @sdk-pdf/react | Thrown when | Closest Aspose.PDF exception |
| ------------------------ | ----------------------------------------------------------------------- | ------------------------------- |
| `InvalidPasswordError` | The document is encrypted, and the password is missing or wrong. | `InvalidPasswordException` |
| `DocumentFormatError` | The PDF content is malformed beyond what the SDK can work around. | `InvalidPdfFileFormatException` |
| `NotSupportedError` | The document uses a PDF feature the SDK doesn't support. | — |
| `DocumentNotLoadedError` | An operation requires a document, and none is loaded. | — |
| `InvalidInputError` | The input passed to the API is invalid. | — |
| `UninitializedError` | An object is used before its asynchronous initialization has completed. | — |
| `GenericError` | The base class of the classes above. | `PdfException` |
### What to know [#what-to-know-9]
* **Errors reach the browser.** Loading, editing, and saving fail in the user's session, so error UI moves to your React components; exceptions on the server remain for the steps that stay there.
* **Nothing half-applied.** Commands validate first and throw before touching anything; readers return empty values instead of throwing; hooks never throw during render. `Viewport` and `PageCanvas` are the exception: they throw `DocumentNotLoadedError` when rendered without a document.
* **Malformed documents.** When the SDK can work around a problem in the file, it completes the operation and logs a message instead of throwing. Each message carries `level` (`LogLevel.Debug`, `Info`, `Warning`, `Error`), `reason`, a static `message`, `data`, and `stack`.
## Cleanup and lifecycle [#cleanup-and-lifecycle]
### Before: Aspose.PDF [#before-asposepdf-10]
`Document` implements `IDisposable`: `Dispose` closes the resources the document uses, and `using` disposes it at the end of the block. With `isManagedStream` set to `true`, the document closes the input stream:
```csharp
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;
}
}
}
```
### After: @sdk-pdf/react [#after-sdk-pdfreact-10]
| Concern | @sdk-pdf/react |
| ------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Closing a document | `resetPdf()` from [`useResetPdf`](https://sdk.pdf.net/docs/v1/reference/useResetPdf) unloads it and returns the load state to `'initial'`; there is no dispose call. |
| Input buffers | `loadPdf` from [`useLoadPdf`](https://sdk.pdf.net/docs/v1/reference/useLoadPdf) reads the buffer for the document's lifetime: pass a copy when you keep the bytes, and don't transfer the original. |
| Event listeners | [`useViewportEvent`](https://sdk.pdf.net/docs/v1/reference/useViewportEvent) subscriptions follow the component lifecycle. |
| Log subscriptions | `logMessages.on()` returns an unsubscribe function; call it in the effect cleanup, as in [Errors and logging](https://sdk.pdf.net/docs/v1/migration/from-aspose#errors-and-logging). |
| Keyboard listeners | [`useHotkeys`](https://sdk.pdf.net/docs/v1/reference/useHotkeys) installs window-level shortcuts; memoize the mapping, and pass a falsy value instead of it to disable them, such as while a modal is open. |
After `resetPdf()`, page and block ids, widget snapshots, and revisions from the old document are no longer valid: read fresh state through the hooks once the next document loads.
## Features without an equivalent [#features-without-an-equivalent]
Plan around these before you migrate; most of them stay on your server with Aspose.PDF:
| Aspose.PDF feature | In @sdk-pdf/react |
| ---------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Conversion to other formats (`Save` with `SaveFormat.Doc`, `SaveFormat.DocX`, and more) | No equivalent; keep it on your server and convert the PDF uploaded from `prepareDocument()` |
| HTML-to-PDF and other inputs (`HtmlLoadOptions` and other load options) | No equivalent; convert on your server and send the PDF to `loadPdf` |
| Page images for use outside the app (`PngDevice`, `JpegDevice`, and the other devices) | Keep them on your server; inside the app, `Viewport` and `PageCanvas` render the pages |
| Digital signatures (`PdfFileSignature`) | No equivalent; signature widgets display, `isCryptoSigned` is read-only, and the SDK never signs. Keep signing on your server |
| OCR (`Document.Convert` with a `CallBackGetHocr` callback to an OCR engine) | No equivalent; keep it on your server |
| PDF/A and PDF/X (`Convert` with a `PdfFormat`) | No equivalent; keep it on your server |
| Encryption and decryption (`Encrypt`, `Decrypt`) | `loadPdf` opens encrypted files with a password, and saving has no encryption option; keep encryption on your server |
| Compression and linearization (`OptimizeResources`, `Optimize`) | No equivalent; keep it on your server |
| Merging and importing pages (`Pages.Add(otherDocument.Pages)`) | No equivalent; keep it on your server, see [Merge and split](https://sdk.pdf.net/docs/v1/migration/from-aspose#merge-and-split) |
| Resizing pages (`SetPageSize`), page boxes (`MediaBox`, `CropBox`) | No equivalent; `createPage` sets the size of new pages |
| Flattening (`Flatten`) | No equivalent; `isReadOnly` locks fields in the browser, and the server flattens the uploaded file |
| Form data in JSON (`ExportToJson`, `ImportFromJson`) | No equivalent; values are read and written per widget with `useWidgetValue` |
| Regular-expression search (`TextSearchOptions`) | No equivalent; `useDocumentSearch` matches plain text, and code can match paragraph text from `useProgrammaticEditor` itself |
| Replacing a fragment inside a paragraph, styling text from code (`TextState`) | No equivalent; the programmatic editor rewrites whole paragraphs, and users style their selection |
| Stamp rotation, background layering, and opacity (`TextStamp`, `ImageStamp`) | No equivalent; place images with the `addImage` tool or `useStampAnnotationCreate` and text with the `addText` tool or `createParagraph`, or apply these stamps on the server |
| Creating annotations other than ink (highlights, notes, shapes, links), XFDF import and export | No equivalent; existing shapes, lines, and ink display, and their border color and width can be changed |
| Redaction (`RedactionAnnotation.Redact`) | No equivalent |
| Bookmarks (`Outlines`) | No equivalent |
| Generating documents from scratch (`new Document()`, `Pages.Add()`, `TextBuilder`) | No equivalent; `loadPdf` opens existing PDF bytes, so generate the document on your server |
| Formats other than PDF | PDF only |