add support for running the event loop (bellard#14)

* add support for running the event loop allow running of promise/async code

* moved loop to interface file+docs+return value

* fix

* prettier

* prettier test file

* removed RESERVED_FUNCTIONS

Author: avi

c/interface.c

@@ -238,6 +238,28 @@ char* QTS_GetString(JSContext *ctx, JSValueConst *value) {
   return result;
 }
 
+/* 
+  runs pending jobs (Promises/async functions) until it encounters
+  an exception or it executed the passed maxJobsToExecute jobs.
+  
+  Passing a negative value will run the loop until there are no more
+  pending jobs or an exception happened
+
+  Returns the executed number of jobs or the exception encountered
+*/
+JSValue *QTS_ExecutePendingJob(JSRuntime *rt, int maxJobsToExecute) {
+  JSContext *pctx;
+  int status = 1;
+  int executed = 0;
+  for (;executed != maxJobsToExecute && status == 1; executed++) {
+    status = JS_ExecutePendingJob(rt, &pctx);
+  }
+  if (status == -1) {
+    return jsvalue_to_heap(JS_GetException(pctx));
+  } else {
+    return jsvalue_to_heap(JS_NewFloat64(pctx, executed));
+  }
+}
 
 JSValue *QTS_GetProp(JSContext *ctx, JSValueConst *this_val, JSValueConst *prop_name) {
   JSAtom prop_atom = JS_ValueToAtom(ctx, *prop_name);

ts/ffi.ts

@@ -139,6 +139,9 @@ export class QuickJSFFI {
   QTS_GetString: (ctx: JSContextPointer, value: JSValuePointer | JSValueConstPointer) => string =
     this.module.cwrap("QTS_GetString", "string", ["number","number"])
 
+  QTS_ExecutePendingJob: (rt: JSRuntimePointer, maxJobsToExecute: number) => JSValuePointer =
+    this.module.cwrap("QTS_ExecutePendingJob", "number", ["number","number"])
+
   QTS_GetProp: (ctx: JSContextPointer, this_val: JSValuePointer | JSValueConstPointer, prop_name: JSValuePointer | JSValueConstPointer) => JSValuePointer =
     this.module.cwrap("QTS_GetProp", "number", ["number","number","number"])
 

ts/quickjs-emscripten-module.js

@@ -258,6 +258,25 @@ describe('QuickJSVm', async () => {
     })
   })
 
+  describe('.runEventloop', () => {
+    it('promises can run', () => {
+      let i = 0
+      const fnHandle = vm.newFunction('nextId', () => {
+        return vm.newNumber(++i)
+      })
+      vm.setProp(vm.global, 'nextId', fnHandle)
+      fnHandle.dispose()
+
+      const result = vm.unwrapResult(
+        vm.evalCode(`(new Promise(resolve => resolve())).then(nextId).then(nextId).then(nextId);1`)
+      )
+      assert.equal(i, 0)
+      vm.runEventloop()
+      assert.equal(i, 3)
+      assert.equal(vm.getNumber(result), 1)
+    })
+  })
+
   describe('.dump', () => {
     function dumpTestExample(val: unknown) {
       const json = JSON.stringify(val)

ts/quickjs.test.ts

@@ -13,6 +13,7 @@ import {
   LowLevelJavascriptVm,
   VmPropertyDescriptor,
   VmCallResult,
+  VmEventLoopResult,
   VmFunctionImplementation,
 } from './vm-interface'
 import { QuickJSEmscriptenModule } from './emscripten-types'
@@ -484,6 +485,32 @@ export class QuickJSVm implements LowLevelJavascriptVm<QuickJSHandle> {
     return { value: this.heapValueHandle(resultPtr) }
   }
 
+  /**
+   * runEventloop(maxJobsToExecute?: number) Runs pendingJobs on the VM
+   *
+   * Promises and async functions create pendingJobs these do not execute
+   * immediately and need to triggered to run.
+   * You can pass an optional maxJobsToExecute param if you wish to run only
+   * some of the pendingJobs, by default all pendingJobs are executed until
+   * either the queue is exausted or the runtime encounters an exception
+   *
+   * return value for success is the number of executed jobs
+   * for error the exception that stopped the execution
+   */
+  runEventloop(maxJobsToExecute?: number): VmEventLoopResult<QuickJSHandle> {
+    const resultValue = this.heapValueHandle(
+      this.ffi.QTS_ExecutePendingJob(this.rt.value, maxJobsToExecute || -1)
+    )
+    const typeOfRet = this.typeof(resultValue)
+    if (typeOfRet === 'number') {
+      const executedJobs = this.getNumber(resultValue)
+      resultValue.dispose()
+      return { value: executedJobs }
+    } else {
+      return { error: resultValue }
+    }
+  }
+
   // customizations
 
   /**

ts/quickjs.ts

@@ -16,7 +16,7 @@ export type SuccessOrFail<S, F> =
  * `{ value: VmHandle } | { error: VmHandle }`.
  */
 export type VmCallResult<VmHandle> = SuccessOrFail<VmHandle, VmHandle>
-
+export type VmEventLoopResult<VmHandle> = SuccessOrFail<number, VmHandle>
 /**
  * A VmFunctionImplementation takes handles as arguments.
  * It should return a handle, or be void.