html-to-pdf-converter/commonjs/compound-pdf.js

HTML to PDF converter with support for HEADERS, FOOTERS and page numbers

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
const puppeteer = require("puppeteer");
const puppeteer_1 = require("./puppeteer");
const types_1 = require("./types");
const helpers_1 = require("./helpers");
const hummus_1 = require("./hummus");
const index_1 = require("./utils/index");
const index_2 = require("./index");
const calcSlotSize = (footer, margin, pageSize, page) => __awaiter(this, void 0, void 0, function* () {
    switch (footer.type) {
        case 'HtmlSlot': {
            return puppeteer_1.calcContentSize(footer.html, pageSize, margin, page);
        }
        case 'TextSlot': {
            const { left, center, right } = footer;
            const height = [left, center, right]
                .filter((x) => x !== undefined)
                .map(x => x.size)
                .reduce((a, b) => index_2.Millimeters.max(a, b));
            return {
                width: pageSize.width.subtract(margin.left).subtract(margin.right),
                height: height.add(index_2.Millimeters.of(4)),
            };
        }
        default:
            return index_1.unreachable(footer);
    }
});
const mkPdfWithSpaceForSlots = ({ pdfContent, header, footer, margin, pageSize }, page) => __awaiter(this, void 0, void 0, function* () {
    const headerSize = header ? yield calcSlotSize(header, margin, pageSize, page) : types_1.PageSize.ofZero();
    const footerSize = footer ? yield calcSlotSize(footer, margin, pageSize, page) : types_1.PageSize.ofZero();
    const pdfBuffer = yield puppeteer_1.mkSizedPdf(pdfContent, page, pageSize, Object.assign({}, margin, { top: margin.top.add(headerSize.height), bottom: margin.bottom.add(footerSize.height) }));
    return {
        mainPdf: pdfBuffer,
        margin,
        header: header ? { size: headerSize, data: header } : undefined,
        footer: footer ? { size: footerSize, data: footer } : undefined,
    };
});
const addSlotToPdf = (args) => __awaiter(this, void 0, void 0, function* () {
    const { pdf, margin, slot, pagesCount, page, startFromPage, totalPagesCount, slotType } = args;
    const { data, size } = slot;
    switch (data.type) {
        case 'HtmlSlot': {
            const htmlContent = helpers_1.propagatePageNumbers(data.html, startFromPage, startFromPage + pagesCount, totalPagesCount);
            const slotPdf = yield puppeteer_1.mkSizedPdf(htmlContent, page, size);
            return hummus_1.mergePdfs(pdf, slotPdf, margin, slotType, size);
        }
        case 'TextSlot': {
            if (slotType === 'header') {
                throw new Error('TODO: to be developed!');
            }
            return hummus_1.addFooter({
                pdfBuffer: pdf,
                margin,
                txt: data,
                startPageNum: startFromPage,
                endPageNum: startFromPage + pagesCount,
                totalPagesCount,
            });
        }
        default:
            return index_1.unreachable(data);
    }
});
const mkCompoundPdf = (contents, browser) => __awaiter(this, void 0, void 0, function* () {
    const page = yield browser.newPage();
    const pdfsWithSpaceForSlots = [];
    for (let content of contents) {
        const pdfData = yield mkPdfWithSpaceForSlots(content, page);
        const pagesCount = hummus_1.getPagesCount(pdfData.mainPdf);
        pdfsWithSpaceForSlots.push({ content: pdfData, pagesCount });
    }
    const totalPagesCount = pdfsWithSpaceForSlots
        .map(x => x.pagesCount)
        .reduce((acc, v) => acc + v, 0);
    const pdfsWithSlots = [];
    let startPage = 1;
    for (let { content, pagesCount } of pdfsWithSpaceForSlots) {
        const { mainPdf, margin, footer, header } = content;
        const common = { margin, pagesCount, page, startFromPage: startPage, totalPagesCount };
        const withHeader = header
            ? yield addSlotToPdf(Object.assign({}, common, { pdf: mainPdf, slot: header, slotType: 'header' }))
            : mainPdf;
        const withSlots = footer
            ? yield addSlotToPdf(Object.assign({}, common, { pdf: withHeader, slot: footer, slotType: 'footer' }))
            : withHeader;
        pdfsWithSlots.push(withSlots);
        startPage += pagesCount;
    }
    yield page.close();
    return hummus_1.appendPdfs(pdfsWithSlots);
});
const mkPdf = ({ margin, pageSize, pdfContent }, browser) => __awaiter(this, void 0, void 0, function* () {
    const page = yield browser.newPage();
    const pdfBuffer = yield puppeteer_1.mkSizedPdf(pdfContent, page, pageSize, margin);
    yield page.close();
    return pdfBuffer;
});
exports.initialize = (options = {}) => __awaiter(this, void 0, void 0, function* () {
    const browser = yield puppeteer.launch(options.puppeteer);
    return {
        mkCompoundPdf: (contents) => mkCompoundPdf(contents, browser),
        mkPdf: (content) => mkPdf(content, browser),
        destroy: () => browser.close(),
    };
});
//# sourceMappingURL=compound-pdf.js.map