fix: return value from pager

Author: devdigital

src/browser/browser.js

@@ -20,10 +20,14 @@ const createAdapted = adapter => ({
 
     return content
   },
-  page: async (data, delegate) => {
+  page: delegate => async data => {
+    let result = null
+
     await adapter(async adapted => {
-      await pager(adapted.context(), data)(delegate)
+      result = await pager(adapted.context())(delegate)(data)
     })
+
+    return result
   },
 })
 

src/browser/browser.test.js

@@ -16,7 +16,9 @@ describe('browser', () => {
   })
 
   it('should throw when adapter is not object', () => {
-    expect(() => browser()(false)).toThrow('browser adapter must be a function.')
+    expect(() => browser()(false)).toThrow(
+      'browser adapter must be a function.'
+    )
   })
 
   it('should return content from get', async () => {
@@ -45,11 +47,27 @@ describe('browser', () => {
 
     let result = null
     await use(async ({ page }) => {
-      await page('http://www.google.com', (context, data) => {
-        result = { context, data }
-      })
+      await page(accumulated => {
+        result = accumulated
+        return {
+          complete: true,
+        }
+      })()
     })
 
     expect(result.context).toBeInstanceOf(Page)
   })
+
+  it('should return expected value from page', async () => {
+    const { use } = browser()(puppeteer)
+
+    let result = null
+    await use(async ({ page }) => {
+      result = await page(accumulated => {
+        return Object.assign({}, accumulated, { complete: true })
+      })('foo')
+    })
+
+    expect(result).toEqual('foo')
+  })
 })

src/browser/pager.js

@@ -1,24 +1,24 @@
 import isNil from 'inspected/schema/is-nil'
 
-const pager = (context, data) => async delegate => {
+const pager = context => delegate => async value => {
   if (isNil(delegate)) {
     throw new Error('page delegate must be specified.')
   }
 
-  let currentContext = context
-  let currentData = data
+  let accumulated = { complete: false, context, value }
+  while (accumulated.complete === false) {
+    accumulated = await delegate(accumulated)
 
-  let result = { complete: false }
-  while (result.complete === false) {
-    result = await delegate(currentContext, currentData)
-
-    if (!result) {
+    if (!accumulated) {
       break
     }
+  }
 
-    currentContext = result.context
-    currentData = result.data
+  if (!accumulated) {
+    return null
   }
+
+  return accumulated.value ? accumulated.value : null
 }
 
 export default pager

src/browser/pager.test.js

@@ -2,24 +2,54 @@ import pager from './pager'
 
 describe('pager', () => {
   it('should throw if delegate is undefined', async () => {
-    await expect(pager()()).rejects.toHaveProperty(
+    await expect(pager()()()).rejects.toHaveProperty(
       'message',
       'page delegate must be specified.'
     )
   })
 
   it('should throw if delegate is null', async () => {
-    await expect(pager()(null)).rejects.toHaveProperty(
+    await expect(pager()()(null)).rejects.toHaveProperty(
       'message',
       'page delegate must be specified.'
     )
   })
 
   it('should pass context and data to delegate', async () => {
     let result = null
-    await pager({ foo: 'bar' }, 'baz')(
-      async (context, data) => (result = { context, data })
-    )
-    expect(result).toEqual({ context: { foo: 'bar' }, data: 'baz' })
+    await pager({ foo: 'bar' })(async accumulated => {
+      result = accumulated
+      return { complete: true }
+    })('baz')
+
+    expect(result).toEqual({
+      context: { foo: 'bar' },
+      value: 'baz',
+      complete: false,
+    })
+  })
+
+  it('should return assigned value', async () => {
+    const result = await pager()(async () => {
+      return {
+        complete: true,
+        value: 'foo',
+      }
+    })()
+
+    expect(result).toEqual('foo')
+  })
+
+  it('should accumulate context and value', async () => {
+    const result = await pager(10)(async accumulated => {
+      const complete = accumulated.value > 50
+      return {
+        complete,
+        context: accumulated.context - 1,
+        value: accumulated.value + accumulated.context,
+      }
+    })(1)
+
+    expect(result).toEqual(55)
   })
 })