fix: super charge returned function to support both async and iterator

Author: antfu

src/index.ts

@@ -27,7 +27,7 @@ export type QuansyncGenerator<Return = any, Yield = unknown> =
  * "Superposition" function that can be consumed in both sync and async contexts.
  */
 export type QuansyncFn<Return = any, Args extends any[] = []> =
-  ((...args: Args) => QuansyncGenerator<Return>)
+  ((...args: Args) => QuansyncGenerator<Return> & Promise<Return>)
   & {
     sync: (...args: Args) => Return
     async: (...args: Args) => Promise<Return>
@@ -53,12 +53,15 @@ function fromObject<Return, Args extends any[]>(
       async: (options.async as any).bind(null, ...args),
       __isQuansync: true,
     }
-  } as unknown as QuansyncFn<Return, Args>
-
-  generator.sync = options.sync
-  generator.async = options.async
-
-  return generator
+  }
+  const fn = (...args: Args): any => {
+    const iter = generator(...args) as unknown as QuansyncGenerator<Return, Args> & Promise<Return>
+    iter.then = fn => options.async(...args).then(fn)
+    return iter
+  }
+  fn.sync = options.sync
+  fn.async = options.async
+  return fn
 }
 
 function fromPromise<T>(promise: Promise<T> | T): QuansyncFn<T, []> {
@@ -135,8 +138,8 @@ export function quansync<Return, Args extends any[] = []>(
  */
 export function quansyncMacro<Return, Args extends any[] = []>(
   options: QuansyncInput<Return, Args> | ((...args: Args) => Promise<Return> | Return),
-): QuansyncFn<Return, Args> {
-  return quansync(options as any)
+): QuansyncFn<Return> {
+  return quansync(options as any) as any
 }
 
 /**

test/index.test.ts

@@ -57,6 +57,21 @@ it('generator', async () => {
   expect(await multiply.async(4, 5)).toBe('20')
 })
 
+it('consume with await', async () => {
+  const add = quansync({
+    name: 'add',
+    sync: (a: number, b: number) => a + b,
+    async: async (a: number, b: number) => {
+      await new Promise(resolve => setTimeout(resolve, 10))
+      return a + b
+    },
+  })
+
+  expect(add(2, 3)).resolves.toBe(5)
+  expect(add.sync(2, 6)).toBe(8)
+  expect(add.async(2, 3)).resolves.toBe(5)
+})
+
 it('yield optional promise', async () => {
   interface Transformer {
     transform: (code: string) => string | Promise<string>