goscript 0.0.2

package/example/simple/main.go

@@ -0,0 +1,138 @@
+package main
+
+// MyStruct demonstrates a simple struct with public and private fields.
+// It will be converted into a TypeScript class by goscript.
+type MyStruct struct {
+	// MyInt is a public integer field, initialized to zero.
+	MyInt int
+	// MyString is a public string field, initialized to empty string.
+	MyString string
+	// myBool is a private boolean field, initialized to false.
+	myBool bool
+}
+
+// GetMyString returns the MyString field.
+func (m *MyStruct) GetMyString() string {
+	return m.MyString
+}
+
+// GetMyBool returns the myBool field.
+func (m *MyStruct) GetMyBool() bool {
+	return m.myBool
+}
+
+// NewMyStruct creates a new MyStruct instance.
+func NewMyStruct(s string) MyStruct {
+	return MyStruct{MyString: s}
+}
+
+func vals() (int, int) {
+	return 1, 2
+}
+
+func main() {
+	println("Hello from GoScript example!")
+
+	// Basic arithmetic
+	a, b := 10, 3
+	println("Addition:", a+b, "Subtraction:", a-b, "Multiplication:", a*b, "Division:", a/b, "Modulo:", a%b)
+
+	// Boolean logic and comparisons
+	println("Logic &&:", true && false, "||:", true || false, "!:!", !true)
+	println("Comparisons:", a == b, a != b, a < b, a > b, a <= b, a >= b)
+
+	// string(rune) conversion
+	var r rune = 'X'
+	s := string(r)
+	println("string('X'):", s)
+
+	var r2 rune = 121 // 'y'
+	s2 := string(r2)
+	println("string(121):", s2)
+
+	var r3 rune = 0x221A // '√'
+	s3 := string(r3)
+	println("string(0x221A):", s3)
+
+	// Arrays
+	arr := [3]int{1, 2, 3}
+	println("Array elements:", arr[0], arr[1], arr[2])
+
+	// Slices and range loop
+	slice := []int{4, 5, 6}
+	println("Slice elements:", slice[0], slice[1], slice[2])
+	sum := 0
+	for idx, val := range slice {
+		sum += val
+		println("Range idx:", idx, "val:", val)
+	}
+	println("Range sum:", sum)
+
+	// Basic for loop
+	prod := 1
+	for i := 1; i <= 3; i++ {
+		prod *= i
+	}
+	println("Product via for:", prod)
+
+	// Struct, pointers, copy independence
+	instance := NewMyStruct("go-script")
+	println("instance.MyString:", instance.GetMyString())
+	instance.MyInt = 42
+	copyInst := instance
+	copyInst.MyInt = 7
+	println("instance.MyInt:", instance.MyInt, "copyInst.MyInt:", copyInst.MyInt)
+
+	// Pointer initialization and dereference assignment
+	ptr := new(MyStruct)
+	ptr.MyInt = 9
+	println("ptr.MyInt:", ptr.MyInt)
+	deref := *ptr
+	deref.MyInt = 8
+	println("After deref assign, ptr.MyInt:", ptr.MyInt, "deref.MyInt:", deref.MyInt)
+
+	// Method calls on pointer receiver
+	ptr.myBool = true
+	println("ptr.GetMyBool():", ptr.GetMyBool())
+
+	// Composite literal assignment
+	comp := MyStruct{MyInt: 100, MyString: "composite", myBool: false}
+	println("comp fields:", comp.MyInt, comp.GetMyString(), comp.GetMyBool())
+
+	// Multiple return values and blank identifier
+	x, _ := vals()
+	_, y := vals()
+	println("vals x:", x, "y:", y)
+
+	// If/else
+	if a > b {
+		println("If branch: a>b")
+	} else {
+		println("Else branch: a<=b")
+	}
+
+	// Switch statement
+	switch a {
+	case 10:
+		println("Switch case 10")
+	default:
+		println("Switch default")
+	}
+	// Goroutines and Channels
+	println("\nGoroutines and Channels:")
+	ch := make(chan string)
+	go func() {
+		println("Goroutine: Sending message")
+		ch <- "Hello from goroutine!"
+	}()
+	msg := <-ch
+	println("Main goroutine: Received message:", msg)
+
+	// Function Literals
+	println("\nFunction Literals:")
+	add := func(x, y int) int {
+		return x + y
+	}
+	sum = add(5, 7)
+	println("Function literal result:", sum)
+}

