Inleiding

Elke functionaliteit in Aspose.PDF FOSS voor TypeScript wordt bereikt via twee klassen: Document en Page. Document beheert de paginacollectie en alles dat op het document betrekking heeft — metadata, bladwijzers, paginalabels en opslaan/laden — terwijl elke Page in doc.Pages alles beheert wat op die ene pagina betrekking heeft: inhoud, annotaties en formuliervelden. Zodra die twee klassen bekend zijn, is de rest van het oppervlak van de bibliotheek — conversie, annotaties, formulieren, beveiliging — eigenlijk alleen maar meer methoden op dezelfde twee objecten.

Dit bericht kijkt dieper naar de delen van dat kernoppervlak die de introductiebericht slechts vluchtig noemt: documenten samenstellen uit andere documenten, pagina’s vanaf nul bouwen, een bladwijzerboom toevoegen voor navigatie, en inhoud taggen voor toegankelijkheid. Alle vier zijn eenvoudige methode-aanroepen — geen apart module om te importeren, geen extra afhankelijkheid naast het @asposefoss/pdf-pakket zelf.

Dit zijn de bewerkingen die naar voren komen zodra een PDF-pipeline verder gaat dan “een bestand openen, wijzigen, opslaan”: rapporten van verschillende bronnen combineren tot één document, pagina’s programmatisch genereren in plaats van vanuit een sjabloon te starten, en de output navigeerbaar en toegankelijk maken in plaats van alleen visueel correct.

Wat er inbegrepen is

Documenten samenstellen en reorganiseren

Document.Split() splitst een document op in één nieuw single-page Document per pagina, in paginavolgorde. Document.ExtractPages() kopieert een opgegeven set van 1-gebaseerde paginanummers naar een nieuw self-contained Document, in de opgegeven volgorde — dezelfde pagina kan herhaald worden. Pagina’s uit één document kunnen ook naar een ander worden gekopieerd: Document.Append() kopieert elke pagina van een bron-document naar het einde van het doel-document, en Document.InsertPage() kopieert een enkele pagina over documenten heen op een specifieke 1-gebaseerde positie.

import { Document } from '@asposefoss/pdf';

const report = Document.OpenFile('report.pdf');

const parts = report.Split();                      // one Document per page
const chapter = report.ExtractPages([3, 4, 5]);     // subset (1-based, repeats allowed) as a new Document

const cover = Document.OpenFile('cover.pdf');
report.InsertPage(1, cover.Pages[0]);               // copy a single page across documents
report.Append(chapter);                             // copy chapter's pages onto report

report.WriteTo('assembled.pdf');

Meerdere documenten kunnen ook worden gecombineerd tot één in één enkele aanroep met Document.Merge(), die een nieuwe Document bouwt uit kopieën van elke pagina van elk document dat eraan wordt doorgegeven, in volgorde.

Pagina’s vanaf nul bouwen

Document.New() maakt een document uit het niets: nul pagina’s wanneer een formaat wordt weggelaten, of één lege pagina van de opgegeven PageFormat wanneer er één wordt doorgegeven. Extra lege pagina’s komen van Document.AddPage(), die ook een PageFormat accepteert (of een bestaande Page om de grootte te kopiëren). Tekst wordt op een pagina getekend met Page.AddText(), gepositioneerd op een (x, y)-punt in de PDF-gebruikersruimte.

import { Document, PageFormat } from '@asposefoss/pdf';

const doc = Document.New(PageFormat.A4);          // one blank A4 page
doc.Pages[0].AddText('Hello', 72, 720, { fontSize: 14 });
doc.AddPage(PageFormat.A4.landscape());           // append more as you go
doc.WriteTo('scratch.pdf');

Bladwijzers en documentnavigatie

De documentstructuur (het bladwijzerpaneel dat de meeste PDF-lezers naast de pagina tonen) wordt gelezen met Document.GetOutlines() en volledig vervangen door Document.SetOutlines(), elk werkend met een boom van OutlineItem-waarden. Elke OutlineItem bevat een Title, een Dest-bestemming, en optioneel Children voor geneste items, plus weergave-hintsen zoals Open (standaard uitgeklapt) en Bold.

