--reuse option

1 files changed, 68 insertions, 55 deletions

diff --git a/browser.js b/browser.js
index dfad399..d1f5c50 100644
--- a/browser.js
+++ b/browser.js
@@ -4,77 +4,90 @@ const cookiesStorage = require("./cookies-storage");
 puppeteer.use(StealthPlugin());
 
 
-const options = {
+const chromeOptions = {
     headless: true,
     args: []
 };
 
 let browser = null
-let page = null
 let cdpClient = null
-let interceptCallback = null
-let interceptionNeededCallback = null
 
-module.exports = {
-    async launch() {
-        browser = await puppeteer.launch(options)
-    },
+class PageWrapper {
+    constructor() {
+        this.intrNeededCallback = null
+        this.intrCallback = null
+
+        this.page = null
+    }
 
-    async getPage(_interceptionNeededCallback, _interceptCallback) {
-        if (page && page.isClosed()) {
-            page.removeAllListeners && page.removeAllListeners()
-            page = null
+    async getPage(interceptionNeededCallback, interceptCallback) {
+        this.intrCallback = interceptCallback
+        this.intrNeededCallback = interceptionNeededCallback
+
+        if (this.page !== null && this.page.isClosed()) {
+            this.page.removeAllListeners && this.page.removeAllListeners()
+            this.page = null
         }
 
-        interceptionNeededCallback = _interceptionNeededCallback
-        interceptCallback = _interceptCallback
+        if (this.page !== null)
+            return this.page
 
-        if (!page) {
-            page = await browser.newPage()
-            page.on('framenavigated', async () => {
-                let cookies = await page.cookies();
+        this.page = await browser.newPage()
+        this.page.on('domcontentloaded', async () => {
+            try {
+                let cookies = await this.page.cookies();
                 if (cookies)
                     await cookiesStorage.save(cookies)
-            })
-
-            await page.setCookie(...(await cookiesStorage.get()))
-
-            cdpClient = await page.target().createCDPSession();
-            await cdpClient.send('Network.setRequestInterception', {
-                patterns: [{
-                    urlPattern: '*',
-                    resourceType: 'Document',
-                    interceptionStage: 'HeadersReceived'
-                }],
-            })
-            await cdpClient.on('Network.requestIntercepted', async e => {
-                let obj = { interceptionId: e.interceptionId }
-                if (interceptionNeededCallback && interceptionNeededCallback(e) === true) {
-                    let ret = await cdpClient.send('Network.getResponseBodyForInterception', {
-                        interceptionId: e.interceptionId
-                    })
-                    interceptCallback(ret, e.responseHeaders)
-                    obj['errorReason'] = 'BlockedByClient'
-                }
-                await cdpClient.send('Network.continueInterceptedRequest', obj)
-            })
-        }
+            } catch (e) {
+                console.warn(e)
+            }
+        })
 
-        return page
-    },
+        await this.page.setCookie(...(await cookiesStorage.get()))
 
-    setProxy(proxy) {
-        options.args.push(`--proxy-server=${proxy}`)
-    },
+        cdpClient = await this.page.target().createCDPSession();
+        await cdpClient.send('Network.setRequestInterception', {
+            patterns: [{
+                urlPattern: '*',
+                resourceType: 'Document',
+                interceptionStage: 'HeadersReceived'
+            }],
+        })
+        await cdpClient.on('Network.requestIntercepted', async e => {
+            let obj = { interceptionId: e.interceptionId }
+            if (this.intrNeededCallback && this.intrNeededCallback(e) === true) {
+                let ret = await cdpClient.send('Network.getResponseBodyForInterception', {
+                    interceptionId: e.interceptionId
+                })
+                this.intrCallback(ret, e.responseHeaders)
+                obj['errorReason'] = 'BlockedByClient'
+            }
+            await cdpClient.send('Network.continueInterceptedRequest', obj)
+        })
 
-    disableSandbox() {
-        options.args.push(
-            '--no-sandbox',
-            '--disable-setuid-sandbox'
-        )
+        return this.page
+    }
+}
+
+let singlePageWrapper = new PageWrapper()
+
+module.exports = {
+    async launch(options) {
+        if (options.proxy)
+            chromeOptions.args.push(`--proxy-server=${options.proxy}`)
+
+        if (options.noSandbox)
+            chromeOptions.args.push(
+                '--no-sandbox',
+                '--disable-setuid-sandbox'
+            )
+
+        if (options.headful)
+            chromeOptions.headless = false
+
+        browser = await puppeteer.launch(chromeOptions)
     },
 
-    setHeadful() {
-        options.headless = false
-    }
+    singlePageWrapper,
+    PageWrapper,
 }
\ No newline at end of file