first commit

Author: rosbit

README.md

@@ -0,0 +1,230 @@
+# go-wasm, makes creating WebAssembly with golang easily
+
+`go-wasm` is a package extending the golang package `syscall/js` and making creating WebAssembly with golang easily
+
+### Usage
+
+The package is fully go-getable, so, just type
+
+  `go get github.com/rosbit/go-wasm`
+
+to install.
+
+All the following Wasm result should be built with
+  `GOOS=js GOARCH=wasm go build`
+
+#### 1. Evaluate expressions
+
+```go
+package main
+
+import (
+  "github.com/rosbit/go-wasm"
+  "fmt"
+)
+
+func main() {
+  res, _ := wasm.Eval("1 + 2", nil)
+  fmt.Println("result is:", res)
+}
+```
+
+#### 2. Go calls JS function
+
+Suppose there's a JS file named `a.js` like this:
+
+```js
+function add(a, b) {
+    return a+b
+}
+```
+
+one can call the JS function `add()` in Go code like the following:
+
+```go
+package main
+
+import (
+  "github.com/rosbit/go-wasm"
+  "fmt"
+)
+
+var add func(int, int)int
+
+func main() {
+  if err := wasm.BindFunc("add", &add); err != nil {
+     fmt.Printf("%v\n", err)
+     return
+  }
+
+  res := add(1, 2)
+  fmt.Println("result is:", res)
+}
+```
+
+#### 3. JS calls Go function
+
+JS calling Go function is also easy. In the Go code, make a Golang function
+as JS built-in function by calling `MakeJsFunc("funcname", function)`. There's the example:
+
+```go
+package main
+
+import "github.com/rosbit/go-wasm"
+
+// function to be called by JS
+func adder(a1 float64, a2 float64) float64 {
+    return a1 + a2
+}
+
+func main() {
+  wasm.MakeJsFunc("adder", adder) // now "adder" is a global JS function
+  done := make(chan struct{})
+  <-done
+}
+```
+
+In JS code, one can call the registered function directly. There's the example `b.js`.
+
+```js
+r = adder(1, 100)   # the function "adder" is implemented in Go
+console.log(r)
+```
+
+#### 4. Make Go struct instance as a JS object
+
+This package provides a function `SetModule` which will convert a Go struct instance into
+a JS object. There's the example `c.js`, `m` is the object var provided by Go code:
+
+```js
+m.incAge(10)
+print(m)
+
+console.log('m.name', m.name)
+console.log('m.age', m.age)
+```
+
+The Go code is like this:
+
+```go
+package main
+
+import "github.com/rosbit/go-wasm"
+
+type M struct {
+   Name string
+   Age int
+}
+func (m *M) IncAge(a int) {
+   m.Age += a
+}
+
+func main() {
+  wasm.BindObject("m", &M{Name:"rosbit", Age: 1}) // "m" is the object var name
+
+  done := make(chan struct{})
+  <-done
+}
+```
+
+#### 5. Set many built-in functions and objects at one time
+
+If there're a lot of functions and objects to be registered, a map could be constructed with function `SetGlobals` or put as an
+argument for function `Eval`.
+
+```go
+package main
+
+import "github.com/rosbit/go-wasm"
+import "fmt"
+
+type M struct {
+   Name string
+   Age int
+}
+func (m *M) IncAge(a int) {
+   m.Age += a
+}
+
+func adder(a1 float64, a2 float64) float64 {
+    return a1 + a2
+}
+
+func main() {
+  vars := map[string]interface{}{
+     "m": &M{Name:"rosbit", Age:1}, // to JS object
+     "adder": adder,                // to JS built-in function
+     "a": []int{1,2,3},             // to JS array
+  }
+
+  wasm.SetGlobals(vars)
+  res := wasm.GetGlobal("a") // get the value of var named "a". Any variables in script could be get by GetGlobal
+  fmt.Printf("res:", res)
+}
+```
+
+#### 6. Wrap anything as JS global object
+
+This package also provides a function `SetGlobalObject` which will create a JS variable integrating any
+Go values/functions as an object. There's the example `d.js` which will use object `tm` provided by Go code:
+
+```js
+a = tm.newA("rosbit", 10)
+a.incAge(10)
+console.log(a)
+
+tm.printf('a.name: %s\n', a.name)
+tm.printf('a.age: %d\n', a.age)
+```
+
+The Go code is like this:
+
+```go
+package main
+
+import (
+  "github.com/rosbit/go-wasm"
+  "fmt"
+)
+
+type A struct {
+   Name string
+   Age int
+}
+func (m *A) IncAge(a int) {
+   m.Age += a
+}
+func newA(name string, age int) *A {
+   return &A{Name: name, Age: age}
+}
+
+func main() {
+  wasm.SetGlobalObject("tm", map[string]interface{}{ // object name is "tm"
+     "newA": newA,            // make user defined function as object method named "tm.newA"
+     "printf": fmt.Printf,    // make function in a standard package named "tm.printf"
+  })
+
+  done := make(chan struct{})
+  <-done
+}
+```
+
+### Other helper functions
+
+```go
+func JSONStringify(v interface{}) string    // wasm.JSONStringify([]int{1, 3})
+func JSONParse(val string) interface{}      // wasm.JSONParse(`{"a":"b","c":1}`)
+func CallObjectMethod(objName, objMethod string, args ...interface{}) js.Value
+ // jsObj := wasm.CallObjectMethod("document", "getElementById", "id")
+func CallFunc(funcName string, args ...interface{}) js.Value // wasm.CallFunc("add", 1, 1)
+```
+
+### Status
+
+The package is not fully tested, so be careful.
+
+### Contribution
+
+Pull requests are welcome! Also, if you want to discuss something send a pull request with proposal and changes.
+
+__Convention:__ fork the repository and make changes on your fork in a feature branch.

