Allow direct window handle

Author: Noam Rosenthal

src/index.ts

@@ -54,6 +54,6 @@ export function directJSHandle(handle: JSHandle | FutureHandle) : any {
     return new Proxy(create(null, (handle instanceof Promise) ? handle: Promise.resolve(handle)), handler)
 }
 
-export function directPageHandle(page: Page) {
+export function getWindowHandle(page: Page) {
     return directJSHandle(page.evaluateHandle('window'))
 }

test/main.unit.ts

@@ -1,6 +1,6 @@
 const puppeteer = require('puppeteer')
 import {expect} from 'chai'
-import {directJSHandle, directPageHandle} from '../src/index'
+import {directJSHandle, getWindowHandle} from '../src/index'
 
 
 describe('puppeteer-handle', () => {
@@ -12,94 +12,92 @@ describe('puppeteer-handle', () => {
 
     after(async() => await this.browser.close())
 
+    const ev = func => directJSHandle(this.page.evaluateHandle(func))
+
     it('should seamlessly evaluate into browser-side objects', async() => {
         const handle = await this.page.evaluateHandle(() => ({a: {b: () => 1}}))
         const pHandle = directJSHandle(handle)
         expect(await pHandle.a.b()).to.equal(1)
     })
 
     it('should enable thisArg', async() => {
-        const handle = await this.page.evaluateHandle(() => ({a: {val: 2, b: function() { return this.val; }}}))
-        const pHandle = directJSHandle(handle)
-        expect(await pHandle.a.b()).to.equal(2)
+        const handle = ev(() => ({a: {val: 2, b: function() { return this.val; }}}))
+        expect(await handle.a.b()).to.equal(2)
     })
 
     it('should enable arguments', async() => {
-        const handle = await this.page.evaluateHandle(() => ({add: (a, b) => a + b}))
-        const pHandle = directJSHandle(handle)
-        expect(await pHandle.add(1, 4)).to.equal(5)        
+        const handle = ev(() => ({add: (a, b) => a + b}))
+
+        expect(await handle.add(1, 4)).to.equal(5)
     })
 
 
     it('should enable async functions', async() => {
-        const handle = await this.page.evaluateHandle(() => ({later: () => Promise.resolve(4)}))
-        const pHandle = directJSHandle(handle)
-        expect(await pHandle.later()).to.equal(4)
+        const handle = ev(() => ({later: () => Promise.resolve(4)}))
+
+        expect(await handle.later()).to.equal(4)
     })
 
     it('shoult evaluate strings', async() => {
-        const handle = await this.page.evaluateHandle(() => ({str: '123'}))
-        const pHandle = directJSHandle(handle)
-        expect(await pHandle.str).to.equal('123')  
+        const handle = ev(() => ({str: '123'}))
+
+        expect(await handle.str).to.equal('123')
     })
 
     it('shoult evaluate numbers', async() => {
-        const handle = await this.page.evaluateHandle(() => ({num: 789}))
-        const pHandle = directJSHandle(handle)
-        expect(await pHandle.num).to.equal(789)  
+        const handle = ev(() => ({num: 789}))
+
+        expect(await handle.num).to.equal(789)
     })
 
     it('shoult evaluate objects', async() => {
-        const handle = await this.page.evaluateHandle(() => ({a: {b: 'something'}}))
-        const pHandle = directJSHandle(handle)
-        expect(await pHandle.a).to.deep.equal({b: 'something'})  
+        const handle = ev(() => ({a: {b: 'something'}}))
+
+        expect(await handle.a).to.deep.equal({b: 'something'})
     })
 
     it('should allow for a "then" property', async() => {
-        const handle = await this.page.evaluateHandle(() => ({then: 9}))
-        const pHandle = directJSHandle(handle)
-        expect(await pHandle.then).to.equal(9)      
+        const handle = ev(() => ({then: 9}))
+
+        expect(await handle.then).to.equal(9)
     })
 
 
     it('should allow functions in main object', async() => {
-        const handle = await this.page.evaluateHandle(() => ({a: () => 12}))
-        const pHandle = directJSHandle(handle)
-        expect(await pHandle.a()).to.equal(12)
+        const handle = ev(() => ({a: () => 12}))
+
+        expect(await handle.a()).to.equal(12)
     })
 
     it('should work with a promise', async() => {
-        const pHandle = directJSHandle(this.page.evaluateHandle(() => ({a: () => 32})))
-        expect(await pHandle.a()).to.equal(32)
+        const handle = ev(() => ({a: () => 32}))
+        expect(await handle.a()).to.equal(32)
     })
 
     it('should work with window', async() => {
-        const window = directJSHandle(this.page.evaluateHandle(() => window))
+        const window =ev(() => window)
         expect(await window.document.body.tagName).to.equal('BODY')
     })
 
     it('should evaluate on window', async() => {
-        expect(await directPageHandle(this.page).document.body.tagName).to.equal('BODY')
+        expect(await getWindowHandle(this.page).document.body.tagName).to.equal('BODY')
     })
 
     it('should allow a callback', async() => {
-        const handle = this.page.evaluateHandle(() => ({callback: cb => cb('yes')}))
-        const pHandle = directJSHandle(handle)
-        const value = await new Promise(resolve => pHandle.callback(resolve))
+        const handle = ev(() => ({callback: cb => cb('yes')}))
+        const value = await new Promise(resolve => handle.callback(resolve))
         expect(value).to.equal('yes')
     })
 
     it('should allow a callback in any arg', async() => {
-        const handle = await this.page.evaluateHandle(() => ({add: (num, cb) => cb(num + 1)}))
-        const pHandle = directJSHandle(handle)
-        const value = await new Promise(resolve => pHandle.add(1, resolve))
+        const handle = ev(() => ({add: (num, cb) => cb(num + 1)}))
+
+        const value = await new Promise(resolve => handle.add(1, resolve))
         expect(value).to.equal(2)
     })
 
     it('should work on the main handle', async() => {
-        const handle = await this.page.evaluateHandle(() => 'root')
-        const pHandle = directJSHandle(handle)
-        const value = await pHandle
+        const value = await ev(() => 'root')
         expect(value).to.equal('root')
     })
 })