Add binding gen js for remote and local

.gitignore

@@ -0,0 +1,5 @@
+# Ignore cmd directory
+cmd/
+
+# ignore all .DS_Store files
+.DS_Store

bindings/generator.go

@@ -0,0 +1,26 @@
+package bindings
+
+import (
+	"fmt"
+	"log"
+
+	js "github.com/onflow/flixkit-go/bindings/js"
+	"github.com/onflow/flixkit-go/common"
+)
+
+func Generate(lang string, flix *common.FlowInteractionTemplate, templateLocation string) (string, error) {
+	var contents string
+	var err error
+	switch lang {
+		case "javascript", "js":
+			contents, err = js.GenerateJavaScript(flix, templateLocation)
+		default:
+			return "", fmt.Errorf("language %s not supported", lang)
+	}
+
+    if err != nil {
+        log.Fatalf("Error generating JavaScript: %v", err)
+    }
+
+	return contents, err
+}

bindings/js/gen.go

@@ -0,0 +1,90 @@
+package js
+
+import (
+	"bytes"
+	"embed"
+	_ "embed"
+	"fmt"
+	"net/url"
+	"path"
+	"text/template"
+
+	"github.com/onflow/flixkit-go/common"
+)
+
+type SimpleParameter struct {
+	Name string
+	Type string
+}
+
+type TemplateData struct {
+    Version     string
+    Parameters []SimpleParameter
+    Title       string
+    Location    string
+    IsScript    bool
+    IsLocalTemplate bool
+}
+
+//go:embed templates/*.tmpl
+var templateFiles embed.FS
+
+func GenerateJavaScript(flix *common.FlowInteractionTemplate, templateLocation string) (string, error) {
+    tmpl, err := template.ParseFS(templateFiles, "templates/*.tmpl")
+    if err != nil {
+        fmt.Println("Error executing template:", err)
+        return "", err
+    }
+
+    templatePath, IsLocal, _ := GetTemplateReference(templateLocation)
+    methodName := common.TitleToMethodName(flix.Data.Messages.Title.I18N["en-US"])
+    data := TemplateData{
+        Version: flix.FVersion,
+        Parameters: TransformArguments(flix.Data.Arguments),
+        Title: methodName,
+        Location: templatePath,
+        IsScript: flix.IsScript(),
+        IsLocalTemplate: IsLocal,
+    }
+
+    var buf bytes.Buffer
+    err = tmpl.Execute(&buf, data)
+    return buf.String(), err    
+}
+
+
+func TransformArguments(args common.Arguments) []SimpleParameter {
+	simpleArgs := []SimpleParameter{}
+	for name, arg := range args {
+        isArray, arrayType := IsArrayParameter(arg)
+        if (isArray) {
+            simpleArgs = append(simpleArgs, SimpleParameter{Name: name, Type: "Array(t." + arrayType + ")"})
+        } else {
+            simpleArgs = append(simpleArgs, SimpleParameter{Name: name, Type: arg.Type})
+        }
+	}
+	return simpleArgs
+}
+
+
+func IsArrayParameter(arg common.Argument) (bool, string) {
+    isArray := arg.Type[0] == '[' && arg.Type[len(arg.Type)-1] == ']'
+    if (!isArray) {
+        return isArray, ""
+    }
+    return isArray, arg.Type[1 : len(arg.Type)-1]
+}
+
+func GetTemplateReference(templateLocation string) (string, bool, error) {
+    var err error
+    templatePath := templateLocation
+    IsLocal := common.IsLocalTemplate(templateLocation)
+    if (IsLocal) {
+        parsedURL, err := url.Parse(templateLocation)
+        if err != nil {
+            return templatePath, IsLocal, err
+        }
+        templatePath = "./" + path.Base(parsedURL.Path)   
+    }
+    return templatePath, IsLocal, err
+}

bindings/js/gen_test.go

