feat: support resolve yield promise

Author: antfu

README.md

@@ -28,8 +28,8 @@ import { quansync } from 'quansync'
 
 // Create an quansync function by providing `sync` and `async` implementations
 const readFile = quansync({
-  sync: fs.readFileSync,
-  async: fs.promises.readFile,
+  sync: (path: string) => fs.readFileSync(path),
+  async: (path: string) => fs.promises.readFile(path),
 })
 
 // Create an quansync function by providing a generator function

src/index.ts

@@ -1,14 +1,15 @@
-export interface QuansyncInputObject<Args extends any[], Return> {
+export interface QuansyncInputObject<Return, Args extends any[]> {
   name?: string
   sync: (...args: Args) => Return
   async: (...args: Args) => Promise<Return>
 }
-export type QuansyncInputGenerator<Args extends any[], Return>
+
+export type QuansyncInputGenerator<Return, Args extends any[]>
   = ((...args: Args) => QuansyncGenerator<Return>)
 
-export type QuansyncInput<Args extends any[], Return> =
-  | QuansyncInputObject<Args, Return>
-  | QuansyncInputGenerator<Args, Return>
+export type QuansyncInput<Return, Args extends any[]> =
+  | QuansyncInputObject<Return, Args>
+  | QuansyncInputGenerator<Return, Args>
 
 export interface QuansyncYield<R> {
   name?: string
@@ -17,58 +18,75 @@ export interface QuansyncYield<R> {
   __isQuansync: true
 }
 
-export type UnwrapQuansyncReturn<T> = T extends QuansyncYield<infer R> ? R : T
+export type UnwrapQuansyncReturn<T> = T extends QuansyncYield<infer R> ? Awaited<R> : Awaited<T>
 
 export type QuansyncGenerator<Return = any, Yield = unknown> =
   Generator<Yield, Return, UnwrapQuansyncReturn<Yield>>
 
 /**
  * "Superposition" function that can be consumed in both sync and async contexts.
  */
-export type QuansyncFn<Args extends any[] = [], Return = any> =
+export type QuansyncFn<Return = any, Args extends any[] = []> =
   ((...args: Args) => QuansyncGenerator<Return>)
   & {
     sync: (...args: Args) => Return
     async: (...args: Args) => Promise<Return>
   }
 
+const ERROR_PROMISE_IN_SYNC = '[Quansync] Yielded an unexpected promise in sync context'
+
+function isThenable<T>(value: any): value is Promise<T> {
+  return value && typeof value === 'object' && typeof value.then === 'function'
+}
+
 export function isQuansyncYield<T>(value: any | QuansyncYield<T>): value is QuansyncYield<T> {
   return typeof value === 'object' && value !== null && '__isQuansync' in value
 }
 
-function fromObject<Args extends any[], Return>(
-  options: QuansyncInputObject<Args, Return>,
-): QuansyncFn<Args, Return> {
+function fromObject<Return, Args extends any[]>(
+  options: QuansyncInputObject<Return, Args >,
+): QuansyncFn<Return, Args > {
   const generator = function *(...args: Args): QuansyncGenerator<Return, any> {
     return yield {
       name: options.name,
-      sync: () => options.sync(...args),
-      async: () => options.async(...args),
+      sync: (options.sync as any).bind(null, ...args),
+      async: (options.async as any).bind(null, ...args),
       __isQuansync: true,
     }
-  } as unknown as QuansyncFn<Args, Return>
+  } as unknown as QuansyncFn<Return, Args>
 
   generator.sync = options.sync
   generator.async = options.async
 
   return generator
 }
 
+function fromPromise<T>(promise: Promise<T> | T): QuansyncFn<T, []> {
+  return fromObject({
+    async: () => Promise.resolve(promise),
+    sync: () => {
+      if (isThenable(promise))
+        throw new Error(ERROR_PROMISE_IN_SYNC)
+      return promise
+    },
+  })
+}
+
 function unwrapSync(value: any): any {
-  return isQuansyncYield(value)
-    ? value.sync()
-    : value
+  if (isQuansyncYield(value))
+    return value.sync()
+  if (isThenable(value))
+    throw new Error(ERROR_PROMISE_IN_SYNC)
+  return value
 }
 
 function unwrapAsync(value: any): Promise<any> {
-  return isQuansyncYield(value)
-    ? value.async()
-    : value
+  return isQuansyncYield(value) ? value.async() : value
 }
 
-function fromGenerator<Args extends any[], Return>(
-  generator: QuansyncInputGenerator<Args, Return>,
-): QuansyncFn<Args, Return> {
+function fromGenerator<Return, Args extends any[]>(
+  generator: QuansyncInputGenerator<Return, Args>,
+): QuansyncFn<Return, Args> {
   function sync(...args: Args): Return {
     const iterator = generator(...args)
     let current = iterator.next()
@@ -84,7 +102,7 @@ function fromGenerator<Args extends any[], Return>(
     while (!current.done) {
       current = iterator.next(await unwrapAsync(current.value))
     }
-    return await unwrapAsync(current.value)
+    return unwrapAsync(current.value)
   }
 
   return fromObject({
@@ -97,11 +115,20 @@ function fromGenerator<Args extends any[], Return>(
 /**
  * Creates a new Quansync function, a "superposition" between async and sync.
  */
-export function quansync<Args extends any[], Return>(
-  options: QuansyncInput<Args, Return>,
-): QuansyncFn<Args, Return> {
+export function quansync<Return, Args extends any[] = []>(
+  options: QuansyncInput<Return, Args> | Promise<Return>,
+): QuansyncFn<Return, Args> {
+  if (isThenable(options))
+    return fromPromise<Return>(options)
   if (typeof options === 'function')
     return fromGenerator(options)
   else
     return fromObject(options)
 }
+
+/**
+ * Converts a promise to a Quansync generator.
+ */
+export function promiseToGenerator<T>(promise: Promise<T> | T): QuansyncGenerator<T> {
+  return fromPromise(promise as Promise<T>)()
+}

test/index.test.ts

@@ -1,5 +1,5 @@
 import { expect, it } from 'vitest'
-import { isQuansyncYield, quansync } from '../src'
+import { isQuansyncYield, promiseToGenerator, quansync } from '../src'
 
 it('basic', async () => {
   const add = quansync({
@@ -49,9 +49,64 @@ it('generator', async () => {
       const value = yield * add(sum, a)
       sum = value
     }
-    return yield * toString(sum)
+    const foo = yield * toString(sum)
+    return foo
   })
 
   expect(multiply.sync(2, 3)).toBe('6')
   expect(await multiply.async(4, 5)).toBe('20')
 })
+
+it('yield optional promise', async () => {
+  interface Transformer {
+    transform: (code: string) => string | Promise<string>
+  }
+
+  const transform = quansync(function *(transformers: Transformer[], code: string) {
+    let current = code
+    for (const transformer of transformers) {
+      current = yield * promiseToGenerator(transformer.transform(current))
+      // ...
+    }
+    return current
+  })
+
+  expect(transform.sync([], '')).toBe('')
+  await expect(transform.async([], '')).resolves.toBe('')
+
+  expect(
+    transform.sync([
+      {
+        transform: (code: string) => `${code}1`,
+      },
+    ], 'foo'),
+  ).toBe('foo1')
+  expect(() =>
+    transform.sync([
+      {
+        transform: async (code: string) => `${code}1`,
+      },
+    ], 'foo'),
+  ).toThrowErrorMatchingInlineSnapshot(`[Error: [Quansync] Yielded an unexpected promise in sync context]`)
+
+  await expect(
+    transform.async([
+      {
+        transform: async (code: string) => `${code}1`,
+      },
+    ], 'foo'),
+  ).resolves.toBe('foo1')
+})
+
+it('yield promise', async () => {
+  const run = quansync(function *(code: string) {
+    const result = yield new Promise<string>((resolve) => {
+      setTimeout(() => resolve(code), 10)
+    })
+    return result
+  })
+
+  expect(() => run.sync('foo'))
+    .toThrowErrorMatchingInlineSnapshot(`[Error: [Quansync] Yielded an unexpected promise in sync context]`)
+  await expect(run.async('foo')).resolves.toBe('foo')
+})