package/example/simple/main.gs.ts

@@ -0,0 +1,133 @@
+import * as goscript from "@go/builtin";
+
+class MyStruct {
+	// MyInt is a public integer field, initialized to zero.
+	public MyInt: number = 0;
+	// MyString is a public string field, initialized to empty string.
+	public MyString: string = "";
+	// myBool is a private boolean field, initialized to false.
+	private myBool: boolean = false;
+	
+	// GetMyString returns the MyString field.
+	public GetMyString(): string {
+		const m = this
+		return m.MyString
+	}
+	
+	// GetMyBool returns the myBool field.
+	public GetMyBool(): boolean {
+		const m = this
+		return m.myBool
+	}
+	
+	constructor(init?: Partial<MyStruct>) { if (init) Object.assign(this, init as any); }
+	public clone(): MyStruct { return Object.assign(Object.create(MyStruct.prototype) as MyStruct, this); }
+}
+
+// NewMyStruct creates a new MyStruct instance.
+export function NewMyStruct(s: string): MyStruct {
+	return new MyStruct({ MyString: s })
+}
+
+function vals(): [number, number] {
+	return [1, 2]
+}
+
+export function main(): void {
+	console.log("Hello from GoScript example!")
+	
+	// Basic arithmetic
+	let a = 10
+	let b = 3
+	console.log("Addition:", a + b, "Subtraction:", a - b, "Multiplication:", a * b, "Division:", a / b, "Modulo:", a % b)
+	
+	// Boolean logic and comparisons
+	console.log("Logic &&:", true && false, "||:", true || false, "!:!", !true)
+	console.log("Comparisons:", a == b, a != b, a < b, a > b, a <= b, a >= b)
+	
+	// string(rune) conversion
+	let r: number = 'X';
+	let s = String.fromCharCode(r)
+	console.log("string('X'):", s)
+	
+	// 'y'
+	let r2: number = 121;
+	let s2 = String.fromCharCode(r2)
+	console.log("string(121):", s2)
+	
+	// '√'
+	let r3: number = 0x221A;
+	let s3 = String.fromCharCode(r3)
+	console.log("string(0x221A):", s3)
+	
+	// Arrays
+	let arr = [1, 2, 3]
+	console.log("Array elements:", arr[0], arr[1], arr[2])
+	
+	// Slices and range loop
+	let slice = [4, 5, 6]
+	console.log("Slice elements:", slice[0], slice[1], slice[2])
+	let sum = 0
+	for (let idx = 0; idx < slice.length; idx++) {
+		const val = slice[idx]
+		{
+			sum += val
+			console.log("Range idx:", idx, "val:", val)
+		}
+	}
+	console.log("Range sum:", sum)
+	
+	// Basic for loop
+	let prod = 1
+	for (let i = 1; i <= 3; i++) {
+		prod *= i
+	}
+	console.log("Product via for:", prod)
+	
+	// Struct, pointers, copy independence
+	let instance = NewMyStruct("go-script").clone()
+	console.log("instance.MyString:", instance.GetMyString())
+	instance.MyInt = 42
+	let copyInst = instance.clone()
+	copyInst.MyInt = 7
+	console.log("instance.MyInt:", instance.MyInt, "copyInst.MyInt:", copyInst.MyInt)
+	
+	// Pointer initialization and dereference assignment
+	let ptr = new(MyStruct)
+	ptr.MyInt = 9
+	console.log("ptr.MyInt:", ptr.MyInt)
+	let deref = ptr.clone()
+	deref.MyInt = 8
+	console.log("After deref assign, ptr.MyInt:", ptr.MyInt, "deref.MyInt:", deref.MyInt)
+	
+	// Method calls on pointer receiver
+	ptr.myBool = true
+	console.log("ptr.GetMyBool():", ptr.GetMyBool())
+	
+	// Composite literal assignment
+	let comp = new MyStruct({ MyInt: 100, MyString: "composite", myBool: false }).clone()
+	console.log("comp fields:", comp.MyInt, comp.GetMyString(), comp.GetMyBool())
+	
+	// Multiple return values and blank identifier
+	let [x, ] = vals()
+	let [, y] = vals()
+	console.log("vals x:", x, "y:", y)
+	
+	// If/else
+	if (a > b) {
+		console.log("If branch: a>b")
+	} else {
+		console.log("Else branch: a<=b")
+	}
+	
+	// Switch statement
+	switch (a) {
+		case 10:
+			console.log("Switch case 10")
+			break
+		default:
+			console.log("Switch default")
+			break
+	}
+}
+

