goscript 0.0.80 → 0.0.81

package/compiler/analysis.go

@@ -1515,7 +1515,7 @@ func (a *Analysis) addImportsForPromotedMethods(pkg *packages.Package) {
 		if len(packagesToAdd) > 0 {
 			fileImports := make(map[string]*fileImport)
 			for pkgName, pkgObj := range packagesToAdd {
-				tsImportPath := "@goscript/" + pkgObj.Path()
+				tsImportPath := translateGoImportPathToTypescriptModulePath(pkgObj.Path())
 				fileImports[pkgName] = &fileImport{
 					importPath: tsImportPath,
 					importVars: make(map[string]struct{}),

package/compiler/compiler.go

@@ -474,11 +474,7 @@ func (c *PackageCompiler) generateIndexFile(compiledFiles []string) error {
 		// Check if this is a protobuf file
 		if strings.HasSuffix(fileName, ".pb") {
 			// For protobuf files, add a simple re-export
-			pbTsFileName := fileName + ".ts"
-			if err := func() error {
-				var _ string = pbTsFileName
-				return c.writeProtobufExports(indexFile, fileName)
-			}(); err != nil {
+			if err := c.writeProtobufExports(indexFile, fileName); err != nil {
 				return err
 			}
 			continue
@@ -555,8 +551,8 @@ func (c *PackageCompiler) generateIndexFile(compiledFiles []string) error {
 		// Write exports if this file has exported symbols
 		if len(valueSymbols) > 0 {
 			slices.Sort(valueSymbols)
-			exportLine := fmt.Sprintf("export { %s } from \"./%s.js\"\n",
-				strings.Join(valueSymbols, ", "), fileName)
+			exportLine := fmt.Sprintf("export { %s } from %q\n",
+				strings.Join(valueSymbols, ", "), translateGeneratedFileToImportPath(fileName))
 			if _, err := indexFile.WriteString(exportLine); err != nil {
 				return err
 			}
@@ -566,8 +562,8 @@ func (c *PackageCompiler) generateIndexFile(compiledFiles []string) error {
 		if len(structSymbols) > 0 {
 			slices.Sort(structSymbols)
 			// Export classes as values (which makes them available as both types and values in TypeScript)
-			exportLine := fmt.Sprintf("export { %s } from \"./%s.js\"\n",
-				strings.Join(structSymbols, ", "), fileName)
+			exportLine := fmt.Sprintf("export { %s } from %q\n",
+				strings.Join(structSymbols, ", "), translateGeneratedFileToImportPath(fileName))
 			if _, err := indexFile.WriteString(exportLine); err != nil {
 				return err
 			}
@@ -575,8 +571,8 @@ func (c *PackageCompiler) generateIndexFile(compiledFiles []string) error {
 
 		if len(typeSymbols) > 0 {
 			slices.Sort(typeSymbols)
-			exportLine := fmt.Sprintf("export type { %s } from \"./%s.js\"\n",
-				strings.Join(typeSymbols, ", "), fileName)
+			exportLine := fmt.Sprintf("export type { %s } from %q\n",
+				strings.Join(typeSymbols, ", "), translateGeneratedFileToImportPath(fileName))
 			if _, err := indexFile.WriteString(exportLine); err != nil {
 				return err
 			}
@@ -664,7 +660,10 @@ func (c *FileCompiler) Compile(ctx context.Context) error {
 	goWriter := NewGoToTSCompiler(c.codeWriter, c.pkg, c.Analysis, c.fullPath)
 
 	// Add import for the goscript runtime using namespace import and alias
-	c.codeWriter.WriteLinef("import * as $ from %q", "@goscript/builtin/index.js")
+	c.codeWriter.WriteLinef(
+		"import * as $ from %q",
+		translateTypescriptModulePathToIndexImportPath("@goscript/builtin"),
+	)
 
 	// Check if there are any .pb.go files in this package and add imports for them
 	if err := c.addProtobufImports(); err != nil {
@@ -691,8 +690,8 @@ func (c *FileCompiler) Compile(ctx context.Context) error {
 				}
 				// Sort functions for consistent output
 				slices.Sort(sanitizedFunctions)
-				c.codeWriter.WriteLinef("import { %s } from \"./%s.gs.js\";",
-					strings.Join(sanitizedFunctions, ", "), sourceFile)
+				c.codeWriter.WriteLinef("import { %s } from %q;",
+					strings.Join(sanitizedFunctions, ", "), translateGeneratedGoFileToImportPath(sourceFile))
 			}
 		}
 	}
@@ -709,7 +708,7 @@ func (c *FileCompiler) Compile(ctx context.Context) error {
 		for _, sourceFile := range sourceFiles {
 			typeImports := typeImports[sourceFile]
 			if len(typeImports) > 0 {
-				// Filter out protobuf types - they should be imported from .pb.js files, not .gs.js files
+				// Filter out protobuf types - they should be imported from .pb.ts files, not .gs.ts files
 				var nonProtobufTypes []string
 				for _, typeName := range typeImports {
 					// Check if this type is a protobuf type by looking at its type info
@@ -736,8 +735,8 @@ func (c *FileCompiler) Compile(ctx context.Context) error {
 					}
 					// Sort types for consistent output
 					slices.Sort(sanitizedTypes)
-					c.codeWriter.WriteLinef("import { %s } from \"./%s.gs.js\";",
-						strings.Join(sanitizedTypes, ", "), sourceFile)
+					c.codeWriter.WriteLinef("import { %s } from %q;",
+						strings.Join(sanitizedTypes, ", "), translateGeneratedGoFileToImportPath(sourceFile))
 				}
 			}
 		}
@@ -762,8 +761,8 @@ func (c *FileCompiler) Compile(ctx context.Context) error {
 				}
 				// Sort variables for consistent output
 				slices.Sort(sanitizedVariables)
-				c.codeWriter.WriteLinef("import { %s } from \"./%s.gs.js\";",
-					strings.Join(sanitizedVariables, ", "), sourceFile)
+				c.codeWriter.WriteLinef("import { %s } from %q;",
+					strings.Join(sanitizedVariables, ", "), translateGeneratedGoFileToImportPath(sourceFile))
 			}
 		}
 	}
@@ -779,7 +778,7 @@ func (c *FileCompiler) Compile(ctx context.Context) error {
 		slices.Sort(syntheticPkgNames)
 		for _, pkgName := range syntheticPkgNames {
 			imp := syntheticImports[pkgName]
-			c.codeWriter.WriteImport(pkgName, imp.importPath+"/index.js")
+			c.codeWriter.WriteImport(pkgName, translateTypescriptModulePathToIndexImportPath(imp.importPath))
 		}
 	}
 

package/compiler/decl.go

@@ -574,7 +574,7 @@ func (c *GoToTSCompiler) writeLinknameFunction(decl *ast.FuncDecl, info *linknam
 func (c *GoToTSCompiler) findImportAlias(pkgPath string) string {
 	// The importPath in analysis.Imports is stored as the TypeScript path (e.g., @goscript/pkg/path)
 	// We need to convert the Go package path to match
-	tsPath := "@goscript/" + pkgPath
+	tsPath := translateGoImportPathToTypescriptModulePath(pkgPath)
 
 	for alias, imp := range c.analysis.Imports {
 		if imp.importPath == tsPath {

package/compiler/gs_dependencies_test.go

@@ -5,6 +5,7 @@ import (
 	"os"
 	"path/filepath"
 	"slices"
+	"strings"
 	"testing"
 
 	"github.com/sirupsen/logrus"
@@ -171,3 +172,127 @@ func TestCompilePackagesCopiesHandwrittenDependencies(t *testing.T) {
 		t.Fatalf("Expected handwritten dependency at %s: %v", cmpPath, err)
 	}
 }
+
+func TestCompilePackagesEmitTypeScriptImportSpecifiers(t *testing.T) {
+	tempDir, err := os.MkdirTemp("", "goscript-ts-imports")
+	if err != nil {
+		t.Fatalf("Failed to create temp dir: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	wd, err := os.Getwd()
+	if err != nil {
+		t.Fatalf("Failed to get working directory: %v", err)
+	}
+
+	config := &Config{
+		OutputPath:         tempDir,
+		Dir:                filepath.Dir(wd),
+		AllDependencies:    true,
+		DisableEmitBuiltin: false,
+	}
+
+	logger := logrus.New()
+	logger.SetLevel(logrus.WarnLevel)
+	le := logrus.NewEntry(logger)
+
+	comp, err := NewCompiler(config, le, nil)
+	if err != nil {
+		t.Fatalf("Failed to create compiler: %v", err)
+	}
+
+	_, err = comp.CompilePackages(
+		context.Background(),
+		"github.com/aperturerobotics/goscript/tests/tests/package_import",
+		"github.com/aperturerobotics/goscript/tests/tests/map_value_field_access_cross_file",
+	)
+	if err != nil {
+		t.Fatalf("Compilation failed: %v", err)
+	}
+
+	assertFileContains(t,
+		filepath.Join(
+			tempDir,
+			"@goscript",
+			"github.com",
+			"aperturerobotics",
+			"goscript",
+			"tests",
+			"tests",
+			"package_import",
+			"package_import.gs.ts",
+		),
+		[]string{
+			`@goscript/builtin/index.ts`,
+			`@goscript/github.com/aperturerobotics/goscript/tests/tests/package_import/subpkg/index.ts`,
+		},
+		[]string{
+			".js",
+		},
+	)
+
+	assertFileContains(t,
+		filepath.Join(
+			tempDir,
+			"@goscript",
+			"github.com",
+			"aperturerobotics",
+			"goscript",
+			"tests",
+			"tests",
+			"package_import",
+			"subpkg",
+			"index.ts",
+		),
+		[]string{
+			`"./subpkg.gs.ts"`,
+		},
+		[]string{
+			".gs.js",
+		},
+	)
+
+	assertFileContains(t,
+		filepath.Join(
+			tempDir,
+			"@goscript",
+			"github.com",
+			"aperturerobotics",
+			"goscript",
+			"tests",
+			"tests",
+			"map_value_field_access_cross_file",
+			"read.gs.ts",
+		),
+		[]string{
+			`"./types.gs.ts"`,
+			`@goscript/builtin/index.ts`,
+		},
+		[]string{
+			".gs.js",
+			"index.js",
+		},
+	)
+}
+
+func assertFileContains(t *testing.T, path string, want []string, wantAbsent []string) {
+	t.Helper()
+
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatalf("Failed to read %s: %v", path, err)
+	}
+	text := string(data)
+
+	for _, s := range want {
+		if !strings.Contains(text, s) {
+			t.Fatalf("Expected %s to contain %q\n%s", path, s, text)
+		}
+	}
+
+	for _, s := range wantAbsent {
+		if strings.Contains(text, s) {
+			t.Fatalf("Expected %s to omit %q\n%s", path, s, text)
+		}
+	}
+}

package/compiler/output.go

@@ -15,6 +15,8 @@ func ComputeModulePath(outputRoot, goPkg string) string {
 
 var typeScriptGoStubPrefix = "@ts/"
 
+const builtinGoImportPath = "github.com/aperturerobotics/goscript/builtin"
+
 // translateGoPathToTypescriptPath translates a go package import path to a typescript import path.
 func translateGoPathToTypescriptPath(goImportPath string) string {
 	if strings.HasPrefix(goImportPath, typeScriptGoStubPrefix) {
@@ -23,6 +25,34 @@ func translateGoPathToTypescriptPath(goImportPath string) string {
 	return fmt.Sprintf("@goscript/%s", goImportPath)
 }
 
+// translateGoImportPathToTypescriptModulePath maps a Go import path to a TypeScript module path.
+func translateGoImportPathToTypescriptModulePath(goImportPath string) string {
+	if goImportPath == builtinGoImportPath {
+		return "@goscript/builtin"
+	}
+	return translateGoPathToTypescriptPath(goImportPath)
+}
+
+// translateTypescriptModulePathToIndexImportPath maps a TypeScript module path to its index.ts import path.
+func translateTypescriptModulePathToIndexImportPath(modulePath string) string {
+	return modulePath + "/index.ts"
+}
+
+// translateGeneratedFileToImportPath maps a generated file stem to its .ts import path.
+func translateGeneratedFileToImportPath(fileName string) string {
+	return fmt.Sprintf("./%s.ts", fileName)
+}
+
+// translateGeneratedGoFileToImportPath maps a generated Go file stem to its .gs.ts import path.
+func translateGeneratedGoFileToImportPath(fileName string) string {
+	return fmt.Sprintf("./%s.gs.ts", fileName)
+}
+
+// translateGeneratedProtobufFileToImportPath maps a protobuf file stem to its .pb.ts import path.
+func translateGeneratedProtobufFileToImportPath(fileName string) string {
+	return fmt.Sprintf("./%s.pb.ts", fileName)
+}
+
 // getActualPackageName returns the actual Go package name from package information.
 // If the package is not found in the imports map, returns an error instead of falling back.
 // This handles cases where the package name differs from the last segment of the import path.

package/compiler/protobuf.go

@@ -294,7 +294,8 @@ func (c *FileCompiler) addProtobufImports() error {
 					}
 				}
 
-				c.codeWriter.WriteLinef("import { %s } from \"./%s.pb.js\";", strings.Join(uniq, ", "), pbBaseName)
+				c.codeWriter.WriteLinef("import { %s } from %q;",
+					strings.Join(uniq, ", "), translateGeneratedProtobufFileToImportPath(pbBaseName))
 				break
 			}
 		}

package/compiler/spec.go

@@ -650,12 +650,7 @@ func (c *GoToTSCompiler) WriteImportSpec(a *ast.ImportSpec) {
 	// All Go package imports are mapped to the @goscript/ scope.
 	// The TypeScript compiler will resolve these using tsconfig paths to either
 	// handwritten versions (in .goscript-assets) or transpiled versions (in goscript).
-	var tsImportPath string
-	if goPath == "github.com/aperturerobotics/goscript/builtin" {
-		tsImportPath = "@goscript/builtin/index.js"
-	} else {
-		tsImportPath = "@goscript/" + goPath
-	}
+	tsImportPath := translateGoImportPathToTypescriptModulePath(goPath)
 
 	c.analysis.Imports[impName] = &fileImport{
 		importPath: tsImportPath,
@@ -671,7 +666,7 @@ func (c *GoToTSCompiler) WriteImportSpec(a *ast.ImportSpec) {
 		}
 	}
 
-	c.tsw.WriteImport(impName, tsImportPath+"/index.js")
+	c.tsw.WriteImport(impName, translateTypescriptModulePathToIndexImportPath(tsImportPath))
 }
 
 func (c *GoToTSCompiler) writeClonedFieldInitializer(fieldName string, fieldType types.Type, isEmbedded bool) {

package/compiler/wasm_api.go

@@ -110,7 +110,10 @@ func (c *FileCompiler) CompileToWriter(w io.Writer) error {
 	goWriter := NewGoToTSCompiler(c.codeWriter, c.pkg, c.Analysis, c.fullPath)
 
 	// Add import for the goscript runtime using namespace import and alias
-	c.codeWriter.WriteLinef("import * as $ from %q", "@goscript/builtin/index.js")
+	c.codeWriter.WriteLinef(
+		"import * as $ from %q",
+		translateTypescriptModulePathToIndexImportPath("@goscript/builtin"),
+	)
 
 	c.codeWriter.WriteLine("") // Add a newline after imports
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "goscript",
   "description": "Go to TypeScript transpiler",
-  "version": "0.0.80",
+  "version": "0.0.81",
   "author": {
     "name": "Aperture Robotics LLC.",
     "email": "support@aperture.us",