go-func.go

@@ -0,0 +1,32 @@
+package wasm
+
+import (
+	elutils "github.com/rosbit/go-embedding-utils"
+	"syscall/js"
+)
+
+func bindGoFunc(funcVar interface{}) (goFunc js.Func, err error) {
+	helper, e := elutils.NewGolangFuncHelper("noname", funcVar)
+	if e != nil {
+		err = e
+		return
+	}
+	goFunc = js.FuncOf(wrapGoFunc(helper))
+	return
+}
+
+func wrapGoFunc(helper *elutils.GolangFuncHelper) func(this js.Value, args []js.Value)interface{} {
+	return func(this js.Value, args []js.Value) (val interface{}) {
+		getArgs := func(i int) interface{} {
+			return fromValue(args[i])
+		}
+
+		v, e := helper.CallGolangFunc(len(args), "gofunc", getArgs)
+		if e != nil || v == nil {
+			return
+		}
+
+		val = v
+		return
+	}
+}

go-interface.go

@@ -0,0 +1,13 @@
+package wasm
+
+import (
+	"reflect"
+)
+
+func bindGoInterface(interfaceVar reflect.Value) (goInterface map[string]interface{}) {
+	t := interfaceVar.Type()
+	r := make(map[string]interface{})
+	bindGoMethod(interfaceVar, t, r)
+	return r
+}
+

go-struct.go

@@ -0,0 +1,63 @@
+package wasm
+
+import (
+	elutils "github.com/rosbit/go-embedding-utils"
+	"syscall/js"
+	"reflect"
+	"strings"
+	// "fmt"
+)
+
+func bindGoStruct(structVar reflect.Value) (goStruct map[string]interface{}) {
+	var structE reflect.Value
+	if structVar.Kind() == reflect.Ptr {
+		structE = structVar.Elem()
+	} else {
+		structE = structVar
+	}
+	structT := structE.Type()
+
+	if structE == structVar {
+		// struct is unaddressable, so make a copy of struct to an Elem of struct-pointer.
+		// NOTE: changes of the copied struct cannot effect the original one. it is recommended to use the pointer of struct.
+		structVar = reflect.New(structT) // make a struct pointer
+		structVar.Elem().Set(structE)    // copy the old struct
+		structE = structVar.Elem()       // structE is the copied struct
+	}
+
+	goStruct = wrapGoStruct(structVar, structE, structT)
+	return
+}
+
+func lowerFirst(name string) string {
+	return strings.ToLower(name[:1]) + name[1:]
+}
+
+func wrapGoStruct(structVar, structE reflect.Value, structT reflect.Type) map[string]interface{} {
+	r := make(map[string]interface{})
+	for i:=0; i<structT.NumField(); i++ {
+		strField := structT.Field(i)
+		name := strField.Name
+		name = lowerFirst(name)
+		fv := structE.Field(i)
+		r[name] = toValue(fv.Interface())
+	}
+
+	// receiver is the struct
+	bindGoMethod(structE, structT, r)
+
+	// reciver is the pointer of struct
+	t := structVar.Type()
+	bindGoMethod(structVar, t, r)
+	return r
+}
+
+func bindGoMethod(structV reflect.Value, structT reflect.Type, r map[string]interface{}) {
+	for i := 0; i<structV.NumMethod(); i+=1 {
+		m := structT.Method(i)
+		name := lowerFirst(m.Name)
+		mV := structV.Method(i)
+		mT := mV.Type()
+		r[name] = js.FuncOf(wrapGoFunc(elutils.NewGolangFuncHelperDiretly(mV, mT)))
+	}
+}

go.mod

@@ -0,0 +1,5 @@
+module github.com/rosbit/go-wasm
+
+go 1.17
+
+require github.com/rosbit/go-embedding-utils v0.1.0 // indirect

go.sum

@@ -0,0 +1,2 @@
+github.com/rosbit/go-embedding-utils v0.1.0 h1:UAgyEBTRpxphPRNOGVa2VBxXned5GxohW6XPdTxWlXQ=
+github.com/rosbit/go-embedding-utils v0.1.0/go.mod h1:vN49YyUkB9OQI4t/6ofn0+kHYOrn/mAP1cqkzITBoEw=

js-func.go

@@ -0,0 +1,36 @@
+package wasm
+
+import (
+	elutils "github.com/rosbit/go-embedding-utils"
+	"syscall/js"
+	"reflect"
+)
+
+func bindFunc(fn *js.Value, funcVarPtr interface{}) (err error) {
+	helper, e := elutils.NewEmbeddingFuncHelper(funcVarPtr)
+	if e != nil {
+		err = e
+		return
+	}
+	helper.BindEmbeddingFunc(wrapFunc(fn, helper))
+	return
+}
+
+func wrapFunc(fn *js.Value, helper *elutils.EmbeddingFuncHelper) elutils.FnGoFunc {
+	return func(args []reflect.Value) (results []reflect.Value) {
+		var jsArgs []interface{}
+
+		// make js args
+		itArgs := helper.MakeGoFuncArgs(args)
+		for arg := range itArgs {
+			jsArgs = append(jsArgs, arg)
+		}
+
+		// call js function
+		res := fn.Invoke(jsArgs...)
+
+		// convert result to golang
+		results = helper.ToGolangResults(fromValue(res), res.Type() == js.TypeObject && res.InstanceOf(array), nil)
+		return
+	}
+}