There is a built-in option for that:

await page.goto('https://www.digg.com/', {"waitUntil" : "networkidle0"});

networkidle0 - consider navigation to be finished when there are no more than 0 network connections for at least 500 ms

networkidle2 - consider navigation to be finished when there are no more than 2 network connections for at least 500 ms.

Of course it won't work if you're working with endless-scrolling-single-page-applications like Twitter.

Puppeteer GitHub issue #1552 provides explanation for the motivation behind networkidle2.

You can try to wrap your promises inside a Promise.all.

So instead of returning result, you return Promise.all(result) which will resolve once it get's all of the data.

Also, there are many different ways to go thru the list or selectors.

$$eval

This runs Array.from(document.querySelectorAll(selector)) within the page and passes it as the first argument to pageFunction.

Example code:

await page.$$eval('a', a => a.href)

evaluate

This is golden and you can execute any code that you can execute on your browsers console.

const result = await page.evaluate(() =>
  [...document.querySelectorAll('input')] // or anything that you want to use normally
)

Useful APIs

There are several useful APIs that can be used wisely:

• .type: types a text on selector
• .click: Clicks an elementhandle/selector etc
• .select: Selects something from a element

Know what doesn't work

elementHandle.attribute() has been removed on #638. Which means getting attribute should be handled by $eval from now.

The error occurs because when nightmare code (which expects to run on a Node.js environment) runs on the client child_process doesn't exist. You could add a condition to ensure it's only run on the server.

if (typeof window === 'undefined') {
    const test = require('nightmare');
}

However, I'm unsure why you'd want to run it in a page. It's not meant to run in the browser.

I had this issue when trying to use the integratedConsole rather than integratedTerminal or externalTerminal as part of my Node configuration within launch.json:

Setting it back to:

"console": "integratedTerminal"

Fixed it. Only took an hour to figure out. See docs for more information.

Instead of a txt you should choose JSON to store your list of referer values in an array.

referers.json

["https://www.google.com", "https://www.facebook.com", "https://www.instagram.com"]

Then you will be able to pick a random element form the array by: array[randomIndex]. To generate a random number for the length of your array you have multiple possibilities, Math.floor(Math.random() * array.length) only one of them.

referers.js

const puppeteer = require('puppeteer')
const referers = require('./referers.json')

async function fn() {
  const randomReferer = referers[Math.floor(Math.random() * referers.length)]
  console.log(referers)
  console.log(randomReferer)
  const browser = await puppeteer.launch({ headless: false, devtools: true })
  const page = await browser.newPage()

  page.setExtraHTTPHeaders({ referer: randomReferer })

  await page.goto('https://www.instagram.com/')
}
fn()

output example:

[
  'https://www.google.com',
  'https://www.facebook.com',
  'https://www.instagram.com'
]
https://www.facebook.com

You should import puppeteer outside of your function, so firebase can reuse it. Also you don't need to create timeouts, but you can use await page.waitFor(5000); instead. I tried to create a minimal example for your use case. If you still run into errors, please go to your firebase functions console and check the logs, they should tell you what's wrong.

There is also the possibility that you haven't enabled billing on your firebase account - in this case your function cannot reach 3rd party hosts.

import * as functions from 'firebase-functions';
import * as puppeteer from 'puppeteer';

export const generatePDF = functions
    .runWith({ timeoutSeconds: 30, memory: "1GB" })
    .https.onRequest(async (request, response) => {

        const url = 'https://www.yoururl.com/';
        const browser = await puppeteer.launch({ headless: true, args: ['--no-sandbox'] });

        const page = await browser.newPage();
        await page.goto(url);
        await page.waitFor(5000);

        const pdf = await page.pdf({
            format: 'A4',
        });

        await browser.close();

        response.setHeader('Content-Disposition', 'filename=customfilename.pdf');
        return response.type('application/pdf').send(pdf);
    });

Google is doing this in Google+ and a talented developer reverse engineered it and produced http://html2canvas.hertzen.com/ . To work in IE you'll need a canvas support library such as http://excanvas.sourceforge.net/

I think you could use Puppeteer to generate a pdf. I've not tried it but here are some links that demonstrate this approach:

• advanced-pdf-generation-for-node-js-using-puppeteer
• pdf-from-html-node-js-puppeteer
• high-quality-pdf-generation-using-puppeteer

This should work, tested with version 1.7.0 on https://try-puppeteer.appspot.com/

const browser = await puppeteer.launch();

const page = await browser.newPage();
await page.goto('http://www.supremenewyork.com/shop/jackets/uaxjeqvro/fm9kozqa6');

let $elemHandler = await page.$('#s');
let properties = await $elemHandler.getProperties();
for (const property of properties.values()) {
  const element = property.asElement();
  if (element){
    let hText = await element.getProperty("text");
    let text = await hText.jsonValue();
    if(text==="Large"){
       let hValue = await element.getProperty("value");
       let value = await hValue.jsonValue();
      await page.select("#s",value); // or use 58730
      console.log(`Selected ${text} which is value ${value}.`);
    }
  }
}
await browser.close();