@browserless/function 10.10.1 → 10.10.2

package/package.json

@@ -2,7 +2,7 @@
   "name": "@browserless/function",
   "description": "Execute arbitrary JavaScript code in a secure browser sandbox with access to page DOM and network.",
   "homepage": "https://browserless.js.org",
-  "version": "10.10.1",
+  "version": "10.10.2",
   "main": "src/index.js",
   "author": {
     "email": "hello@microlink.io",
@@ -57,5 +57,5 @@
     "timeout": "2m",
     "workerThreads": false
   },
-  "gitHead": "32f6e72bcb489a83ac9659520a3961aeb97c47b7"
+  "gitHead": "ec6a614923a1a692bd717ecc8e6f1b09417801d9"
 }

package/src/function.js

@@ -5,10 +5,17 @@ const template = require('./template')
 
 const [nodeMajor] = process.version.slice(1).split('.').map(Number)
 
-module.exports = async ({ url, code, vmOpts, browserWSEndpoint, ...opts }) => {
-  const needsNetwork = template.isUsingPage(code)
+module.exports = async ({
+  url,
+  code,
+  vmOpts,
+  browserWSEndpoint,
+  needsNetwork = template.isUsingPage(code),
+  source = template(code, needsNetwork),
+  ...opts
+}) => {
   const permissions = needsNetwork && nodeMajor >= 25 ? ['net'] : []
-  const [fn, teardown] = isolatedFunction(template(code), {
+  const [fn, teardown] = isolatedFunction(source, {
     ...vmOpts,
     allow: { permissions },
     throwError: false
@@ -17,3 +24,6 @@ module.exports = async ({ url, code, vmOpts, browserWSEndpoint, ...opts }) => {
   await teardown()
   return result
 }
+
+module.exports.isUsingPage = template.isUsingPage
+module.exports.buildTemplate = template

package/src/index.js

@@ -6,40 +6,68 @@ const runFunction = require('./function')
 
 const stringify = fn => fn.toString().trim().replace(/;$/, '')
 
-module.exports =
-  (
-    fn,
-    {
-      getBrowserless = requireOneOf(['browserless']),
-      retry = 2,
-      timeout = 30000,
-      gotoOpts,
-      ...opts
-    } = {}
-  ) =>
-    async (url, fnOpts = {}) => {
-      const browserlessPromise = getBrowserless()
-      const browser = await browserlessPromise
-      const browserless = await browser.createContext()
-
-      return browserless.withPage((page, goto) => async () => {
-        const { device } = await goto(page, { url, timeout, ...gotoOpts })
-
-        const browserWSEndpoint = (await browserless.browser()).wsEndpoint()
-        if (!browserWSEndpoint) throw new Error('Browser WebSocket endpoint not found')
+module.exports = (
+  fn,
+  {
+    getBrowserless = requireOneOf(['browserless']),
+    retry = 2,
+    timeout = 30000,
+    gotoOpts,
+    ...opts
+  } = {}
+) => {
+  const code = stringify(fn)
+  const needsNetwork = runFunction.isUsingPage(code)
+  const source = runFunction.buildTemplate(code, needsNetwork)
+  let browserPromise
 
-        const result = await runFunction({
-          url,
-          code: stringify(fn),
-          browserWSEndpoint: (await browserless.browser()).wsEndpoint(),
-          device,
-          ...opts,
-          ...fnOpts
-        })
-
-        if (result.isFulfilled) return result
-        const error = ensureError(result.value)
-        if (isBrowserlessError(error)) throw error
-        return result
-      })()
+  const getBrowser = async () => {
+    if (!browserPromise) {
+      browserPromise = Promise.resolve(getBrowserless()).catch(error => {
+        browserPromise = undefined
+        throw error
+      })
     }
+    return browserPromise
+  }
+
+  return async (url, fnOpts = {}) => {
+    const browser = await getBrowser()
+    const browserless = await browser.createContext()
+
+    return browserless.withPage((page, goto) => async () => {
+      const { device } = await goto(page, { url, timeout, ...gotoOpts })
+
+      const runFunctionOpts = {
+        url,
+        code,
+        device,
+        ...opts,
+        ...fnOpts
+      }
+
+      if (runFunctionOpts.code === code) {
+        runFunctionOpts.needsNetwork = needsNetwork
+        runFunctionOpts.source = source
+      }
+
+      if (runFunctionOpts.needsNetwork !== false) {
+        const browserFromPage = typeof page.browser === 'function' ? page.browser() : undefined
+        const browserWSEndpoint =
+          browserFromPage && typeof browserFromPage.wsEndpoint === 'function'
+            ? browserFromPage.wsEndpoint()
+            : undefined
+
+        if (!browserWSEndpoint) throw new Error('Browser WebSocket endpoint not found')
+        runFunctionOpts.browserWSEndpoint = browserWSEndpoint
+      }
+
+      const result = await runFunction(runFunctionOpts)
+
+      if (result.isFulfilled) return result
+      const error = ensureError(result.value)
+      if (isBrowserlessError(error)) throw error
+      return result
+    })()
+  }
+}

package/src/template.js

@@ -29,8 +29,8 @@ const isUsingPage = code => {
   return result
 }
 
-const template = code => {
-  if (!isUsingPage(code)) return `async (url, _, opts) => (${code})(opts)`
+const template = (code, usesPage = isUsingPage(code)) => {
+  if (!usesPage) return `async (url, _, opts) => (${code})(opts)`
   return `
     async (url, browserWSEndpoint, opts) => {
       const puppeteer = require('@cloudflare/puppeteer')