fix prettier

Author: justjake

.prettierignore

@@ -1,2 +1,5 @@
 ts/ffi.ts
+ts/ffi-asyncify.ts
+ts/quickjs-emscripten-module-asyncify.js
+ts/quickjs-emscripten-module.js
 dist/*

.prettierrc

@@ -1,6 +1,7 @@
 {
-	"semi": false,
+  "semi": false,
   "singleQuote": true,
   "printWidth": 100,
-	"trailingComma": "es5"
+  "trailingComma": "es5",
+  "arrowParens": "avoid"
 }

package.json

@@ -44,7 +44,7 @@
     "@types/mocha": "^5.2.7",
     "@types/node": "^13.1.4",
     "mocha": "7.2.0",
-    "prettier": "^1.19.1",
+    "prettier": "2.5.1",
     "source-map-support": "^0.5.16",
     "ts-node": "^8.5.4",
     "typedoc": "^0.22.0",

ts/deferred-promise.ts

@@ -1,5 +1,5 @@
-import type { Disposable } from "./lifetime"
-import type { QuickJSHandle, QuickJSVm } from "./quickjs"
+import type { Disposable } from './lifetime'
+import type { QuickJSHandle, QuickJSVm } from './quickjs'
 
 /**
  * QuickJSDeferredPromise wraps a QuickJS promise [[handle]] and allows

ts/quickjs.test.ts

@@ -374,7 +374,7 @@ describe('QuickJSVm', async () => {
     typeofTestExample({ cow: true })
     typeofTestExample([1, 2, 3])
     typeofTestExample(
-      function() {},
+      function () {},
       (val: any) => val.toString()
     )
   })

ts/quickjs.ts

@@ -154,7 +154,7 @@ class QuickJS {
 export function shouldInterruptAfterDeadline(deadline: Date | number): InterruptHandler {
   const deadlineAsNumber = typeof deadline === 'number' ? deadline : deadline.getTime()
 
-  return function() {
+  return function () {
     return Date.now() > deadlineAsNumber
   }
 }

ts/types.ts

@@ -1,4 +1,4 @@
-import type { QuickJSFFI } from "./ffi";
-import type { QuickJSAsyncFFI } from "./ffi-asyncify";
+import type { QuickJSFFI } from './ffi'
+import type { QuickJSAsyncFFI } from './ffi-asyncify'
 
-export type EitherFFI = QuickJSFFI | QuickJSAsyncFFI
+export type EitherFFI = QuickJSFFI | QuickJSAsyncFFI

ts/vm-asyncify.ts

@@ -1,9 +1,20 @@
 import { QuickJSAsyncEmscriptenModule } from './emscripten-types'
 import { QuickJSAsyncFFI } from './ffi-asyncify'
-import { JSContextPointer, JSModuleDefPointer, JSRuntimePointer, JSValuePointer, JSVoidPointer } from './ffi-types'
+import {
+  JSContextPointer,
+  JSModuleDefPointer,
+  JSRuntimePointer,
+  JSValuePointer,
+  JSVoidPointer,
+} from './ffi-types'
 import { Lifetime, WeakLifetime } from './lifetime'
 import { Disposable, Scope } from './quickjs'
-import { ContextCallbacks, CToHostCallbackFunctionImplementation, CToHostModuleLoaderImplementation, QuickJSModuleCallbacks } from './quickjs-module'
+import {
+  ContextCallbacks,
+  CToHostCallbackFunctionImplementation,
+  CToHostModuleLoaderImplementation,
+  QuickJSModuleCallbacks,
+} from './quickjs-module'
 import { PureQuickJSVm, QuickJSHandle, QuickJSPropertyKey, QuickJSVm } from './vm'
 import { SuccessOrFail, VmFunctionImplementation } from './vm-interface'
 
@@ -38,22 +49,22 @@ function assertSync<T>(value: T | Promise<T>): T {
   return value
 }
 
-export type ModuleExport = 
-  | { type: 'function', name: string, implementation: (vm: QuickJSVm) => VmFunctionImplementation<QuickJSHandle> }
-  | { type: 'value', name: string, value: (vm: QuickJSVm) => QuickJSHandle }
+export type ModuleExport =
+  | {
+      type: 'function'
+      name: string
+      implementation: (vm: QuickJSVm) => VmFunctionImplementation<QuickJSHandle>
+    }
+  | { type: 'value'; name: string; value: (vm: QuickJSVm) => QuickJSHandle }
 
 export interface ModuleDefinition {
   name: string
   exports: ModuleExport[]
 }
 
-export type ModuleLoadSuccess = 
-  | string 
-  | /** TODO */ ModuleDefinition
+export type ModuleLoadSuccess = string | /** TODO */ ModuleDefinition
 
