forked from Team-Ortix/golang-wasm
80 lines
2.8 KiB
Go
80 lines
2.8 KiB
Go
package main
|
|
|
|
import "syscall/js"
|
|
|
|
var (
|
|
// bridgeName is the namesace for all functions and values set.
|
|
//
|
|
// The returning JavaScript proxy via the webpack loader will look for functions and values under this namespace.
|
|
bridgeName = "__go_wasm__"
|
|
|
|
// The JS object of the __go_wasm__ value.
|
|
bridge js.Value
|
|
|
|
// Wrapper is a simple JS function that when called with a Go Function, will return a new function that will throw
|
|
// if the property `error` is an instance of JavaScript's `error`.
|
|
//
|
|
// All Go functions in the bridgeName proxy are expected to be the result of calling wrapper with the Go function.
|
|
wrapper js.Value
|
|
)
|
|
|
|
// newReturnValue creates an object with the value as the result.
|
|
// See wrapGoFunc for the reasoning behind style style of returning values from Go functions.
|
|
func newReturnValue(value interface{}) js.Value {
|
|
jsObject := js.Global().Get("Object").New()
|
|
jsObject.Set("result", value)
|
|
|
|
return jsObject
|
|
}
|
|
|
|
// newReturnError creates an object with the goError's message and creates a Javascript Error object with the message.
|
|
//
|
|
// See wrapGoFunc for the reasoning behind style style of returning values from Go functions.
|
|
func newReturnError(goErr error) js.Value {
|
|
jsObject := js.Global().Get("Object").New()
|
|
jsError := js.Global().Get("Error")
|
|
jsObject.Set("error", jsError.New(goErr.Error()))
|
|
|
|
return jsObject
|
|
}
|
|
|
|
// Using this wrapper makes it possible to throw errors in go-fashion.
|
|
// This means that all wrapped functions must return value and an error (respectively).
|
|
//
|
|
// The __wrapper__ function from JS will automatically throw if the returned object has an 'error' property.
|
|
// Inversely, it will automatically give the result value if that property exists.
|
|
// All Go functions directly returned via wasm should keep this in mind.
|
|
func wrapGoFunc(f func(js.Value, []js.Value) (interface{}, error)) js.Func {
|
|
return js.FuncOf(func(this js.Value, args []js.Value) interface{} {
|
|
res, err := f(this, args)
|
|
if err != nil {
|
|
return newReturnError(err)
|
|
}
|
|
|
|
return newReturnValue(res)
|
|
})
|
|
}
|
|
|
|
func setFunc(name string, f func(js.Value, []js.Value) (interface{}, error)) {
|
|
bridge.Set(name, wrapper.Invoke(wrapGoFunc(f)))
|
|
}
|
|
|
|
func setValue(name string, value interface{}) {
|
|
bridge.Set(name, value)
|
|
}
|
|
|
|
// Toggling the __ready__ value in the bridge lets JS know that everything is setup.
|
|
// Setting __ready__ to true can help prevent possible race conditions of Wasm being called before everything is
|
|
// registered, and potentially crashing applications.
|
|
func ready() {
|
|
bridge.Set("__ready__", true)
|
|
<-make(chan bool, 0) // To use anything from Go WASM, the program may not exit.
|
|
}
|
|
|
|
// We want to make sure that this is always ran first. This means that we can make sure that whenever functions are
|
|
// initialized, they are able to be set to the bridge and wrapper.
|
|
func init() {
|
|
bridge = js.Global().Get(bridgeName)
|
|
wrapper = bridge.Get("__wrapper__")
|
|
}
|