n8n-nodes-puppeteer-extended/dist/nodes/Puppeteer/Puppeteer.node.js

n8n node for requesting webpages using Puppeteer

"use strict";
var __asyncValues = (this && this.__asyncValues) || function (o) {
    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
    var m = o[Symbol.asyncIterator], i;
    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Puppeteer = void 0;
const puppeteer_1 = require("puppeteer");
const Puppeteer_node_options_1 = require("./Puppeteer.node.options");
const helpers_1 = require("./puppeteer/helpers");
const puppeteer_2 = __importDefault(require("./puppeteer"));
if (!process.send)
    (0, puppeteer_2.default)();
class Puppeteer {
    constructor() {
        this.description = Puppeteer_node_options_1.nodeDescription;
        this.methods = {
            loadOptions: {
                async getDevices() {
                    const deviceNames = Object.keys(puppeteer_1.devices);
                    const returnData = [];
                    for (const name of deviceNames) {
                        const device = puppeteer_1.devices[name];
                        returnData.push({
                            name,
                            value: name,
                            description: `${device.viewport.width} x ${device.viewport.height} @ ${device.viewport.deviceScaleFactor}x`,
                        });
                    }
                    return returnData;
                },
            },
        };
    }
    async execute() {
        var e_1, _a;
        let returnData = [];
        const credentials = (await this.getCredentials("n8nApi"));
        const executionId = this.getExecutionId();
        const globalOptions = this.getNodeParameter("globalOptions", 0, {});
        const nodeOptions = this.getNodeParameter("nodeOptions", 0, {});
        const url = this.getNodeParameter("url", 0, {});
        const queryParameters = this.getNodeParameter("queryParameters", 0, {});
        const interactions = this.getNodeParameter("interactions", 0, {});
        const output = this.getNodeParameter("output", 0, {});
        const isStarted = await (0, helpers_1.ipcRequest)("launch", {
            globalOptions,
            executionId,
        }).catch((e) => {
            throw new Error(e);
        });
        if (isStarted) {
            console.log("exec", globalOptions);
            const res = await (0, helpers_1.ipcRequest)("exec", {
                nodeParameters: {
                    globalOptions,
                    nodeOptions,
                    url,
                    queryParameters,
                    interactions,
                    output,
                },
                executionId,
                continueOnFail: this.continueOnFail(),
            }).catch((e) => {
                throw new Error(e);
            });
            if (res) {
                if (res.binary) {
                    try {
                        for (var _b = __asyncValues(Object.keys(res.binary)), _c; _c = await _b.next(), !_c.done;) {
                            const key = _c.value;
                            const type = res.binary[key].type;
                            const binaryData = await this.helpers
                                .prepareBinaryData(Buffer.from(res.binary[key].data), undefined, type === "pdf"
                                ? "application/pdf"
                                : `image/${res.binary[key].type}`)
                                .catch((e) => console.log(e));
                            if (binaryData)
                                res.binary[key] = binaryData;
                            else
                                delete res.binary[key];
                        }
                    }
                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
                    finally {
                        try {
                            if (_c && !_c.done && (_a = _b.return)) await _a.call(_b);
                        }
                        finally { if (e_1) throw e_1.error; }
                    }
                }
                returnData = [res];
            }
        }
        (0, helpers_1.ipcRequest)("check", {
            executionId,
            apiKey: credentials.apiKey,
            baseUrl: credentials.baseUrl,
        });
        return this.prepareOutputData(returnData);
    }
}
exports.Puppeteer = Puppeteer;
//# sourceMappingURL=Puppeteer.node.js.map