from-data-to-pdf/dist/index.js

This library converts html files, URL and character string from html files to PDF files or PDF buffer.

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    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) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
const puppeteer = require("puppeteer");
const fs = require("fs");
const pathModule = require("path");
/**
 * @author DOUAL Sofian
 * @description Return a browser.
 *
 * @export
 * @returns { Promise<Browser> }
 */
function initBrowser() {
    return __awaiter(this, void 0, void 0, function* () {
        try {
            // console.log('BROWSER IS INIT');
            return yield puppeteer.launch();
        }
        catch (error) {
            throw new Error(error);
        }
    });
}
exports.initBrowser = initBrowser;
/**
 * @author DOUAL Sofian
 * @description Close given browser.
 *
 * @export
 * @param { Browser } browser
 * @returns { Promise<void> }
 */
function closeBrowser(browser) {
    return __awaiter(this, void 0, void 0, function* () {
        try {
            // console.log('BROWSER IS CLOSED');
            yield browser.close();
            return;
        }
        catch (error) {
            throw new Error(error);
        }
    });
}
exports.closeBrowser = closeBrowser;
/**
 * @author DOUAL Sofian
 * @description If path is undefined, returns an array of PDFS buffer. Otherwise, return the path of the saved PDF files.
 *
 * @export
 * @param { Browser } browser
 * @param { FileBuffer[] } targets
 * @param { string } [path]
 * @returns {Promise<FileBuffer>}
 */
function generateBuffer(browser, targets, path) {
    return __awaiter(this, void 0, void 0, function* () {
        try {
            const page = yield browser.newPage();
            const targetMax = targets.length;
            for (let i = 0; i < targetMax; i++) {
                if (!targets[i].name) {
                    if (targets[i].url)
                        delete targets[i].url;
                    else if (targets[i].text)
                        delete targets[i].text;
                    else if (targets[i].options)
                        delete targets[i].options;
                    targets[i]['error'] = new Error('Projects need name.');
                    continue;
                }
                if (targets[i].url) {
                    yield page.goto(targets[i].url, {
                        waitUntil: 'networkidle0'
                    });
                    delete targets[i].url;
                }
                else if (targets[i].text) {
                    yield page.setContent(targets[i].text, {
                        waitUntil: "networkidle0"
                    });
                    delete targets[i].text;
                }
                else {
                    continue;
                }
                // define the default pdf options.
                if (!targets[i].options) {
                    targets[i]['options'] = {
                        printBackground: true,
                        preferCSSPageSize: true,
                        displayHeaderFooter: true
                    };
                }
                if (path) {
                    const pdfName = pathModule.join(path, (targets[i].name.split(' ').join('-') + Date.now().toString() + '.pdf'));
                    targets[i].options['path'] = pdfName;
                    if (targets[i].url)
                        delete targets[i].url;
                    else if (targets[i].text)
                        delete targets[i].text;
                    yield page.pdf(targets[i].options);
                    targets[i]['pathOfsavedFile'] = pdfName;
                    delete targets[i].options;
                }
                else {
                    targets[i]['buffer'] = yield page.pdf(targets[i].options);
                    delete targets[i].options;
                }
            }
            return targets;
        }
        catch (error) {
            throw new Error(error);
        }
    });
}
exports.generateBuffer = generateBuffer;
/**
 * @author DOUAL Sofian
 * @description Save the buffer as a PDF file in <My project>/temp/generatedPDF/.
 *
 * @export
 * @param { FileBuffer[] } targets
 * @returns { Promise<FileBuffer[]> }
 */
function savePDF(targets) {
    return __awaiter(this, void 0, void 0, function* () {
        const targetMax = targets.length;
        for (let i = 0; i < targetMax; i++) {
            try {
                if (!targets[i].name)
                    throw new Error("Projects need name.");
                let path = __filename.split('\\node_modules');
                path = (path.length > 1 ? path[0] : path[0].split('\\dist')[0]) + '/temp/generatedPDF/';
                const pdfName = path + targets[i].name.split(' ').join('-') + Date.now().toString() + '.pdf';
                const pdf = yield fs.promises.open(pdfName, 'a');
                yield pdf.appendFile(targets[i].buffer);
                pdf.close();
                targets[i]['pathOfsavedFile'] = pdfName;
                delete targets[i].buffer;
            }
            catch (error) {
                delete targets[i].buffer;
                targets[i]['error'] = error;
                continue;
            }
        }
        return targets;
    });
}
exports.savePDF = savePDF;
/**
 * @author DOUAL Sofian
 * @description Create folders ./temp, ./temp/target, ./temp/generatedPDF
 *
 * @returns { Promise<boolean> }
 */
function initDefaultFolder() {
    return __awaiter(this, void 0, void 0, function* () {
        try {
            let folderRoot = setPath();
            let contentFolder = yield fs.promises.readdir(folderRoot);
            contentFolder = contentFolder.filter(x => x === 'temp');
            const tempPath = setPath('./temp/');
            const targetPath = setPath('./temp/target/)');
            const pdfPath = setPath('./temp/generatedPDF/');
            if (contentFolder.length === 0) {
                yield fs.promises.mkdir(tempPath);
                yield fs.promises.mkdir(targetPath);
                yield fs.promises.mkdir(pdfPath);
                return false;
            }
            else {
                const contentTemp = yield fs.promises.readdir(tempPath);
                let reload = false;
                if (!contentTemp.includes('target')) {
                    yield fs.promises.mkdir(targetPath);
                    reload = true;
                }
                if (!contentTemp.includes('generatedPDF')) {
                    yield fs.promises.mkdir(pdfPath);
                    reload = true;
                }
                if (reload)
                    return false;
                return true;
            }
        }
        catch (error) {
            throw new Error(error);
        }
    });
}
exports.initDefaultFolder = initDefaultFolder;
/**
 * @author DOUAL Sofian
 * @description Converts HTML files to string.
 *
 * @param { HTMLTarget[] } data
 * @param { string } [path]
 * @returns { Promise<FileBuffer[]> }
 */
