Add binding gen js for remote and local

javascript.go

@@ -11,13 +11,17 @@ import (
 
 type SimpleParameter struct {
 	Name string
-	Type string
+	JsType string
+    Description string
+    FclType string
+    CadType string
 }
 
 type TemplateData struct {
     Version     string
     Parameters []SimpleParameter
     Title       string
+    Description string
     Location    string
     IsScript    bool
     IsLocalTemplate bool
@@ -34,10 +38,12 @@ func GenerateJavaScript(flix *FlowInteractionTemplate, templateLocation string,
     }
 
     methodName := TitleToMethodName(flix.Data.Messages.Title.I18N["en-US"])
+    description := flix.Data.Messages.Description.I18N["en-US"]
     data := TemplateData{
         Version: flix.FVersion,
         Parameters: TransformArguments(flix.Data.Arguments),
         Title: methodName,
+        Description: description,
         Location: templateLocation,
         IsScript: flix.IsScript(),
         IsLocalTemplate: isLocal,
@@ -73,22 +79,77 @@ func TitleToMethodName(s string) string {
 func TransformArguments(args Arguments) []SimpleParameter {
 	simpleArgs := []SimpleParameter{}
 	for name, arg := range args {
-        isArray, arrayType := IsArrayParameter(arg)
+        isArray, cType, jsType := IsArrayParameter(arg)
+        desciption := arg.Messages.Title.I18N["en-US"]
         if isArray {
-            simpleArgs = append(simpleArgs, SimpleParameter{Name: name, Type: "Array(t." + arrayType + ")"})
+            simpleArgs = append(simpleArgs, SimpleParameter{Name: name, CadType: cType, JsType: jsType, FclType: "Array(t." + cType + ")", Description: desciption})
         } else {
-            simpleArgs = append(simpleArgs, SimpleParameter{Name: name, Type: arg.Type})
+            jsType := ConvertCadenceTypeToJS(arg.Type)
+            simpleArgs = append(simpleArgs, SimpleParameter{Name: name, CadType: arg.Type, JsType: jsType, FclType: arg.Type, Description: desciption})
         }
 	}
 	return simpleArgs
 }
 
 
-func IsArrayParameter(arg Argument) (bool, string) {
+func IsArrayParameter(arg Argument) (bool, string, string) {
     isArray := arg.Type[0] == '[' && arg.Type[len(arg.Type)-1] == ']'
     if (!isArray) {
-        return isArray, ""
+        return isArray, "", ""
     }
-    return isArray, arg.Type[1 : len(arg.Type)-1]
+    cadenceType := arg.Type[1 : len(arg.Type)-1]
+    jsType := "Array<" + ConvertCadenceTypeToJS(cadenceType) + ">"
+    return isArray, cadenceType, jsType
 }
 
+// ConvertCadenceTypeToJS takes a Cadence type as a string and returns its JavaScript equivalent
+func ConvertCadenceTypeToJS(cadenceType string) string {
+    switch cadenceType {
+    case "Int":
+        return "Number"
+    case "Int8":
+        return "Number"
+    case "Int16":
+        return "Number"
+    case "Int32":
+        return "Number"
+    case "Int64":
+        return "BigInt"
+    case "Int128":
+        return "BigInt"
+    case "Int256":
+        return "BigInt"
+    case "UInt":
+        return "string"
+    case "UInt8":
+        return "string"
+    case "UInt16":
+        return "string"
+    case "UInt32":
+        return "string"
+    case "UInt64":
+        return "string"
+    case "UInt128":
+        return "string"
+    case "UInt256":
+        return "string"
+    case "UFix64":
+        return "string"
+    case "Fix64":
+        return "BigInt"
+    case "String":
+        return "string"
+    case "Character":
+        return "string"
+    case "Bool":
+        return "boolean"
+    case "Address":
+        return "string"
+    case "Void":
+        return "void"
+    default:
+        // For composite and resource types, you can customize further.
+        // For now, let's just return 'any' for unknown or complex types
+        return "any"
+    }
+}

javascript_test.go

@@ -88,12 +88,12 @@ var parsedTemplateScript = &FlowInteractionTemplate{
 		Messages: Messages{
 			Title: &Title{
 				I18N: map[string]string{
-					"en-US": "Transfer Tokens",
+					"en-US": "Multiple Two Integers",
 				},
 			},
 			Description: &Description{
 				I18N: map[string]string{
-					"en-US": "Transfer tokens from one account to another",
+					"en-US": "Multiply two numbers to another",
 				},
 			},
 		},
@@ -171,16 +171,20 @@ func TestJSGenTransaction(t *testing.T) {
 	assert.NoError(err, "ParseTemplate should not return an error")
 	assert.NotNil(contents, "Parsed template should not be nil")
 	assert.True(strings.Contains(contents, "await fcl.mutate("), "Expected '%s'", "await fcl.mutate(")
+
+
 }
 
 
 func TestJSGenScript(t *testing.T) {
 	assert := assert.New(t)
 
-	contents, err := GenerateJavaScript(parsedTemplateScript, "./transfer_token.json", true)
+	contents, err := GenerateJavaScript(parsedTemplateScript, "./multiply_two_integers.json", true)
 	assert.NoError(err, "ParseTemplate should not return an error")
 	assert.NotNil(contents, "Parsed template should not be nil")
 	assert.True(strings.Contains(contents, "await fcl.query("), "Expected '%s'", "await fcl.query(")
+
+
 }
 
 func TestJSGenArrayScript(t *testing.T) {
@@ -191,4 +195,5 @@ func TestJSGenArrayScript(t *testing.T) {
 	assert.NotNil(contents, "Parsed template should not be nil")
 	assert.True(strings.Contains(contents, "await fcl.query("), "Expected '%s'", "await fcl.query(")
 	assert.True(strings.Contains(contents, `args: (arg, t) => [arg(numbers, t.Array(t.Int))]`), "Expected '%s'", `args: (arg, t) => [arg(numbers, t.Array(t.Int))]`)
+
 }

templates/js_main.tmpl

@@ -10,17 +10,30 @@ import flixTemplate from "{{.Location}}"
 const flixTemplate = "{{.Location}}"
 {{- end}}
 
+// TODO: add runtime check for parameters consistency
 const parameterNames = [
   {{- range $index, $ele := .Parameters -}}
      {{if $index}}, {{end}}"{{$ele.Name}}"
   {{- end -}}
 ];
+ {{"\n"}}/**
+* {{.Description}}{{"\n"}}
+   {{- if gt (len .Parameters) 0 -}}
+* @param {Object} Parameters - parameters for the cadence
+    {{- range $index, $ele := .Parameters -}}
+{{"\n"}}* @param {{"{"}} {{$ele.JsType}} {{"}"}} Parameters.{{$ele.Name}} - {{$ele.Description}}: {{$ele.CadType}}
+    {{- end -}}
+ {{ end -}}
+ {{- if not .IsScript -}}
+{{"\n"}}* @returns {Promise<string>} - returns a promise which resolves to the transaction id
+ {{- end -}}
+{{"\n"}}*/
 
 {{if .IsScript}}
 {{- template "js_script.tmpl" .}}
 {{else}}
 {{- template "js_tx.tmpl" .}}
-{{end}}
+{{- end}}
 
 
 

templates/js_script.tmpl

@@ -10,7 +10,7 @@ export async function {{.Title}}({
     {{ if len .Parameters -}}
     args: (arg, t) => [
       {{- range $index, $ele := .Parameters -}}
-        {{if $index}}, {{end}}arg({{.Name}}, t.{{.Type}})
+        {{if $index}}, {{end}}arg({{.Name}}, t.{{.FclType}})
       {{- end -}}
       ]
     {{- end }}

templates/js_tx.tmpl

@@ -10,7 +10,7 @@ export async function {{.Title}}({
     {{ if len .Parameters -}}
     args: (arg, t) => [
       {{- range $index, $ele := .Parameters -}}
-        {{if $index}}, {{end}}arg({{.Name}}, t.{{.Type}})
+        {{if $index}}, {{end}}arg({{.Name}}, t.{{.FclType}})
       {{- end -}}
       ]
     {{- end }}