-export type ModuleLoadFailure =
-  | Error
-  | QuickJSHandle
+export type ModuleLoadFailure = Error | QuickJSHandle
 
 export type ModuleLoadResult = SuccessOrFail<ModuleLoadSuccess, ModuleLoadFailure>
 
@@ -71,7 +82,10 @@ export interface RuntimeOptions {
   memoryLimit?: TODO<'JS_SetMemoryLimit', number>
   gcThreshold?: TODO<'JS_SetGCThreshold', number>
   maxStackSize?: TODO<'JS_SetMaxStackSize', number>
-  sharedArrayBufferFunctions?: TODO<'JS_SetJSSharedArrayBufferFunctions', { sab_alloc: TODO, sab_free: TODO, sab_dup: TODO, sab_opaque: TODO }>
+  sharedArrayBufferFunctions?: TODO<
+    'JS_SetJSSharedArrayBufferFunctions',
+    { sab_alloc: TODO; sab_free: TODO; sab_dup: TODO; sab_opaque: TODO }
+  >
 }
 
 export type Intrinsic =
@@ -106,7 +120,7 @@ const DefaultIntrinsicsList = [
   'Promise',
 ] as const
 
-export const DefaultIntrinsics = Symbol('DefaultIntrinsics') 
+export const DefaultIntrinsics = Symbol('DefaultIntrinsics')
 
 export interface ContextOptions {
   /**
@@ -119,7 +133,7 @@ export interface ContextOptions {
 
 /**
  * Create a new [QuickJSAsyncRuntime].
- * 
+ *
  * Each runtime is isolated in a separate WebAssembly module, so that errors in
  * one runtime cannot contaminate another runtime.
  */
@@ -128,22 +142,22 @@ export async function newRuntime(options: RuntimeOptions = {}): Promise<QuickJSA
   const module = await newModule()
   const ffi = new QuickJSAsyncFFI(module)
   const callbacks = new QuickJSModuleCallbacks(module, ffi)
-    const rt = new Lifetime(ffi.QTS_NewRuntime(), undefined, rt_ptr => {
-      callbacks.deleteRuntime(rt_ptr)
-      ffi.QTS_FreeRuntime(rt_ptr)
-    })
-    const runtime = new QuickJSAsyncRuntime({
-      module,
-      ffi,
-      rt,
-      callbacks,
-    })
-
-    if (options.moduleLoader) {
-      runtime.setModuleLoader(options.moduleLoader)
-    }
+  const rt = new Lifetime(ffi.QTS_NewRuntime(), undefined, rt_ptr => {
+    callbacks.deleteRuntime(rt_ptr)
+    ffi.QTS_FreeRuntime(rt_ptr)
+  })
+  const runtime = new QuickJSAsyncRuntime({
+    module,
+    ffi,
+    rt,
+    callbacks,
+  })
+
+  if (options.moduleLoader) {
+    runtime.setModuleLoader(options.moduleLoader)
+  }
 
-    return runtime
+  return runtime
 }
 
 /**
@@ -272,12 +286,17 @@ export class QuickJSAsyncContext extends PureQuickJSVm implements ContextCallbac
     this.ffi = ffi
   }
 
-  compileModule(moduleName: string, source: string): Lifetime<JSModuleDefPointer, never, QuickJSAsyncContext> {
+  compileModule(
+    moduleName: string,
+    source: string
+  ): Lifetime<JSModuleDefPointer, never, QuickJSAsyncContext> {
     return Scope.withScope(scope => {
       const sourcePtr = scope.manage(this.memory.newHeapCharPointer(source))
       const moduleDefPtr = this.ffi.QTS_CompileModule(this.ctx.value, moduleName, sourcePtr.value)
       // uh... how do we free this?
-      return new Lifetime(moduleDefPtr, undefined, ptr => this.ffi.QTS_FreeVoidPointer(this.ctx.value, ptr as JSVoidPointer))
+      return new Lifetime(moduleDefPtr, undefined, ptr =>
+        this.ffi.QTS_FreeVoidPointer(this.ctx.value, ptr as JSVoidPointer)
+      )
     })
   }
 
@@ -289,7 +308,9 @@ export class QuickJSAsyncContext extends PureQuickJSVm implements ContextCallbac
   }
 
   throw(error: Error | QuickJSHandle) {
-    return this.errorToHandle(error).consume(handle => this.ffi.QTS_Throw(this.ctx.value, handle.value))
+    return this.errorToHandle(error).consume(handle =>
+      this.ffi.QTS_Throw(this.ctx.value, handle.value)
+    )
   }
 
   /** @private */
