feat(wasm): export an autocomplete function (#3148)

Author: Codelax

.github/workflows/wasm.yml

@@ -28,3 +28,7 @@ jobs:
         run: ./scripts/build-wasm.sh
       - name: Run npm package tests
         run: ./scripts/run-tests-wasm.sh
+      - name: Run custom tester
+        run: ./scripts/run-tests-wasm.sh
+        env:
+          TESTER: true

cmd/scw-wasm-tester/args.go

@@ -0,0 +1,24 @@
+//go:build wasm && js
+
+package main
+
+import (
+	"os"
+)
+
+type Args struct {
+	callback     string
+	targetObject string
+}
+
+func getArgs() Args {
+	args := Args{}
+	if len(os.Args) > 0 {
+		args.callback = os.Args[0]
+	}
+	if len(os.Args) > 1 {
+		args.targetObject = os.Args[1]
+	}
+
+	return args
+}

cmd/scw-wasm-tester/main.go

@@ -0,0 +1,42 @@
+//go:build wasm && js
+
+package main
+
+import (
+	"syscall/js"
+
+	"github.com/scaleway/scaleway-cli/v2/internal/jshelpers"
+)
+
+type jsFunction func(js.Value, []js.Value) any
+
+var tests = map[string]jsFunction{
+	"FromSlice": wasmTestFromSlice,
+}
+
+func main() {
+	stopChan := make(chan struct{})
+	stop := func(_ js.Value, args []js.Value) (any, error) {
+		stopChan <- struct{}{}
+		return nil, nil
+	}
+
+	args := getArgs()
+
+	if args.targetObject != "" {
+		cliPackage := js.ValueOf(map[string]any{})
+		for funcName, testFunc := range tests {
+			cliPackage.Set(funcName, js.FuncOf(testFunc))
+		}
+		cliPackage.Set("stop", js.FuncOf(jshelpers.AsyncJsFunc(stop)))
+		js.Global().Set(args.targetObject, cliPackage)
+	}
+
+	if args.callback != "" {
+		givenCallback := js.Global().Get(args.callback)
+		if !givenCallback.IsUndefined() {
+			givenCallback.Invoke()
+		}
+	}
+	<-stopChan
+}

cmd/scw-wasm-tester/slices.go

@@ -0,0 +1,13 @@
+//go:build wasm && js
+
+package main
+
+import (
+	"syscall/js"
+
+	"github.com/scaleway/scaleway-cli/v2/internal/jshelpers"
+)
+
+func wasmTestFromSlice(_ js.Value, _ []js.Value) any {
+	return jshelpers.FromSlice([]string{"1", "2", "3"})
+}

cmd/scw-wasm/main.go

@@ -10,11 +10,19 @@ import (
 )
 
 func main() {
+	stopChan := make(chan struct{})
+	stop := func(_ js.Value, args []js.Value) (any, error) {
+		stopChan <- struct{}{}
+		return nil, nil
+	}
+
 	args := getArgs()
 
 	if args.targetObject != "" {
 		cliPackage := js.ValueOf(map[string]any{})
-		cliPackage.Set("run", asyncFunc(jshelpers.AsFunction(wasm.Run)))
+		cliPackage.Set("run", js.FuncOf(jshelpers.AsPromise(wasm.Run)))
+		cliPackage.Set("complete", js.FuncOf(jshelpers.AsPromise(wasm.Autocomplete)))
+		cliPackage.Set("stop", js.FuncOf(jshelpers.AsyncJsFunc(stop)))
 		js.Global().Set(args.targetObject, cliPackage)
 	}
 
@@ -24,5 +32,5 @@ func main() {
 			givenCallback.Invoke()
 		}
 	}
-	<-make(chan struct{})
+	<-stopChan
 }

internal/core/wasm.go

