@disruptive-learning/cfdi-to-pdf/dist/esm/builders/node/pdf_maker_builder.js

Librería para crear un pdf basado en un XML CFDI o Retenciones

import { createWriteStream } from 'node:fs';
import { buffer } from 'node:stream/consumers';
import PdfPrinter from 'pdfmake';
import AbstractPdfMakerBuilder from '#src/builders/abstract_pdf_maker_builder';
import { catalogsSource } from '#src/catalogs/catalogs_source';
export default class PdfMakerBuilder extends AbstractPdfMakerBuilder {
    _pdfPrinter;
    constructor(documentTranslator, documentOptions, catalogs, overrideFontDictionary, options) {
        super();
        this._documentTranslator = documentTranslator;
        this._catalogs = catalogs ?? catalogsSource;
        const fonts = overrideFontDictionary ?? this.defaultFontDictionary();
        this._pdfPrinter = new PdfPrinter(fonts);
        this._documentOptions = {
            ...documentOptions,
            defaultStyle: {
                ...this.defaultStyle(),
                ...documentOptions?.defaultStyle,
            },
            styles: {
                ...this.defaultDictionaryStyles(),
                ...documentOptions?.styles,
            },
            pageMargins: documentOptions?.pageMargins ?? this._defaultPageMargins,
        };
        this._options = options;
    }
    async buildRaw(data) {
        const pdfDoc = this.buildPdf(data);
        pdfDoc.end();
        const pdfBuffer = await buffer(pdfDoc);
        return pdfBuffer.toString('binary');
    }
    async buildBase64(data) {
        const pdfDoc = this.buildPdf(data);
        pdfDoc.end();
        const pdfBuffer = await buffer(pdfDoc);
        return pdfBuffer.toString('base64');
    }
    async build(data, destination) {
        return new Promise((resolve, reject) => {
            const pdfDoc = this.buildPdf(data);
            const fileWriteStream = createWriteStream(destination);
            fileWriteStream.on('error', (error) => {
                fileWriteStream.end();
                reject(error);
            });
            pdfDoc.pipe(fileWriteStream);
            pdfDoc.on('end', () => {
                resolve();
            });
            pdfDoc.on('error', (error) => {
                reject(error);
            });
            pdfDoc.end();
        });
    }
    buildStream(data) {
        return this.buildPdf(data);
    }
    buildPdf(data) {
        const pdfTemplate = this._documentTranslator.translate(data, this._documentOptions, this._catalogs, this._primaryColor, this._bgGrayColor);
        return this._pdfPrinter.createPdfKitDocument(pdfTemplate, {
            ...this._options,
            tableLayouts: this.layouts(),
        });
    }
    defaultFontDictionary() {
        return {
            Courier: {
                normal: 'Courier',
                bold: 'Courier-Bold',
                italics: 'Courier-Oblique',
                bolditalics: 'Courier-BoldOblique',
            },
            Helvetica: {
                normal: 'Helvetica',
                bold: 'Helvetica-Bold',
                italics: 'Helvetica-Oblique',
                bolditalics: 'Helvetica-BoldOblique',
            },
            Times: {
                normal: 'Times-Roman',
                bold: 'Times-Bold',
                italics: 'Times-Italic',
                bolditalics: 'Times-BoldItalic',
            },
            Symbol: {
                normal: 'Symbol',
            },
            ZapfDingbats: {
                normal: 'ZapfDingbats',
            },
        };
    }
}