import { Document, OutlineItem } from '@asposefoss/pdf';

const items: OutlineItem[] = [
  { Title: 'Introduction', Dest: { name: 'intro' } },
  {
    Title: 'Chapters',
    Open: true,
    Children: [
      { Title: 'Chapter 1', Dest: { name: 'ch1' } },
      { Title: 'Chapter 2', Dest: { name: 'ch2' } },
    ],
  },
];
doc.SetOutlines(items);

Bestemmingen die op deze manier worden genoemd ({ name: 'intro' }) worden opgelost via de tabel met benoemde bestemmingen van het document, die Document.GetNamedDestinations() en Document.SetNamedDestination() rechtstreeks beheren wanneer een bladwijzer moet wijzen naar een bestemming die niet gekoppeld is aan paginainhoud.

Gestructureerde tekst en toegankelijkheidstagging

Document.GetStructTree() retourneert de logische structuurboom van het document (of null wanneer het document niet getagd is), en Document.CreateStructTree() bouwt er een, waarbij het document als Tagged wordt gemarkeerd. Zodra een structuurboom bestaat, retourneert Page.GetStructuredText() de tekst van de pagina als TextBlock-waarden — gepositioneerde fragmenten die al zijn gegroepeerd in regels en alinea-achtige blokken — die de invoer vormen waar een hand-tagging-stap mee werkt: de blokken doorlopen, bepalen welke koppen zijn versus hoofdtekst, en de overeenkomstige elementen aan de boom toevoegen.

function handTagPage(doc: Document, page: Page, heading: string): void {
  const root = doc.GetStructTree();
  if (!root) throw new Error('handTagPage: the document is not tagged yet');
  for (const block of page.GetStructuredText()) {
    const text = block.text.trim();
    if (text.length === 0) continue;
    const el = root.Append(text.startsWith(heading) ? 'H2' : 'P');
    el.MarkContent(page, block.quad);
  }
}

Een getagde structuurboom is waar downstream-functies op voortbouwen: semantische HTML export herschikt ervan in plaats van terug te vallen op een eenvoudige heuristische lay-out, en Document.ValidatePdfUa() controleert het document tegen een subset van de PDF/UA toegankelijkheidsnorm die afhankelijk is van het aanwezig zijn van tagging.

Snelstart

Installeer het pakket, open vervolgens een document, haal een subset van de pagina’s eruit en combineer deze opnieuw, en sla het resultaat op:

git clone https://github.com/aspose-pdf-foss/Aspose.PDF-FOSS-for-TypeScript.git
cd Aspose.PDF-FOSS-for-TypeScript
npm install
npm run build
import { Document } from '@asposefoss/pdf';

const doc = Document.OpenFile('report.pdf');

const chapter = doc.ExtractPages([3, 4, 5]);   // subset (1-based, repeats allowed) as a new Document
const cover = Document.OpenFile('cover.pdf');

doc.InsertPage(1, cover.Pages[0]);             // copy a single page across documents
doc.Append(chapter);                           // copy chapter's pages onto doc

doc.WriteTo('assembled.pdf');

Ondersteunde formaten

FormaatExtensieLezenSchrijven
PDFpdf✓✓
Markdownmd✓✓
SVGsvg✓✓
TIFFtiff✓✓
DOCXdocx—✓
HTMLhtml—✓
PNGpng—✓
EPUBepub—✓

Open source & licenties

Aspose.PDF FOSS voor TypeScript wordt uitgebracht onder de MIT-licentie, met de bron gepubliceerd op GitHub. Er is geen evaluatiewatermerk, gebruikslimiet, of apart licentiebestand om te beheren, en de bibliotheek mag in commerciële producten worden gebruikt zonder royalty’s.

Het pakket bevindt zich momenteel op versie 0.1.0, wat duidt op actieve ontwikkeling in een vroeg stadium. Node.js (>=22) is de enige runtime-vereiste, en het pakket heeft geen andere externe afhankelijkheden.

Aan de slag

Gerelateerde bronnen