@@ -0,0 +1,203 @@
+package js
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/onflow/flixkit-go/common"
+	"github.com/stretchr/testify/assert"
+)
+
+
+var parsedTemplateTX = &common.FlowInteractionTemplate{
+	FType:    "InteractionTemplate",
+	FVersion: "1.0.0",
+	ID:       "290b6b6222b2a77b16db896a80ddf29ebd1fa3038c9e6625a933fa213fce51fa",
+	Data: common.Data{
+		Type:      "transaction",
+		Interface: "",
+		Messages: common.Messages{
+			Title: &common.Title{
+				I18N: map[string]string{
+					"en-US": "Transfer Tokens",
+				},
+			},
+			Description: &common.Description{
+				I18N: map[string]string{
+					"en-US": "Transfer tokens from one account to another",
+				},
+			},
+		},
+		Cadence: "import FungibleToken from 0xFUNGIBLETOKENADDRESS\ntransaction(amount: UFix64, to: Address) {\nlet vault: @FungibleToken.Vault\nprepare(signer: AuthAccount) {\nself.vault <- signer\n.borrow<&{FungibleToken.Provider}>(from: /storage/flowTokenVault)!\n.withdraw(amount: amount)\n}\nexecute {\ngetAccount(to)\n.getCapability(/public/flowTokenReceiver)!\n.borrow<&{FungibleToken.Receiver}>()!\n.deposit(from: <-self.vault)\n}\n}",
+		Dependencies: common.Dependencies{
+			"0xFUNGIBLETOKENADDRESS": common.Contracts{
+				"FungibleToken": common.Networks{
+					"mainnet": common.Network{
+						Address:        "0xf233dcee88fe0abe",
+						FqAddress:      "A.0xf233dcee88fe0abe.FungibleToken",
+						Contract:       "FungibleToken",
+						Pin:            "83c9e3d61d3b5ebf24356a9f17b5b57b12d6d56547abc73e05f820a0ae7d9cf5",
+						PinBlockHeight: 34166296,
+					},
+					"testnet": common.Network{
+						Address:        "0x9a0766d93b6608b7",
+						FqAddress:      "A.0x9a0766d93b6608b7.FungibleToken",
+						Contract:       "FungibleToken",
+						Pin:            "83c9e3d61d3b5ebf24356a9f17b5b57b12d6d56547abc73e05f820a0ae7d9cf5",
+						PinBlockHeight: 74776482,
+					},
+				},
+			},
+		},
+		Arguments: common.Arguments{
+			"amount": common.Argument{
+				Index: 0,
+				Type:  "UFix64",
+				Messages: common.Messages{
+					Title: &common.Title{
+						I18N: map[string]string{
+							"en-US": "The amount of FLOW tokens to send",
+						},
+					},
+				},
+				Balance: "",
+			},
+			"to": common.Argument{
+				Index: 1,
+				Type:  "Address",
+				Messages: common.Messages{
+					Title: &common.Title{
+						I18N: map[string]string{
+							"en-US": "The Flow account the tokens will go to",
+						},
+					},
+				},
+				Balance: "",
+			},
+		},
+	},
+}
+
+
+var parsedTemplateScript = &common.FlowInteractionTemplate{
+	FType:    "InteractionTemplate",
+	FVersion: "1.0.0",
+	ID:       "290b6b6222b2a77b16db896a80ddf29ebd1fa3038c9e6625a933fa213fce51fa",
+	Data: common.Data{
+		Type:      "script",
+		Interface: "",
+		Messages: common.Messages{
+			Title: &common.Title{
+				I18N: map[string]string{
+					"en-US": "Transfer Tokens",
+				},
+			},
+			Description: &common.Description{
+				I18N: map[string]string{
+					"en-US": "Transfer tokens from one account to another",
+				},
+			},
+		},
+		Cadence: "pub fun main(x: Int, y: Int): Int { return x * y }",
+		Arguments: common.Arguments{
+			"x": common.Argument{
+				Index: 0,
+				Type:  "Int",
+				Messages: common.Messages{
+					Title: &common.Title{
+						I18N: map[string]string{
+							"en-US": "number to be multiplied",
+						},
+					},
+				},
+				Balance: "",
+			},
+			"y": common.Argument{
+				Index: 1,
+				Type:  "Int",
+				Messages: common.Messages{
+					Title: &common.Title{
+						I18N: map[string]string{
+							"en-US": "second number to be multiplied",
+						},
+					},
+				},
+				Balance: "",
+			},
+		},
+	},
+}
+
+
+var ArrayTypeScript = &common.FlowInteractionTemplate{
+	FType:    "InteractionTemplate",
+	FVersion: "1.0.0",
+	ID:       "290b6b6222b2a77b16db896a80ddf29ebd1fa3038c9e6625a933fa213fce51fa",
+	Data: common.Data{
+		Type:      "script",
+		Interface: "",
+		Messages: common.Messages{
+			Title: &common.Title{
+				I18N: map[string]string{
+					"en-US": "Multiply Numbers",
+				},
+			},
+			Description: &common.Description{
+				I18N: map[string]string{
+					"en-US": "Multiply numbers in an array",
+				},
+			},
+		},
+		Cadence: "pub fun main(numbers: [Int]): Int { var total = 1; for x in numbers { total = total * x }; return total }",
+		Arguments: common.Arguments{
+			"numbers": common.Argument{
+				Index: 0,
+				Type:  "[Int]",
+				Messages: common.Messages{
+					Title: &common.Title{
+						I18N: map[string]string{
+							"en-US": "Array of numbers to be multiplied",
+						},
+					},
+				},
+				Balance: "",
+			},
+		},
+	},
+}
+func TestJSGenTransaction(t *testing.T) {
+	assert := assert.New(t)
+
+	contents, err := GenerateJavaScript(parsedTemplateTX, "./transfer_token.json")
+	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(")
+	println(contents)
+
+}
+
+
+func TestJSGenScript(t *testing.T) {
+	assert := assert.New(t)
+
+	contents, err := GenerateJavaScript(parsedTemplateScript, "./transfer_token.json")
+	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(")
+	println(contents)
+
+}
+
+
+
+func TestJSGenArrayScript(t *testing.T) {
+	assert := assert.New(t)
+
+	contents, err := GenerateJavaScript(ArrayTypeScript, "./multiply-numbers.template.json")
+	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(")
+	assert.True(strings.Contains(contents, `args: (arg, t) => ([ args(numbers, t.Array(t.Int))])`), "Expected '%s'", `args([ fcl.arg(numbers, t.Array(t.Int)) ])`)
+	println(contents)
+
+}

bindings/js/templates/main.tmpl

@@ -0,0 +1,26 @@
+/**
+    This binding file was auto generated based on FLIX template v{{.Version}}. 
+    Changes to this file might get overwritten 
+**/
+
+import * as fcl from "@onflow/fcl"
+{{- if .IsLocalTemplate }}
+import flixTemplate from "{{.Location}}"
+{{- else}}
+const flixTemplate = "{{.Location}}"
+{{- end}}
+
+const parameterNames = [
+  {{- range $index, $ele := .Parameters -}}
+     {{if $index}}, {{end}}"{{$ele.Name}}"
+  {{- end -}}
+];
+
+{{if .IsScript}}
+{{- template "script.tmpl" .}}
+{{else}}
+{{- template "tx.tmpl" .}}
+{{end}}
+
+
+

bindings/js/templates/script.tmpl

@@ -0,0 +1,20 @@
+export async function {{.Title}}({ 
+ {{- if len .Parameters -}}
+    {{- range $index, $ele := .Parameters -}}
+      {{if $index}}, {{end}}{{.Name}}
+    {{- end -}}
+  {{- end -}}
+}) {
+  const info = await fcl.query({
+    template: flixTemplate,
+    {{ if len .Parameters -}}
+    args: (arg, t) => [
+      {{- range $index, $ele := .Parameters -}}
+        {{if $index}}, {{end}}arg({{.Name}}, t.{{.Type}})
+      {{- end -}}
+      ]
+    {{- end }}
+  });
+
+  return info
+}

bindings/js/templates/tx.tmpl

@@ -0,0 +1,20 @@
+export async function {{.Title}}({ 
+ {{- if len .Parameters -}}
+    {{- range $index, $ele := .Parameters -}}
+      {{if $index}}, {{end}}{{.Name}}
+    {{- end -}}
+  {{- end -}}
+}) {
+  const transactionId = await fcl.mutate({
+    template: flixTemplate,
+    {{ if len .Parameters -}}
+    args: (arg, t) => [
+      {{- range $index, $ele := .Parameters -}}
+        {{if $index}}, {{end}}arg({{.Name}}, t.{{.Type}})
+      {{- end -}}
+      ]
+    {{- end }}
+  });
+
+  return transactionId
+}