@@ -302,12 +323,16 @@ export class QuickJSAsyncContext extends PureQuickJSVm implements ContextCallbac
 
     if (error.name !== undefined) {
       // TODO: assertSync won't work, because in DEBUG, setProp's FFI will always return `Promise`.
-      this.newString(error.name).consume(handle => assertSync(this.setProp(errorHandle, 'name', handle)))
+      this.newString(error.name).consume(handle =>
+        assertSync(this.setProp(errorHandle, 'name', handle))
+      )
     }
 
     if (error.message !== undefined) {
       // TODO: assertSync won't work, because in DEBUG, setProp's FFI will always return `Promise`.
-      this.newString(error.message).consume(handle => assertSync(this.setProp(errorHandle, 'message', handle)))
+      this.newString(error.message).consume(handle =>
+        assertSync(this.setProp(errorHandle, 'message', handle))
+      )
     }
 
     // Disabled due to security leak concerns
@@ -343,7 +368,12 @@ export class QuickJSAsyncContext extends PureQuickJSVm implements ContextCallbac
 
     return Scope.withScope(scope => {
       const thisHandle = scope.manage(
-        new WeakLifetime(this_ptr, this.memory.copyJSValue, this.memory.freeJSValue, this.memory.owner)
+        new WeakLifetime(
+          this_ptr,
+          this.memory.copyJSValue,
+          this.memory.freeJSValue,
+          this.memory.owner
+        )
       )
       const argHandles = new Array<QuickJSHandle>(argc)
       for (let i = 0; i < argc; i++) {

ts/vm.ts

@@ -12,7 +12,10 @@ import {
   HeapCharPointer,
 } from './ffi-types'
 import { Disposable, Lifetime, Scope, StaticLifetime, WeakLifetime } from './lifetime'
-import { CToHostCallbackFunctionImplementation, CToHostInterruptImplementation } from './quickjs-module'
+import {
+  CToHostCallbackFunctionImplementation,
+  CToHostInterruptImplementation,
+} from './quickjs-module'
 import {
   SuccessOrFail,
   LowLevelJavascriptVm,
@@ -65,8 +68,6 @@ export type JSValue = Lifetime<JSValuePointer, JSValuePointer, QuickJSVm>
  */
 export type QuickJSHandle = StaticJSValue | JSValue | JSValueConst
 
-
-
 /**
  * Callback called regularly while the VM executes code.
  * Determines if a VM's execution should be interrupted.
@@ -195,10 +196,10 @@ class QuickJSVmMemory implements Disposable {
   }
 }
 
-/** 
+/**
  * Implements methods that are always synchronous - such methods should never
  * call into a function that suspends when built with ASYNCIFY.
- * 
+ *
  * @private
  */
 export class PureQuickJSVm implements Disposable {
@@ -337,7 +338,7 @@ export class PureQuickJSVm implements Disposable {
     // disposed, no other functions will accept the value.
     this._global = new StaticLifetime(ptr, this.owner)
     return this._global
-  } 
+  }
 
   // New values ---------------------------------------------------------------
 
@@ -352,9 +353,9 @@ export class PureQuickJSVm implements Disposable {
    * Create a QuickJS [string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String) value.
    */
   newString(str: string): QuickJSHandle {
-    const ptr = this.memory.newHeapCharPointer(str).consume(charHandle =>
-      this.ffi.QTS_NewString(this.ctx.value, charHandle.value)
-    )
+    const ptr = this.memory
+      .newHeapCharPointer(str)
+      .consume(charHandle => this.ffi.QTS_NewString(this.ctx.value, charHandle.value))
     return this.memory.heapValueHandle(ptr)
   }
 
@@ -397,9 +398,9 @@ export class PureQuickJSVm implements Disposable {
         mutablePointerArray.value.ptr
       )
       const promiseHandle = this.memory.heapValueHandle(promisePtr)
-      const [resolveHandle, rejectHandle] = Array.from(
-        mutablePointerArray.value.typedArray
-      ).map(jsvaluePtr => this.memory.heapValueHandle(jsvaluePtr as any))
+      const [resolveHandle, rejectHandle] = Array.from(mutablePointerArray.value.typedArray).map(
+        jsvaluePtr => this.memory.heapValueHandle(jsvaluePtr as any)
+      )
       return new QuickJSDeferredPromise({
         owner: this.owner,
         promiseHandle,
@@ -421,7 +422,6 @@ export class PureQuickJSVm implements Disposable {
     return Boolean(this.ffi.QTS_IsJobPending(this.rt.value))
   }
 
-
   private interruptHandler: InterruptHandler | undefined
 
   /**
@@ -548,9 +548,12 @@ export class PureQuickJSVm implements Disposable {
  * Use [[computeMemoryUsage]] or [[dumpMemoryUsage]] to guide memory limit
  * tuning.
  */
-export class QuickJSVm extends PureQuickJSVm implements LowLevelJavascriptVm<QuickJSHandle>, Disposable {
+export class QuickJSVm
+  extends PureQuickJSVm
+  implements LowLevelJavascriptVm<QuickJSHandle>, Disposable
+{
   /** @private */
-   readonly module: QuickJSEmscriptenModule
+  readonly module: QuickJSEmscriptenModule
   /** @private */
   protected readonly ffi: QuickJSFFI
 
@@ -566,7 +569,7 @@ export class QuickJSVm extends PureQuickJSVm implements LowLevelJavascriptVm<Qui
     super(args)
     this.module = args.module
     this.ffi = args.ffi
- }
+  }
 
   // New values ---------------------------------------------------------------
 
@@ -604,7 +607,6 @@ export class QuickJSVm extends PureQuickJSVm implements LowLevelJavascriptVm<Qui
     return funcHandle
   }
 
-
   // Read values --------------------------------------------------------------
 
   /**
@@ -618,7 +620,6 @@ export class QuickJSVm extends PureQuickJSVm implements LowLevelJavascriptVm<Qui
     return this.ffi.QTS_Typeof(this.ctx.value, handle.value)
   }
 
-
   /**
    * Converts `handle` into a Javascript number.
    * @returns `NaN` on error, otherwise a `number`.
@@ -780,9 +781,17 @@ export class QuickJSVm extends PureQuickJSVm implements LowLevelJavascriptVm<Qui
     ...args: QuickJSHandle[]
   ): VmCallResult<QuickJSHandle> {
     this.memory.assertOwned(func)
-    const resultPtr = this.memory.toPointerArray(args).consume(argsArrayPtr =>
-      this.ffi.QTS_Call(this.ctx.value, func.value, thisVal.value, args.length, argsArrayPtr.value)
-    )
+    const resultPtr = this.memory
+      .toPointerArray(args)
+      .consume(argsArrayPtr =>
+        this.ffi.QTS_Call(
+          this.ctx.value,
+          func.value,
+          thisVal.value,
+          args.length,
+          argsArrayPtr.value
+        )
+      )
 
     const errorPtr = this.ffi.QTS_ResolveException(this.ctx.value, resultPtr)
     if (errorPtr) {
@@ -814,9 +823,9 @@ export class QuickJSVm extends PureQuickJSVm implements LowLevelJavascriptVm<Qui
    * `interrupted`.
    */
   evalCode(code: string, filename: string = 'eval.js'): VmCallResult<QuickJSHandle> {
-    const resultPtr = this.memory.newHeapCharPointer(code).consume(charHandle =>
-      this.ffi.QTS_Eval(this.ctx.value, charHandle.value, filename)
-    )
+    const resultPtr = this.memory
+      .newHeapCharPointer(code)
+      .consume(charHandle => this.ffi.QTS_Eval(this.ctx.value, charHandle.value, filename))
     const errorPtr = this.ffi.QTS_ResolveException(this.ctx.value, resultPtr)
     if (errorPtr) {
       this.ffi.QTS_FreeValuePointer(this.ctx.value, resultPtr)