package/example/simple/main.ts

@@ -0,0 +1,3 @@
+import { main } from "@go/example/main.gs.js"
+
+main()

package/example/simple/main_test.go

@@ -0,0 +1,59 @@
+package main_test
+
+import (
+	"context"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"testing"
+
+	"github.com/paralin/goscript/compiler"
+	"github.com/sirupsen/logrus"
+)
+
+func TestBuildRunExampleSimple(t *testing.T) {
+	// Set up paths
+	projectDir, err := filepath.Abs(".")
+	if err != nil {
+		t.Fatalf("failed to determine project directory: %v", err)
+	}
+	outputDir := filepath.Join(projectDir, "output")
+
+	// Initialize the compiler
+	logger := logrus.New()
+	logger.SetLevel(logrus.DebugLevel)
+	le := logrus.NewEntry(logger)
+
+	conf := &compiler.Config{
+		OutputPathRoot: outputDir,
+	}
+	if err := conf.Validate(); err != nil {
+		t.Fatalf("invalid compiler config: %v", err)
+	}
+
+	comp, err := compiler.NewCompiler(conf, le, nil)
+	if err != nil {
+		t.Fatalf("failed to create compiler: %v", err)
+	}
+
+	// Compile the package
+	if err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatalf("compilation failed: %v", err)
+	}
+
+	// Log the compiled file
+	outFile, err := os.ReadFile(filepath.Join(outputDir, "@go/example/main.gs.ts"))
+	if err != nil {
+		t.Fatalf("failed to read output file: %v", err)
+	}
+	t.Log(string(outFile))
+
+	// Run the compiled TypeScript file
+	cmd := exec.Command("tsx", "--tsconfig", "./tsconfig.json", "./main.ts")
+	cmd.Dir = projectDir
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	if err := cmd.Run(); err != nil {
+		t.Fatalf("run failed: %v", err)
+	}
+}

package/example/simple/main_tools.go

@@ -0,0 +1,5 @@
+//go:build tools
+
+package main
+
+import _ "github.com/paralin/goscript/cmd/goscript"

package/example/simple/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "@example/simple",
+  "private": true,
+  "devDependencies": {
+    "typescript": "^5.4.2"
+  }
+}

package/example/simple/run.bash

@@ -0,0 +1,6 @@
+#!/bin/bash
+set -eo pipefail
+
+bash build.bash
+
+tsx --tsconfig ./tsconfig.json ./main.ts

package/example/simple/tsconfig.json

@@ -0,0 +1,28 @@
+{
+  "compilerOptions": {
+    "module": "esnext",
+    "target": "esnext",
+    "moduleResolution": "node",
+    "jsx": "react",
+    "baseUrl": "./",
+    "paths": {
+      "@go/*": ["output/@go/*"],
+      "@go/builtin": ["../../builtin/builtin.ts"]
+    },
+    "allowSyntheticDefaultImports": true,
+    "declaration": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "importsNotUsedAsValues": "remove",
+    "noEmit": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "lib": ["webworker", "dom", "ES6"]
+  },
+  "exclude": ["node_modules", "vendor", "dist"],
+  "ts-node": {
+    "esm": true,
+    "experimentalSpecifierResolution": true
+  }
+}

package/example/simple/yarn.lock

@@ -0,0 +1,8 @@
+# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+# yarn lockfile v1
+
+
+typescript@^5.4.2:
+  version "5.8.3"
+  resolved "https://registry.yarnpkg.com/typescript/-/typescript-5.8.3.tgz#92f8a3e5e3cf497356f4178c34cd65a7f5e8440e"
+  integrity sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ==

