feat: Add reflection to create JS value from Go value

reflect
Chan Wen Xu 2021-03-20 23:45:44 +07:00
parent 5fa7e5c21d
commit 38d86b9e81
Signed by untrusted user: chanbakjsd
GPG Key ID: 7E9A74B1B07A7558
4 changed files with 268 additions and 0 deletions

@ -0,0 +1,87 @@
package wasm
import (
"errors"
"reflect"
"syscall/js"
)
// ErrInvalidArgumentType is returned when a generated Go function wrapper receives invalid argument types from JS.
var ErrInvalidArgumentType = errors.New("invalid argument passed into Go function")
var errorType = reflect.TypeOf(error(nil))
func toJSFunc(x reflect.Value) js.Value {
funcType := x.Type()
var hasError bool
if funcType.NumOut() != 0 {
hasError = funcType.Out(funcType.NumOut()-1) == errorType
}
return js.FuncOf(func(this js.Value, args []js.Value) interface{} {
in, err := conformJSValueToType(funcType, this, args)
if err != nil {
throwWrapper.Invoke(NewError(err))
return nil
}
out := x.Call(in)
if !hasError {
return ToJSValue(returnValue(out))
}
lastParam := out[len(out)-1]
if !lastParam.IsNil() {
throwWrapper.Invoke(NewError(err))
return nil
}
return ToJSValue(returnValue(out[:len(out)-1]))
}).JSValue()
}
var jsValueType = reflect.TypeOf(js.Value{})
func conformJSValueToType(funcType reflect.Type, this js.Value, values []js.Value) ([]reflect.Value, error) {
if funcType.NumIn() == 0 {
if len(values) != 0 {
return nil, ErrInvalidArgumentType
}
return []reflect.Value{}, nil
}
if funcType.In(0) == jsValueType {
values = append([]js.Value{this}, values...)
}
if !funcType.IsVariadic() && funcType.NumIn() != len(values) {
return nil, ErrInvalidArgumentType
}
in := make([]reflect.Value, 0, len(values))
for i, v := range values {
paramType := funcType.In(i)
x := reflect.Zero(paramType).Interface()
err := FromJSValue(v, &x)
if err != nil {
return nil, err
}
in = append(in, reflect.ValueOf(x))
}
return in, nil
}
func returnValue(x []reflect.Value) js.Value {
if len(x) == 1 {
return ToJSValue(x[0])
}
xInterface := make([]interface{}, 0, len(x))
for _, v := range x {
xInterface = append(xInterface, v.Interface())
}
return ToJSValue(x)
}

@ -0,0 +1,11 @@
package wasm
import (
"fmt"
"syscall/js"
)
func FromJSValue(x js.Value, out interface{}) error {
// TODO
return fmt.Errorf("unimplemented")
}

@ -0,0 +1,155 @@
package wasm
import (
"fmt"
"reflect"
"syscall/js"
"unsafe"
)
// ToJSValue converts a given Go value into its equivalent JS form.
//
// One special case is that complex numbers (complex64 and complex128) are converted into objects with a real and imag
// property holding a number each.
//
// A function is converted into a JS function where the function returns an error if the provided arguments do not conform
// to the Go equivalent but otherwise calls the Go function.
//
// The "this" argument of a function is always passed to the Go function if its first parameter is of type js.Value.
// Otherwise, it is simply ignored.
//
// If the last return value of a function is an error, it will be thrown in JS if it's non-nil.
// If the function returns multiple non-error values, it is converted to an array when returning to JS.
//
// It panics when a channel or a map with keys other than string and integers are passed in.
func ToJSValue(x interface{}) js.Value {
if x == nil {
return js.Undefined()
}
// Fast path for basic types that do not require reflection.
switch x := x.(type) {
case js.Value:
return x
case js.Wrapper, bool, int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, uintptr,
unsafe.Pointer, float32, float64, string:
return js.ValueOf(x)
case complex64:
return js.ValueOf(map[string]interface{}{
"real": real(x),
"imag": imag(x),
})
case complex128:
return js.ValueOf(map[string]interface{}{
"real": real(x),
"imag": imag(x),
})
}
value := reflect.ValueOf(x)
if value.Kind() == reflect.Ptr {
value = reflect.Indirect(value)
if !value.IsValid() {
return js.Undefined()
}
}
switch value.Kind() {
case reflect.Array, reflect.Slice:
return toJSArray(value)
case reflect.Func:
return toJSFunc(value)
case reflect.Map:
return mapToJSObject(value)
case reflect.Struct:
return structToJSObject(value)
default:
panic(fmt.Sprintf("cannot convert %T to a JS value", x))
}
}
func toJSArray(x reflect.Value) js.Value {
arrayConstructor, err := Global().Get("Array")
if err != nil {
panic("Array constructor not found")
}
array := arrayConstructor.New()
for i := 0; i < x.Len(); i++ {
array.SetIndex(i, ToJSValue(x.Index(i).Interface()))
}
return array
}
func mapToJSObject(x reflect.Value) js.Value {
objectConstructor, err := Global().Get("Object")
if err != nil {
panic("Object constructor not found")
}
obj := objectConstructor.New()
iter := x.MapRange()
for {
key := iter.Key()
value := iter.Value().Interface()
switch key := key.Interface().(type) {
case int:
obj.SetIndex(key, ToJSValue(value))
case int8:
obj.SetIndex(int(key), ToJSValue(value))
case int16:
obj.SetIndex(int(key), ToJSValue(value))
case int32:
obj.SetIndex(int(key), ToJSValue(value))
case int64:
obj.SetIndex(int(key), ToJSValue(value))
case uint:
obj.SetIndex(int(key), ToJSValue(value))
case uint8:
obj.SetIndex(int(key), ToJSValue(value))
case uint16:
obj.SetIndex(int(key), ToJSValue(value))
case uint32:
obj.SetIndex(int(key), ToJSValue(value))
case uint64:
obj.SetIndex(int(key), ToJSValue(value))
case uintptr:
obj.SetIndex(int(key), ToJSValue(value))
case string:
obj.Set(key, ToJSValue(value))
default:
panic(fmt.Sprintf("cannot convert %T into a JS value as its key is not a string or an integer",
x.Interface()))
}
if !iter.Next() {
break
}
}
return obj
}
func structToJSObject(x reflect.Value) js.Value {
objectConstructor, err := Global().Get("Object")
if err != nil {
panic("Object constructor not found")
}
obj := objectConstructor.New()
structType := x.Type()
for i := 0; i < structType.NumField(); i++ {
field := structType.Field(i)
name := field.Name
if tagName, ok := field.Tag.Lookup("wasm"); ok {
name = tagName
}
obj.Set(name, ToJSValue(x.Field(i)))
}
return obj
}

@ -0,0 +1,15 @@
package wasm
import "syscall/js"
const globalIdent = "__go_wasm__"
var throwWrapper js.Value
func init() {
var err error
throwWrapper, err = Global().Get(globalIdent, "__throw__")
if err != nil {
panic("JS wrapper __go_wasm__.__throw__ not found")
}
}