docx

In a browser, you must fetch the font file and convert it to an ArrayBuffer or base64 string. Use Buffer.from() to wrap the data for the Document constructor. Use Packer.toBlob() to export the document for downloading.

import { CharacterSet, Document, Packer, Paragraph, TextRun } from "docx";
import { saveAs } from "file-saver";

// Fetch the font file and convert to ArrayBuffer
const response = await fetch("./fonts/MyFont.ttf");
const fontData = await response.arrayBuffer();

const doc = new Document({
    fonts: [
        {
            name: "MyFont",
            data: Buffer.from(fontData),
            characterSet: CharacterSet.ANSI,
        },
    ],
    sections: [
        {
            children: [
                new Paragraph({
                    children: [
                        new TextRun({
                            text: "Text with embedded font",
                            font: "MyFont",
                        }),
                    ],
                }),
            ],
        },
    ],
});

// Export the document
Packer.toBlob(doc).then((blob) => {
    saveAs(blob, "document.docx");
});

Templates allow you to generate dynamic documents from pre-designed .docx layouts by replacing placeholder tags with content using patchDocument.

Workflow

1. Create a Template: Open a Word processor and create a .docx file using double curly braces {{placeholder_name}} for your tags.
2. Define Patches: Use the patchDocument function to map your placeholder names to new content.
3. Export: Run the patcher to produce the modified document.

Basic Usage Example

import * as fs from "fs";
import { patchDocument, PatchType, TextRun } from "docx";

patchDocument({
    outputType: "nodebuffer",
    data: fs.readFileSync("template.docx"),
    patches: {
        customer_name: {
            type: PatchType.PARAGRAPH,
            children: [new TextRun("John Smith")],
        },
        order_number: {
            type: PatchType.PARAGRAPH,
            children: [new TextRun("12345")],
        },
    },
}).then((doc) => {
    fs.writeFileSync("output.docx", doc);
});

Set the orientation using PageOrientation.LANDSCAPE or PageOrientation.PORTRAIT.

Important: When switching to landscape, you must manually swap the width and height values. The orientation property only controls how Word displays the page; it does not automatically adjust the dimensions.

import { Document, PageOrientation, Paragraph, convertMillimetersToTwip } from "docx";

// Landscape A4
// Note: For landscape, swap width and height values so the larger dimension becomes the width
const doc = new Document({
    sections: [
        {
            properties: {
                page: {
                    size: {
                        orientation: PageOrientation.LANDSCAPE,
                        width: convertMillimetersToTwip(297), // A4 height becomes landscape width
                        height: convertMillimetersToTwip(210), // A4 width becomes landscape height
                    },
                },
            },
            children: [new Paragraph("Landscape page")],
        },
    ],
});

To ensure consistent appearance across different systems, you can embed font data directly into the Document via the fonts property in the constructor. This requires providing the font name, the raw font data (as a Buffer), and an optional characterSet.

import * as fs from "fs";
import { CharacterSet, Document, Paragraph, TextRun } from "docx";

const fontData = fs.readFileSync("./fonts/MyCustomFont.ttf");

const doc = new Document({
    fonts: [
        {
            name: "MyCustomFont",
            data: fontData,
            characterSet: CharacterSet.ANSI,
        },
    ],
    sections: [
        {
            children: [
                new Paragraph({
                    children: [
                        new TextRun({
                            text: "This text uses a custom font",
                            font: "MyCustomFont",
                        }),
                    ],
                }),
            ],
        },
    ],
});