@@ -13,6 +13,10 @@ var (
 )
 
 func asSlice(typ reflect.Type, value js.Value) (any, error) {
+	if !value.InstanceOf(jsArray) {
+		return nil, fmt.Errorf("value type should be Array")
+	}
+
 	l := value.Length()
 
 	slice := reflect.MakeSlice(reflect.SliceOf(typ), l, l)
@@ -32,14 +36,22 @@ func asSlice(typ reflect.Type, value js.Value) (any, error) {
 func AsSlice[T any](value js.Value) ([]T, error) {
 	var t T
 
-	if !value.InstanceOf(jsArray) {
-		return nil, fmt.Errorf("value type should be Array")
-	}
-
 	slice, err := asSlice(reflect.TypeOf(t), value)
 	if err != nil {
 		return nil, err
 	}
 
 	return slice.([]T), nil
 }
+
+// FromSlice converts a Go slice to a JS Array
+func FromSlice(from any) js.Value {
+	fromValue := reflect.ValueOf(from)
+
+	arrayItems := make([]any, fromValue.Len())
+	for i := 0; i < len(arrayItems); i++ {
+		arrayItems[i] = jsValue(fromValue.Index(i).Interface())
+	}
+
+	return jsArray.New(arrayItems...)
+}

internal/jshelpers/arrays.go

@@ -1,39 +1,30 @@
-//go:build wasm && js
+//go:build js
 
-package main
+package jshelpers
 
 import (
 	"fmt"
 	"runtime/debug"
 	"syscall/js"
-
-	"github.com/scaleway/scaleway-cli/v2/internal/jshelpers"
-)
-
-type fn func(this js.Value, args []js.Value) (any, error)
-
-var (
-	jsErr     = js.Global().Get("Error")
-	jsPromise = js.Global().Get("Promise")
 )
 
-func asyncFunc(innerFunc fn) js.Func {
-	return js.FuncOf(func(this js.Value, args []js.Value) any {
+func AsyncJsFunc(innerFunc JsFuncWithError) JsFunc {
+	return func(this js.Value, args []js.Value) any {
 		handler := js.FuncOf(func(_ js.Value, promFn []js.Value) any {
 			resolve, reject := promFn[0], promFn[1]
 
 			go func() {
 				defer func() {
 					if r := recover(); r != nil {
-						reject.Invoke(jshelpers.NewError(
+						reject.Invoke(NewError(
 							fmt.Sprintf("panic: %v\n%s", r, string(debug.Stack())),
 						))
 					}
 				}()
 
 				res, err := innerFunc(this, args)
 				if err != nil {
-					reject.Invoke(jshelpers.NewError(err.Error()))
+					reject.Invoke(NewError(err.Error()))
 				} else {
 					resolve.Invoke(res)
 				}
@@ -43,5 +34,5 @@ func asyncFunc(innerFunc fn) js.Func {
 		})
 
 		return jsPromise.New(handler)
-	})
+	}
 }

cmd/scw-wasm/async.go internal/jshelpers/async.gocmd/scw-wasm/async.go renamed to internal/jshelpers/async.go

@@ -4,11 +4,6 @@ package jshelpers
 
 import "syscall/js"
 
-var (
-	jsObject = js.Global().Get("Object")
-	jsErr    = js.Global().Get("Error")
-)
-
 func NewError(msg any) js.Value {
 	return jsErr.New(msg)
 }

internal/jshelpers/errors.go

@@ -21,7 +21,10 @@ func jsValue(val any) js.Value {
 	switch valType.Kind() {
 	case reflect.Struct:
 		return FromObject(val)
+	case reflect.Slice:
+		return FromSlice(val)
 	}
+
 	return js.ValueOf(val)
 }
 
@@ -32,10 +35,10 @@ func errValue(val any) error {
 	return val.(error)
 }
 
-// AsFunction convert a classic Go function to a function taking js arguments.
+// AsPromise convert a classic Go function to a function taking js arguments.
 // arguments and return types must be types handled by this package
 // function must return 2 variables, second one must be an error
-func AsFunction(goFunc any) func(this js.Value, args []js.Value) (any, error) {
+func AsPromise(goFunc any) JsFunc {
 	goFuncValue := reflect.ValueOf(goFunc)
 	goFuncType := goFuncValue.Type()
 
@@ -51,7 +54,7 @@ func AsFunction(goFunc any) func(this js.Value, args []js.Value) (any, error) {
 		panic("function must return an error")
 	}
 
-	return func(this js.Value, args []js.Value) (any, error) {
+	return AsyncJsFunc(func(this js.Value, args []js.Value) (any, error) {
 		if len(args) != len(goFuncArgs) {
 			return nil, fmt.Errorf("invalid number of arguments, expected %d, got %d", len(goFuncArgs), len(args))
 		}
@@ -60,13 +63,13 @@ func AsFunction(goFunc any) func(this js.Value, args []js.Value) (any, error) {
 		for i, argType := range goFuncArgs {
 			arg, err := goValue(argType, args[i])
 			if err != nil {
-				return nil, fmt.Errorf("invalid argument at index %d with type %s: %w", i, argType.String(), err)
+				return nil, fmt.Errorf("invalid argument at index %d, expected type %s: %w", i, argType.String(), err)
 			}
 			argValues[i] = reflect.ValueOf(arg)
 		}
 
 		returnValues := goFuncValue.Call(argValues)
 
 		return jsValue(returnValues[0].Interface()), errValue(returnValues[1].Interface())
-	}
+	})
 }