Fonts

const doc = new PdfDocument();
const page = doc.newPage();
const ctx = page.context;

const textFormat = new Format({
    font: Font.getPdfFont(StandardPdfFont.HelveticaBold),
    fontSize: 14
});

// Render text using drawText() method
ctx.drawText("1. Test string.", textFormat, 72, 72);

// Save Document
const docData = doc.savePdf();
Util.saveFile("UsingStandardPdfFonts.pdf", docData);

// load the font
const fontData = await Util.loadFile("fonts/Gabriola.ttf");
const gabriola = Font.load(fontData);

// Now that we have our font, use it to render some text
const tf = new Format({
    font: gabriola,
    fontSize: 16
});

const doc = new PdfDocument();

// Use PdfDocument object to set the FontEmbedMode
doc.fontEmbedMode = FontEmbedMode.EmbedFullFont;

const ctx = doc.newPage().context;
ctx.drawText(`Sample text drawn with font ${gabriola.fontFamily}.`,
    tf, 72, 72);

// Save Document
const docData = doc.savePdf();
Util.saveFile("FontEmbedding.pdf", docData);

// load the font
const fontData = await Util.loadFile("fonts/Gabriola.ttf");
const gabriola = Font.load(fontData);

// Now that we have our font, use it to render some text
const tf = new Format({
    font: gabriola,
    fontSize: 16
});

const doc = new PdfDocument();
const ctx = doc.newPage().context;
ctx.drawText(`Sample text drawn with font ${gabriola.fontFamily}.`,
    tf, 72, 72);

// Save Document
const docData = doc.savePdf();
Util.saveFile("UsingFontFromFile.pdf", docData);

// Create a FontCollection instance:
const fc = new FontCollection();

// load and add font
fc.addFont(Font.load(await Util.loadFile("fonts/georgia.ttf")));

// Generate a sample document using the font collection to provide fonts:
const doc = new PdfDocument();
const page = doc.pages.addNew();
const ctx = page.context;

// Allow the Layout created internally by PdfContext
// to find the specified fonts in the font collection:
ctx.fontCollection = fc;

// Use PdfContext.drawText to show that the font collection is also used
// by the graphics once the FontCollection has been set on it:
ctx.drawText("Text rendered using Georgia, drawn by PdfContext.drawText() method.",
    new Format({ fontFamily: "georgia", fontSize: 10 }),
    72, 72);

// Save Document
const docData = doc.savePdf();
Util.saveFile("FontCollection.pdf", docData);

// Set up GcPdfDocument:
const doc = new PdfDocument();
const ctx = doc.newPage().context;

// Initialize a text format with one of the standard fonts. Standard fonts are minimal
// and contain very few glyphs for non-Latin characters.
const tf = new Format({
    font: Font.getPdfFont(StandardPdfFont.Courier),
    fontSize: 14
});

// create FontCollection with fallback font,
// use ARIALUNI.TTF it contains japanese glyphs
const arialuni = Font.load(await Util.loadFile("fonts/arialuni.ttf"));
const fontCollection = new FontCollection();
fontCollection.addFallbackFont(arialuni);
ctx.fontCollection = fontCollection;

// As the fallback fonts are available, the Japanese text will render
// correctly as an appropriate fallback will have been found:
ctx.drawText("Sample text with fallbacks available: あなたは日本語を話せますか？", tf, 72, 72);

// Save Document
const docData = doc.savePdf();
Util.saveFile("FallbackFonts.pdf", docData);

// PdfDocument.getFonts(): list the fonts used in a PDF document together with their properties.
// The sample first generates a source PDF that uses several different fonts
// (an embedded TrueType font and non-embedded standard PDF fonts), then loads
// that PDF and enumerates its fonts with PdfDocument.getFonts(). For each font
// the PostScript name, PDF font type, family, weight, italic flag and embedding
// state are printed to the console; for composite (Type0) fonts the descendant
// CIDFont is shown as well.

// Returns the PDF font type of a PdfFont as a readable string.
function getFontTypeName(font) {
    if (font instanceof PdfFontType0)
        return 'Type0 (composite)';
    if (font instanceof PdfFontTrueType)
        return 'TrueType';
    if (font instanceof PdfFontType1)
        return 'Type1';
    if (font instanceof PdfFontType3)
        return 'Type3';
    return 'Unknown';
}
// Step 1: generate a source PDF that uses several different fonts.
const arial = Font.load(new Uint8Array(await readFile(path.join(__dirname, '..', 'Resources', 'arial.ttf'))));
const helvetica = Font.getPdfFont(StandardPdfFont.Helvetica);
const timesBoldItalic = Font.getPdfFont(StandardPdfFont.TimesBoldItalic);
const srcDoc = new PdfDocument();
const g = srcDoc.pages.addNew().context;
g.drawText('This line is drawn with Arial (a TrueType font embedded as a Type0 composite font).', arial, 12, 'Black', 20, 20);
g.drawText('This line is drawn with the standard PDF font Helvetica (not embedded).', helvetica, 12, 'Black', 20, 50);
g.drawText('This line is drawn with the standard PDF font Times-BoldItalic (not embedded).', timesBoldItalic, 12, 'Black', 20, 80);
const sourceFile = path.join(__dirname, 'ListFonts_source.pdf');
const sourceData = srcDoc.savePdf();
await writeFile(sourceFile, sourceData);
console.log(`Created source document ${sourceFile}`);
// Step 2: load the source PDF and list its fonts using PdfDocument.getFonts().
const doc = PdfDocument.load(sourceData);
console.log(`Fonts of ${path.basename(sourceFile)} listed by PdfDocument.getFonts():\n`);
for (const font of doc.getFonts()) {
    const { fontFamily, fontWeight, fontItalic } = font.getFontAttributes();
    console.log(`/${font.baseFont}`);
    console.log(`    type: ${getFontTypeName(font)}`);
    console.log(`    family: ${fontFamily}`);
    console.log(`    weight: ${fontWeight !== null ? PdfFontWeight[fontWeight] ?? fontWeight : null}`);
    console.log(`    italic: ${fontItalic}`);
    console.log(`    embedded: ${font.isEmbedded}`);
    // For composite (Type0) fonts the actual font data lives in the descendant CIDFont:
    if (font instanceof PdfFontType0)
        console.log(`    descendant CIDFont: /${font.descendantFont?.baseFont}`);
    console.log('');
}