package/go.mod

@@ -0,0 +1,22 @@
+module github.com/paralin/goscript
+
+go 1.24
+
+toolchain go1.24.2
+
+require (
+	github.com/aperturerobotics/cli v1.0.0
+	github.com/pkg/errors v0.9.1
+	github.com/sanity-io/litter v1.5.8
+	github.com/sirupsen/logrus v1.9.3
+	golang.org/x/tools v0.32.0
+)
+
+require (
+	github.com/aperturerobotics/common v0.21.2 // indirect
+	github.com/stretchr/testify v1.10.0 // indirect
+	github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1 // indirect
+	golang.org/x/mod v0.24.0 // indirect
+	golang.org/x/sync v0.13.0 // indirect
+	golang.org/x/sys v0.32.0 // indirect
+)

package/go.sum

@@ -0,0 +1,39 @@
+github.com/aperturerobotics/cli v1.0.0 h1:s3xT2h7eBih4/4yZKTn/HQ6P+qpk6ygWZl2416xAI1M=
+github.com/aperturerobotics/cli v1.0.0/go.mod h1:wtlINjMcKuwyV1x4ftReuA6hHZcPB8kPMXHyQqGFCSc=
+github.com/aperturerobotics/common v0.21.2 h1:fqnPL5Oovpd8nDaNBYGiD1UpZhcH/JfpsS8gt5iBDyA=
+github.com/aperturerobotics/common v0.21.2/go.mod h1:FrecdNcsYvVS8RcWCR8FUkKFh+XmouFOYKHpBdMqqBA=
+github.com/davecgh/go-spew v0.0.0-20161028175848-04cdfd42973b/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v0.0.0-20151028094244-d8ed2627bdf0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/sanity-io/litter v1.5.8 h1:uM/2lKrWdGbRXDrIq08Lh9XtVYoeGtcQxk9rtQ7+rYg=
+github.com/sanity-io/litter v1.5.8/go.mod h1:9gzJgR2i4ZpjZHsKvUXIRQVk7P+yM3e+jAF7bU2UI5U=
+github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
+github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v0.0.0-20161117074351-18a02ba4a312/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
+github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1 h1:gEOO8jv9F4OT7lGCjxCBTO/36wtF6j2nSip77qHd4x4=
+github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1/go.mod h1:Ohn+xnUBiLI6FVj/9LpzZWtj1/D6lUovWYBkxHVV3aM=
+golang.org/x/mod v0.24.0 h1:ZfthKaKaT4NrhGVZHO1/WDTwGES4De8KtWO0SIbNJMU=
+golang.org/x/mod v0.24.0/go.mod h1:IXM97Txy2VM4PJ3gI61r1YEk/gAj6zAHN3AdZt6S9Ww=
+golang.org/x/sync v0.13.0 h1:AauUjRAJ9OSnvULf/ARrrVywoJDy0YS2AwQ98I37610=
+golang.org/x/sync v0.13.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.32.0 h1:s77OFDvIQeibCmezSnk/q6iAfkdiQaJi4VzroCFrN20=
+golang.org/x/sys v0.32.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/tools v0.32.0 h1:Q7N1vhpkQv7ybVzLFtTjvQya2ewbwNDZzUgfXGqtMWU=
+golang.org/x/tools v0.32.0/go.mod h1:ZxrU41P/wAbZD8EDa6dDCa6XfpkhJ7HFMjHJXfBDu8s=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

package/output/output.go

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

package/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "goscript",
+  "version": "0.0.2",
+  "description": "Go to TypeScript compiler",
+  "scripts": {
+    "example": "cd ./example/simple && bash run.bash",
+    "test": "go test -v ./..."
+  },
+  "devDependencies": {
+    "prettier": "^3.5.3",
+    "tsx": "^4.0.0",
+    "typescript": "^5.0.0"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "baseUrl": ".",
+    "target": "ES2022",
+    "lib": ["ES2020", "dom"],
+    "paths": {
+      "@go/builtin": ["./builtin/builtin.ts"]
+    }
+  }
+}

package/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/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
+}