function fromHtmlFileToString(data, path) {
    return __awaiter(this, void 0, void 0, function* () {
        try {
            const folderRoot = setPath((path !== null && path !== void 0 ? path : undefined));
            const countProjects = data.length;
            if (countProjects > 0) {
                const res = [];
                for (let i = 0; i < countProjects; i++) {
                    if (data[i].projectName && data[i].fileName) {
                        let project = {
                            name: data[i].projectName,
                            options: data[i].pdfOptions
                        };
                        if (folderRoot === setPath()) {
                            project['text'] = yield fs.promises.readFile(pathModule.join(folderRoot, '/temp/target/', data[i].fileName), { encoding: 'utf-8' });
                        }
                        else {
                            project['text'] = yield fs.promises.readFile(pathModule.join(folderRoot, data[i].fileName), { encoding: 'utf-8' });
                        }
                        res.push(project);
                        delete data[i];
                    }
                    else {
                        let project = {
                            name: data[i].projectName,
                            error: new Error('Projects need name && file name.')
                        };
                        res.push(project);
                        delete data[i];
                    }
                }
                return res;
            }
            else {
                throw 'No project detected.';
            }
        }
        catch (error) {
            throw new Error(error);
        }
    });
}
exports.fromHtmlFileToString = fromHtmlFileToString;
// Scripts
/**
 * @author DOUAL Sofian
 * @description Carries out the process without to get local files.
 *
 * @export
 * @param { FileBuffer[] } targets
 * @param { boolean } save
 * @param { path } [path]
 * @returns { Promise<FileBuffer[]> }
 */
function getPdf(targets, save, path) {
    return __awaiter(this, void 0, void 0, function* () {
        const browser = yield initBrowser();
        if (save) {
            let folderToSavePdf = setPath((path !== null && path !== void 0 ? path : undefined));
            if (!path) {
                yield initDefaultFolder();
                folderToSavePdf = pathModule.join(folderToSavePdf, '/temp/generatedPDF/');
            }
            targets = yield generateBuffer(browser, targets, folderToSavePdf);
        }
        else {
            targets = yield generateBuffer(browser, targets);
        }
        yield closeBrowser(browser);
        return targets;
    });
}
exports.getPdf = getPdf;
/**
 * @author DOUAL Sofian
 * @description Get html files and carries out the process.
 *
 * @export
 * @param { HTMLTarget[] } files
 * @param { boolean } save
 * @param { Path } [path]
 * @returns { Promise<FileBuffer[]> }
 */
function fromHtmlFileToPdf(files, save, path) {
    var _a, _b, _c, _d, _e;
    return __awaiter(this, void 0, void 0, function* () {
        let formatedFiles = yield fromHtmlFileToString(files, (_b = (_a = path) === null || _a === void 0 ? void 0 : _a.toGetFiles, (_b !== null && _b !== void 0 ? _b : undefined)));
        const browser = yield initBrowser();
        if (save) {
            let folderToSavePdf = setPath((_d = (_c = path) === null || _c === void 0 ? void 0 : _c.toSaveFiles, (_d !== null && _d !== void 0 ? _d : undefined)));
            if (!((_e = path) === null || _e === void 0 ? void 0 : _e.toSaveFiles)) {
                yield initDefaultFolder();
                folderToSavePdf = pathModule.join(folderToSavePdf, '/temp/generatedPDF/');
            }
            formatedFiles = yield generateBuffer(browser, formatedFiles, folderToSavePdf);
        }
        else {
            formatedFiles = yield generateBuffer(browser, formatedFiles);
        }
        yield closeBrowser(browser);
        return formatedFiles;
    });
}
exports.fromHtmlFileToPdf = fromHtmlFileToPdf;
/**
 * @author DOUAL Sofian
 * @description It returns the path of the app directory if path param does not exists.
 *  Else if path param exists and it is a relative path, this method joins it with the path of app directory to finally returns the result as string.
 *  Else if path param exists and it is an absolute path, this methods return it.
 *
 * @param { string } [path]
 * @returns { string }
 */
function setPath(path) {
    try {
        if (path) {
            if (pathModule.isAbsolute(path)) {
                return path;
            }
            else {
                let dirPath = __filename.split('\\node_modules');
                dirPath = (dirPath.length > 1 ? dirPath[0] : dirPath[0].split('\\dist')[0]);
                return pathModule.join(dirPath, path);
            }
        }
        else {
            let dirPath = __filename.split('\\node_modules');
            dirPath = (dirPath.length > 1 ? dirPath[0] : dirPath[0].split('\\dist')[0]);
            return dirPath;
        }
    }
    catch (error) {
        throw new Error(error);
    }
}
exports.setPath = setPath;