goscript 0.0.4 → 0.0.6

package/cmd/goscript/main.js

@@ -15,7 +15,7 @@ const args = process.argv.slice(2);
 
 // Construct the go run command with the absolute path to the goscript executable
 // Use path.join for robustness
-const goscriptCmd = `go run "${path.join(projectRoot, "cmd", "goscript")}"`;
+const goscriptCmd = `go run ./cmd/goscript`;
 
 // Combine the goscript command with the arguments
 const command = `${goscriptCmd} ${args.join(" ")}`;
@@ -24,7 +24,7 @@ const command = `${goscriptCmd} ${args.join(" ")}`;
 const child = spawn(command, {
   shell: true, // Use shell to correctly parse the command string
   stdio: 'inherit', // Inherit stdin, stdout, and stderr
-  cwd: process.cwd(), // Execute in the current working directory where the script is run
+  cwd: projectRoot, // Execute in the current working directory where the script is run
 });
 
 child.on('error', (error) => {

package/compiler/compile.go

@@ -3,12 +3,11 @@ package compiler
 import (
 	"fmt"
 	"go/ast"
-	"go/token" // Added token import for containsAsyncOperations
+	"go/token"
 	"go/types"
 
+	gstypes "github.com/paralin/goscript/compiler/types"
 	"golang.org/x/tools/go/packages"
-
-	gstypes "github.com/paralin/goscript/types"
 )
 
 // GoToTSCompiler compiles Go code to TypeScript code.

package/compiler/compile_expr.go

@@ -8,7 +8,7 @@ import (
 	gtypes "go/types"
 	"strconv"
 
-	gstypes "github.com/paralin/goscript/types"
+	gstypes "github.com/paralin/goscript/compiler/types"
 )
 
 // WriteTypeExpr writes an expression that represents a type.

package/compiler/compile_stmt.go

@@ -7,7 +7,7 @@ import (
 	gtypes "go/types"
 	"strings"
 
-	gstypes "github.com/paralin/goscript/types"
+	gstypes "github.com/paralin/goscript/compiler/types"
 	"github.com/sanity-io/litter"
 	"golang.org/x/tools/go/packages"
 )

package/compiler/output.go

@@ -0,0 +1,10 @@
+package compiler
+
+import (
+	"path/filepath"
+)
+
+// ComputeModulePath computes the root of the output typescript module.
+func ComputeModulePath(outputRoot, goPkg string) string {
+	return filepath.Join(outputRoot, goPkg)
+}

package/compiler/pkg_compiler.go

@@ -6,7 +6,6 @@ import (
 	"os"
 	"path/filepath"
 
-	"github.com/paralin/goscript/output"
 	"github.com/sirupsen/logrus"
 	"golang.org/x/tools/go/packages"
 )
@@ -29,7 +28,7 @@ func NewPackageCompiler(
 		le:           le,
 		pkg:          pkg,
 		compilerConf: compilerConf,
-		outputPath:   output.ComputeModulePath(compilerConf.OutputPathRoot, pkg.PkgPath),
+		outputPath:   ComputeModulePath(compilerConf.OutputPathRoot, pkg.PkgPath),
 	}
 
 	return res, nil

package/compiler/types/tokens.go

@@ -0,0 +1,65 @@
+package types
+
+import (
+	"go/token"
+)
+
+var tokenMap = map[token.Token]string{
+	token.ADD: "+",
+	token.SUB: "-",
+	token.MUL: "*",
+	token.QUO: "/",
+	token.REM: "%",
+	token.OR:  "|",
+	token.XOR: "^",
+	token.SHL: "<<",
+	token.SHR: ">>",
+
+	token.ADD_ASSIGN: "+=",
+	token.SUB_ASSIGN: "-=",
+	token.MUL_ASSIGN: "*=",
+	token.QUO_ASSIGN: "/=",
+	token.REM_ASSIGN: "%=",
+
+	token.AND_ASSIGN:     "&=",
+	token.OR_ASSIGN:      "|=",
+	token.XOR_ASSIGN:     "^=", // TODO: check if this works
+	token.SHL_ASSIGN:     "<<=",
+	token.SHR_ASSIGN:     ">>=",
+	token.AND_NOT_ASSIGN: "&^=",
+
+	token.LAND: "&&",
+	token.LOR:  "||",
+	// token.ARROW: ""
+	token.INC:    "++",
+	token.DEC:    "--",
+	token.EQL:    "==",
+	token.LSS:    "<",
+	token.GTR:    ">",
+	token.ASSIGN: "=",
+	token.NOT:    "!",
+
+	token.NEQ:      "!=",
+	token.LEQ:      "<=",
+	token.GEQ:      ">=",
+	token.DEFINE:   "=",   // :=
+	token.ELLIPSIS: "...", // TODO
+
+	token.LPAREN: "(",
+	token.LBRACK: "[",
+	token.LBRACE: "{",
+	token.COMMA:  ",",
+	token.PERIOD: ".",
+
+	token.RPAREN:    ")",
+	token.RBRACK:    "]",
+	token.RBRACE:    "}",
+	token.SEMICOLON: ";",
+	token.COLON:     ":",
+}
+
+// TokenToTs looks up the typescript version of a token.
+func TokenToTs(tok token.Token) (string, bool) {
+	t, ok := tokenMap[tok]
+	return t, ok
+}

package/compiler/types/types.go

@@ -0,0 +1,46 @@
+package types
+
+// goToTypescriptPrimitives maps Go primitive types to their TypeScript equivalents.
+//
+// Assumptions:
+//   - Target environment is similar to GOOS=js GOARCH=wasm, where `int` and `uint` are 32 bits.
+//   - 32-bit Go integers fit safely within the JS/TypeScript `number` type.
+//   - 64-bit integers (`int64`, `uint64`) require TypeScript `bigint` (ES2020+).
+//   - Only primitive types are handled here. Composite types (pointers, slices, maps, structs, etc.)
+//     are not handled by this mapping.
+var goToTypescriptPrimitives = map[string]string{
+	// Boolean
+	"bool": "boolean",
+
+	// Strings
+	"string": "string",
+
+	// Signed Integers
+	"int":   "number",
+	"int8":  "number",
+	"int16": "number",
+	"int32": "number",
+	"rune":  "number", // alias for int32
+	"int64": "bigint", // Requires TypeScript target >= ES2020
+
+	// Unsigned Integers
+	"uint":   "number",
+	"uint8":  "number", // byte is an alias for uint8
+	"byte":   "number",
+	"uint16": "number",
+	"uint32": "number",
+	"uint64": "bigint", // Requires TypeScript target >= ES2020
+
+	// Floating Point Numbers
+	"float32": "number",
+	"float64": "number",
+}
+
+// GoBuiltinToTypescript returns the TypeScript equivalent of a Go primitive type name.
+// Returns the TypeScript type and true if found, or an empty string and false otherwise.
+//
+// Only primitive types listed in goToTypescriptPrimitives are handled.
+func GoBuiltinToTypescript(typeName string) (string, bool) {
+	val, ok := goToTypescriptPrimitives[typeName]
+	return val, ok
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "goscript",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "Go to TypeScript compiler",
   "bin": {
     "goscript": "./cmd/goscript/main.js"