goscript 0.0.8 → 0.0.11

package/compiler/compile_spec.go

@@ -3,6 +3,9 @@ package compiler
 import (
 	"fmt"
 	"go/ast"
+	"go/types"
+	"sort"
+	"strings"
 )
 
 // WriteSpec writes a specification to the output.
@@ -24,6 +27,102 @@ func (c *GoToTSCompiler) WriteSpec(a ast.Spec) error {
 	return nil
 }
 
+// collectMethodNames returns a comma-separated string of method names for a struct
+func (c *GoToTSCompiler) collectMethodNames(structName string) string {
+	var methodNames []string
+
+	for _, fileSyntax := range c.pkg.Syntax {
+		for _, decl := range fileSyntax.Decls {
+			funcDecl, isFunc := decl.(*ast.FuncDecl)
+			if !isFunc || funcDecl.Recv == nil || len(funcDecl.Recv.List) == 0 {
+				continue // Skip non-functions or functions without receivers
+			}
+
+			// Check if the receiver type matches the struct name
+			recvField := funcDecl.Recv.List[0]
+			recvType := recvField.Type
+			// Handle pointer receivers (*MyStruct) and value receivers (MyStruct)
+			if starExpr, ok := recvType.(*ast.StarExpr); ok {
+				recvType = starExpr.X // Get the type being pointed to
+			}
+
+			// Check if the receiver identifier name matches the struct name
+			if ident, ok := recvType.(*ast.Ident); ok && ident.Name == structName {
+				// Found a method for this struct
+				methodNames = append(methodNames, fmt.Sprintf("'%s'", funcDecl.Name.Name))
+			}
+		}
+	}
+
+	return strings.Join(methodNames, ", ")
+}
+
+// getTypeExprName returns a string representation of a type expression.
+func (c *GoToTSCompiler) getTypeExprName(expr ast.Expr) string {
+	switch t := expr.(type) {
+	case *ast.Ident:
+		return t.Name
+	case *ast.SelectorExpr:
+		return fmt.Sprintf("%s.%s", c.getTypeExprName(t.X), t.Sel.Name)
+	case *ast.StarExpr:
+		return c.getTypeExprName(t.X) // Unwrap pointer type
+	default:
+		return "embedded" // Fallback for complex type expressions
+	}
+}
+
+// collectInterfaceMethods returns a comma-separated string of method names for an interface
+func (c *GoToTSCompiler) collectInterfaceMethods(interfaceType *ast.InterfaceType) string {
+	// Use a map to ensure uniqueness of method names
+	methodNamesMap := make(map[string]struct{})
+
+	if interfaceType.Methods != nil {
+		for _, method := range interfaceType.Methods.List {
+			if len(method.Names) > 0 {
+				// Named method
+				methodNamesMap[method.Names[0].Name] = struct{}{}
+			} else {
+				// Embedded interface - resolve it and collect its methods
+				embeddedType := method.Type
+
+				// Resolve the embedded interface using type information
+				if tv, ok := c.pkg.TypesInfo.Types[embeddedType]; ok && tv.Type != nil {
+					// Get the underlying interface type
+					var ifaceType *types.Interface
+					if named, ok := tv.Type.(*types.Named); ok {
+						if underlying, ok := named.Underlying().(*types.Interface); ok {
+							ifaceType = underlying
+						}
+					} else if underlying, ok := tv.Type.(*types.Interface); ok {
+						ifaceType = underlying
+					}
+
+					// Collect methods from the interface
+					if ifaceType != nil {
+						for i := 0; i < ifaceType.NumMethods(); i++ {
+							methodNamesMap[ifaceType.Method(i).Name()] = struct{}{}
+						}
+					}
+				} else {
+					// Couldn't resolve the embedded interface
+					c.tsw.WriteCommentLine("// Note: Some embedded interface methods may not be fully resolved")
+				}
+			}
+		}
+	}
+
+	// Convert the map to a slice for a deterministic output order
+	var methodNames []string
+	for name := range methodNamesMap {
+		methodNames = append(methodNames, fmt.Sprintf("'%s'", name))
+	}
+
+	// Sort for deterministic output
+	sort.Strings(methodNames)
+
+	return strings.Join(methodNames, ", ")
+}
+
 // WriteTypeSpec writes the type specification to the output.
 func (c *GoToTSCompiler) WriteTypeSpec(a *ast.TypeSpec) error {
 	if a.Doc != nil {
@@ -35,11 +134,27 @@ func (c *GoToTSCompiler) WriteTypeSpec(a *ast.TypeSpec) error {
 
 	switch t := a.Type.(type) {
 	case *ast.StructType:
-		// write the class definition
+		// Detect embedded struct (anonymous field) to support Go struct embedding.
+		var embeddedExpr ast.Expr
+		for _, f := range t.Fields.List {
+			if len(f.Names) == 0 { // anonymous field ⇒ embedded type
+				embeddedExpr = f.Type
+				break // only the first embedded struct is supported for now
+			}
+		}
+		// Write the class header, adding "extends Embedded" when an embedded struct is present.
 		c.tsw.WriteLiterally("class ")
 		if err := c.WriteValueExpr(a.Name); err != nil { // Class name is a value identifier
 			return err
 		}
+		if embeddedExpr != nil {
+			// For pointer embedding (*T) unwrap the star so we extend T, not (T|null)
+			if star, ok := embeddedExpr.(*ast.StarExpr); ok {
+				embeddedExpr = star.X
+			}
+			c.tsw.WriteLiterally(" extends ")
+			c.WriteTypeExpr(embeddedExpr) // Embedded type name
+		}
 		c.tsw.WriteLine(" {")
 		c.tsw.Indent(1)
 
@@ -79,8 +194,51 @@ func (c *GoToTSCompiler) WriteTypeSpec(a *ast.TypeSpec) error {
 
 		// constructor and clone using Object.assign for compactness
 		c.tsw.WriteLine("")
-		c.tsw.WriteLinef("constructor(init?: Partial<%s>) { if (init) Object.assign(this, init as any); }", className)
+		if embeddedExpr != nil {
+			// Determine the embedded type's identifier (strip any package prefix)
+			embeddedTypeNameFull := c.getTypeExprName(embeddedExpr)
+			propName := embeddedTypeNameFull
+			if idx := strings.LastIndex(propName, "."); idx != -1 {
+				propName = propName[idx+1:] // keep only the last segment for the property key
+			}
+
+			// The init parameter allows either flattened fields or a nested {Embedded: {...}} object
+			c.tsw.WriteLinef(
+				"constructor(init?: Partial<%s> & { %s?: Partial<%s> }) {",
+				className, propName, propName,
+			)
+			c.tsw.Indent(1)
+
+			// Pass either the nested embedded object or the full init directly to super()
+			c.tsw.WriteLinef("super(init?.%s || init);", propName)
+
+			// Copy fields that belong only to this derived class
+			c.tsw.WriteLine("if (init) {")
+			c.tsw.Indent(1)
+			c.tsw.WriteLinef("const { %s, ...rest } = init as any;", propName)
+			c.tsw.WriteLine("Object.assign(this, rest);")
+			c.tsw.Indent(-1)
+			c.tsw.WriteLine("}")
+
+			c.tsw.Indent(-1)
+			c.tsw.WriteLine("}")
+		} else {
+			// For a base class without embedding, use simple constructor
+			c.tsw.WriteLinef("constructor(init?: Partial<%s>) { if (init) Object.assign(this, init as any); }", className)
+		}
 		c.tsw.WriteLinef("public clone(): %s { return Object.assign(Object.create(%s.prototype) as %s, this); }", className, className, className)
+
+		// Add code to register the type with the runtime system
+		c.tsw.WriteLine("")
+		c.tsw.WriteLinef("// Register this type with the runtime type system")
+		c.tsw.WriteLinef("static __typeInfo = goscript.registerType(")
+		c.tsw.WriteLinef("  '%s',", className)
+		c.tsw.WriteLinef("  goscript.TypeKind.Struct,")
+		c.tsw.WriteLinef("  new %s(),", className)
+		c.tsw.WriteLinef("  new Set([%s]),", c.collectMethodNames(className))
+		c.tsw.WriteLinef("  %s", className)
+		c.tsw.WriteLinef(");")
+
 		c.tsw.Indent(-1)
 		c.tsw.WriteLine("}")
 	case *ast.InterfaceType:
@@ -88,8 +246,20 @@ func (c *GoToTSCompiler) WriteTypeSpec(a *ast.TypeSpec) error {
 		if err := c.WriteValueExpr(a.Name); err != nil { // Interface name is a value identifier
 			return err
 		}
-		c.tsw.WriteLine(" ")
-		c.WriteTypeExpr(a.Type) // The interface definition itself is a type
+		c.tsw.WriteLiterally(" ") // Changed from WriteLine to WriteLiterally
+		c.WriteTypeExpr(a.Type)   // The interface definition itself is a type
+
+		// Add code to register the interface with the runtime system
+		interfaceName := a.Name.Name
+		c.tsw.WriteLine("")
+		c.tsw.WriteLinef("// Register this interface with the runtime type system")
+		c.tsw.WriteLinef("const %s__typeInfo = goscript.registerType(", interfaceName)
+		c.tsw.WriteLinef("  '%s',", interfaceName)
+		c.tsw.WriteLinef("  goscript.TypeKind.Interface,")
+		c.tsw.WriteLinef("  null,") // Zero value for interface is null
+		c.tsw.WriteLinef("  new Set([%s]),", c.collectInterfaceMethods(t))
+		c.tsw.WriteLinef("  undefined")
+		c.tsw.WriteLinef(");")
 	default:
 		// type alias
 		c.tsw.WriteLiterally("type ")
@@ -110,8 +280,17 @@ func (c *GoToTSCompiler) WriteFuncDeclAsMethod(decl *ast.FuncDecl) error {
 		c.WriteDoc(decl.Doc)
 	}
 
+	// Determine if method is async by checking for async operations in the body
+	isAsync := c.containsAsyncOperations(decl.Body)
+	
 	// Methods are typically public in the TS output
 	c.tsw.WriteLiterally("public ")
+	
+	// Add async modifier if needed
+	if isAsync {
+		c.tsw.WriteLiterally("async ")
+	}
+	
 	// Keep original Go casing for method names
 	if err := c.WriteValueExpr(decl.Name); err != nil { // Method name is a value identifier
 		return err
@@ -129,6 +308,9 @@ func (c *GoToTSCompiler) WriteFuncDeclAsMethod(decl *ast.FuncDecl) error {
 	// Handle return type
 	if funcType.Results != nil && len(funcType.Results.List) > 0 {
 		c.tsw.WriteLiterally(": ")
+		if isAsync {
+			c.tsw.WriteLiterally("Promise<")
+		}
 		if len(funcType.Results.List) == 1 {
 			// Single return value
 			resultType := funcType.Results.List[0].Type
@@ -144,12 +326,27 @@ func (c *GoToTSCompiler) WriteFuncDeclAsMethod(decl *ast.FuncDecl) error {
 			}
 			c.tsw.WriteLiterally("]")
 		}
+		if isAsync {
+			c.tsw.WriteLiterally(">")
+		}
 	} else {
 		// No return value -> void
-		c.tsw.WriteLiterally(": void")
+		if isAsync {
+			c.tsw.WriteLiterally(": Promise<void>")
+		} else {
+			c.tsw.WriteLiterally(": void")
+		}
 	}
 
 	c.tsw.WriteLiterally(" ")
+
+	// Check if function body has defer statements
+	c.nextBlockNeedsDefer = c.scanForDefer(decl.Body)
+	
+	// Save previous async state and set current state based on isAsync
+	previousAsyncState := c.inAsyncFunction
+	c.inAsyncFunction = isAsync
+
 	// Bind receiver name to this
 	if recvField := decl.Recv.List[0]; len(recvField.Names) > 0 {
 		recvName := recvField.Names[0].Name
@@ -157,21 +354,40 @@ func (c *GoToTSCompiler) WriteFuncDeclAsMethod(decl *ast.FuncDecl) error {
 			c.tsw.WriteLine("{")
 			c.tsw.Indent(1)
 			c.tsw.WriteLinef("const %s = this", recvName)
+
+			// Add using statement if needed
+			if c.nextBlockNeedsDefer {
+				if c.inAsyncFunction {
+					c.tsw.WriteLine("await using __defer = new goscript.AsyncDisposableStack();")
+				} else {
+					c.tsw.WriteLine("using cleanup = new goscript.DisposableStack();")
+				}
+				c.nextBlockNeedsDefer = false
+			}
+
 			// write method body without outer braces
 			for _, stmt := range decl.Body.List {
 				if err := c.WriteStmt(stmt); err != nil {
+					c.inAsyncFunction = previousAsyncState // Restore state before returning error
 					return fmt.Errorf("failed to write statement in function body: %w", err)
 				}
 			}
 			c.tsw.Indent(-1)
 			c.tsw.WriteLine("}")
+			
+			// Restore previous async state
+			c.inAsyncFunction = previousAsyncState
 			return nil
 		}
 	}
 	// no named receiver, write whole body
 	if err := c.WriteStmt(decl.Body); err != nil {
+		c.inAsyncFunction = previousAsyncState // Restore state before returning error
 		return fmt.Errorf("failed to write function body: %w", err)
 	}
+	
+	// Restore previous async state
+	c.inAsyncFunction = previousAsyncState
 	return nil
 }
 
@@ -254,3 +470,67 @@ func (c *GoToTSCompiler) WriteImportSpec(a *ast.ImportSpec) {
 
 	c.tsw.WriteImport(impName, importPath)
 }
+
+// WriteInterfaceMethodSignature writes a TypeScript interface method signature from a Go ast.Field.
+func (c *GoToTSCompiler) WriteInterfaceMethodSignature(field *ast.Field) error {
+	if len(field.Names) == 0 {
+		// Should not happen for named methods in an interface, but handle defensively
+		return fmt.Errorf("interface method field has no name")
+	}
+
+	methodName := field.Names[0]
+	funcType, ok := field.Type.(*ast.FuncType)
+	if !ok {
+		// Should not happen for valid interface methods, but handle defensively
+		c.tsw.WriteCommentInline("unexpected interface method type")
+		return fmt.Errorf("interface method type is not a FuncType")
+	}
+
+	// Write method name
+	c.WriteIdentValue(methodName)
+
+	// Write parameter list (name: type)
+	c.tsw.WriteLiterally("(")
+	if funcType.Params != nil {
+		for i, param := range funcType.Params.List {
+			if i > 0 {
+				c.tsw.WriteLiterally(", ")
+			}
+			// Determine parameter name
+			paramName := fmt.Sprintf("_p%d", i) // Default placeholder
+			if len(param.Names) > 0 && param.Names[0].Name != "" && param.Names[0].Name != "_" {
+				paramName = param.Names[0].Name
+			}
+			c.tsw.WriteLiterally(paramName)
+			c.tsw.WriteLiterally(": ")
+			c.WriteTypeExpr(param.Type)
+		}
+	}
+	c.tsw.WriteLiterally(")")
+
+	// Write return type
+	// Use WriteFuncType's logic for return types, but without the async handling
+	if funcType.Results != nil && len(funcType.Results.List) > 0 {
+		c.tsw.WriteLiterally(": ")
+		if len(funcType.Results.List) == 1 && len(funcType.Results.List[0].Names) == 0 {
+			// Single unnamed return type
+			c.WriteTypeExpr(funcType.Results.List[0].Type)
+		} else {
+			// Multiple or named return types -> tuple
+			c.tsw.WriteLiterally("[")
+			for i, result := range funcType.Results.List {
+				if i > 0 {
+					c.tsw.WriteLiterally(", ")
+				}
+				c.WriteTypeExpr(result.Type)
+			}
+			c.tsw.WriteLiterally("]")
+		}
+	} else {
+		// No return value -> void
+		c.tsw.WriteLiterally(": void")
+	}
+
+	c.tsw.WriteLine(";") // Semicolon at the end of the method signature
+	return nil
+}

package/compiler/compile_stmt.go

@@ -28,6 +28,10 @@ func (c *GoToTSCompiler) WriteStmt(a ast.Stmt) error {
 		if err := c.WriteStmtReturn(exp); err != nil {
 			return fmt.Errorf("failed to write return statement: %w", err)
 		}
+	case *ast.DeferStmt:
+		if err := c.WriteDeferStmt(exp); err != nil {
+			return fmt.Errorf("failed to write defer statement: %w", err)
+		}
 	case *ast.IfStmt:
 		if err := c.WriteStmtIf(exp); err != nil {
 			return fmt.Errorf("failed to write if statement: %w", err)
@@ -125,12 +129,70 @@ func (c *GoToTSCompiler) WriteStmt(a ast.Stmt) error {
 		if err := c.WriteStmtSelect(exp); err != nil {
 			return fmt.Errorf("failed to write select statement: %w", err)
 		}
+	case *ast.BranchStmt:
+		// Handle break and continue statements
+		switch exp.Tok {
+		case token.BREAK:
+			c.tsw.WriteLine("break") // No semicolon needed
+		case token.CONTINUE:
+			c.tsw.WriteLine("continue") // No semicolon needed
+		default:
+			c.tsw.WriteCommentLine(fmt.Sprintf("unhandled branch statement token: %s", exp.Tok.String()))
+		}
 	default:
 		c.tsw.WriteCommentLine(fmt.Sprintf("unknown statement: %s\n", litter.Sdump(a)))
 	}
 	return nil
 }
 
+// WriteDeferStmt writes a defer statement using TypeScript's DisposableStack.
+func (c *GoToTSCompiler) WriteDeferStmt(exp *ast.DeferStmt) error {
+	// Check if deferred call contains async operations
+	hasAsyncOps := c.containsAsyncOperations(exp.Call)
+
+	// Choose the right stack variable and async modifier
+	stackVar := "cleanup"
+	asyncPrefix := ""
+
+	if c.inAsyncFunction {
+		stackVar = "__defer"
+		if hasAsyncOps {
+			asyncPrefix = "async "
+		}
+	}
+
+	c.tsw.WriteLiterally(fmt.Sprintf("%s.defer(%s() => {", stackVar, asyncPrefix))
+	c.tsw.Indent(1)
+	c.tsw.WriteLine("")
+
+	// Write the deferred call or inline the body when it's an immediately-invoked
+	// function literal (defer func(){ ... }()).
+	if funcLit, ok := exp.Call.Fun.(*ast.FuncLit); ok && len(exp.Call.Args) == 0 {
+		// Inline the function literal's body to avoid nested arrow invocation.
+		prevAsyncState := c.inAsyncFunction
+		c.inAsyncFunction = hasAsyncOps
+
+		for _, stmt := range funcLit.Body.List {
+			if err := c.WriteStmt(stmt); err != nil {
+				c.inAsyncFunction = prevAsyncState
+				return fmt.Errorf("failed to write statement in deferred function body: %w", err)
+			}
+		}
+
+		c.inAsyncFunction = prevAsyncState
+	} else {
+		// Fallback: write the call expression as-is.
+		if err := c.WriteValueExpr(exp.Call); err != nil {
+			return fmt.Errorf("failed to write deferred call: %w", err)
+		}
+	}
+
+	c.tsw.Indent(-1)
+	c.tsw.WriteLine("});")
+
+	return nil
+}
+
 // WriteStmtSelect writes a select statement.
 func (c *GoToTSCompiler) WriteStmtSelect(exp *ast.SelectStmt) error {
 	// This is our implementation of the select statement, which will use Promise.race
@@ -435,10 +497,12 @@ func (s *GoToTSCompiler) WriteStmtIf(exp *ast.IfStmt) error {
 		s.tsw.WriteLiterally(" else ")
 		switch elseStmt := exp.Else.(type) {
 		case *ast.BlockStmt:
+			// Always pass false for suppressNewline here
 			if err := s.WriteStmtBlock(elseStmt, false); err != nil {
 				return fmt.Errorf("failed to write else block statement in if statement: %w", err)
 			}
 		case *ast.IfStmt:
+			// Recursive call handles its own block formatting
 			if err := s.WriteStmtIf(elseStmt); err != nil {
 				return fmt.Errorf("failed to write else if statement in if statement: %w", err)
 			}
@@ -482,6 +546,16 @@ func (c *GoToTSCompiler) WriteStmtBlock(exp *ast.BlockStmt, suppressNewline bool
 	c.tsw.WriteLine("{")
 	c.tsw.Indent(1)
 
+	// Add "using" statement if needed
+	if c.nextBlockNeedsDefer {
+		if c.inAsyncFunction {
+			c.tsw.WriteLine("await using __defer = new goscript.AsyncDisposableStack();")
+		} else {
+			c.tsw.WriteLine("using cleanup = new goscript.DisposableStack();")
+		}
+		c.nextBlockNeedsDefer = false
+	}
+
 	// Prepare line info
 	var file *token.File
 	if c.pkg != nil && c.pkg.Fset != nil && exp.Lbrace.IsValid() {
@@ -775,32 +849,6 @@ func (c *GoToTSCompiler) writeChannelReceiveWithOk(lhs []ast.Expr, unaryExpr *as
 
 func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 	// writeTypeAssertion handles multi-variable assignment from a type assertion.
-	writeTypeAssertion := func(typeAssertExpr *ast.TypeAssertExpr) error {
-		interfaceExpr := typeAssertExpr.X
-		assertedType := typeAssertExpr.Type
-
-		// Write the TypeScript code for the type assertion.
-		c.tsw.WriteLiterally("let ok: boolean = (")
-		if err := c.WriteValueExpr(interfaceExpr); err != nil {
-			return fmt.Errorf("failed to write interface expression in type assertion (ok check): %w", err)
-		}
-		c.tsw.WriteLiterally(" as any) satisfies ")
-		c.WriteTypeExpr(assertedType)
-		c.tsw.WriteLine("")
-
-		c.tsw.WriteLiterally("let assertedValue: ")
-		c.WriteTypeExpr(assertedType)
-		c.tsw.WriteLiterally(" | null = ok ? (")
-		if err := c.WriteValueExpr(interfaceExpr); err != nil {
-			return fmt.Errorf("failed to write interface expression in type assertion (value assignment): %w", err)
-		}
-		c.tsw.WriteLiterally(" as ")
-		c.WriteTypeExpr(assertedType)
-		c.tsw.WriteLiterally(") : null")
-		c.tsw.WriteLine("")
-
-		return nil
-	}
 
 	// writeMultiVarAssignFromCall handles multi-variable assignment from a single function call.
 	writeMultiVarAssignFromCall := func(lhs []ast.Expr, callExpr *ast.CallExpr, tok token.Token) error {
@@ -982,7 +1030,7 @@ func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 	if len(exp.Lhs) > 1 && len(exp.Rhs) == 1 {
 		rhsExpr := exp.Rhs[0]
 		if typeAssertExpr, ok := rhsExpr.(*ast.TypeAssertExpr); ok {
-			return writeTypeAssertion(typeAssertExpr)
+			return c.writeTypeAssertion(exp.Lhs, typeAssertExpr, exp.Tok)
 		} else if indexExpr, ok := rhsExpr.(*ast.IndexExpr); ok {
 			// Check if this is a map lookup (comma-ok idiom)
 			if len(exp.Lhs) == 2 {
@@ -1458,41 +1506,104 @@ func (c *GoToTSCompiler) WriteStmtRange(exp *ast.RangeStmt) error {
 	return fmt.Errorf("unsupported range loop type: %T", underlying)
 }
 
+// WriteStmtSend writes a channel send statement (ch <- value).
+func (c *GoToTSCompiler) WriteStmtSend(exp *ast.SendStmt) error {
+	// Translate ch <- value to await ch.send(value)
+	c.tsw.WriteLiterally("await ")
+	if err := c.WriteValueExpr(exp.Chan); err != nil { // The channel expression
+		return fmt.Errorf("failed to write channel expression in send statement: %w", err)
+	}
+	c.tsw.WriteLiterally(".send(")
+	if err := c.WriteValueExpr(exp.Value); err != nil { // The value expression
+		return fmt.Errorf("failed to write value expression in send statement: %w", err)
+	}
+	c.tsw.WriteLiterally(")")
+	c.tsw.WriteLine("") // Add newline after the statement
+	return nil
+}
+
 // isSlice returns true if the underlying type is a slice.
 func isSlice(typ gtypes.Type) bool {
 	_, ok := typ.(*gtypes.Slice)
 	return ok
 }
 
-// isLHSMapIndex returns true if the expression is an index expression on a map type.
-func isLHSMapIndex(expr ast.Expr, pkg *packages.Package) bool {
-	if pkg == nil || pkg.TypesInfo == nil {
-		return false
+// writeTypeAssertion handles multi-variable assignment from a type assertion.
+func (c *GoToTSCompiler) writeTypeAssertion(lhs []ast.Expr, typeAssertExpr *ast.TypeAssertExpr, tok token.Token) error {
+	interfaceExpr := typeAssertExpr.X
+	assertedType := typeAssertExpr.Type
+
+	// Ensure LHS has exactly two expressions (value and ok)
+	if len(lhs) != 2 {
+		return fmt.Errorf("type assertion assignment requires exactly 2 variables on LHS, got %d", len(lhs))
 	}
-	indexExpr, ok := expr.(*ast.IndexExpr)
-	if !ok {
-		return false
+
+	// Get variable names, handling blank identifiers
+	valueIsBlank := false
+	okIsBlank := false
+	var valueName string
+	var okName string
+
+	if valIdent, ok := lhs[0].(*ast.Ident); ok {
+		if valIdent.Name == "_" {
+			valueIsBlank = true
+		} else {
+			valueName = valIdent.Name
+		}
+	} else {
+		return fmt.Errorf("unhandled LHS expression type for value in type assertion: %T", lhs[0])
 	}
-	tv, ok := pkg.TypesInfo.Types[indexExpr.X]
-	if !ok || tv.Type == nil {
-		return false
+
+	if okIdent, ok := lhs[1].(*ast.Ident); ok {
+		if okIdent.Name == "_" {
+			okIsBlank = true
+		} else {
+			okName = okIdent.Name
+		}
+	} else {
+		return fmt.Errorf("unhandled LHS expression type for ok in type assertion: %T", lhs[1])
 	}
-	_, isMap := tv.Type.Underlying().(*gtypes.Map)
-	return isMap
-}
 
-// WriteStmtSend writes a channel send statement (ch <- value).
-func (c *GoToTSCompiler) WriteStmtSend(exp *ast.SendStmt) error {
-	// Translate ch <- value to await ch.send(value)
-	c.tsw.WriteLiterally("await ")
-	if err := c.WriteValueExpr(exp.Chan); err != nil { // The channel expression
-		return fmt.Errorf("failed to write channel expression in send statement: %w", err)
+	// Get the type name string for the asserted type
+	typeName := c.getTypeNameString(assertedType)
+
+	// Generate the destructuring assignment
+	if tok == token.DEFINE {
+		c.tsw.WriteLiterally("let ")
+	} else {
+		// We must wrap in parenthesis.
+		c.tsw.WriteLiterally("(")
 	}
-	c.tsw.WriteLiterally(".send(")
-	if err := c.WriteValueExpr(exp.Value); err != nil { // The value expression
-		return fmt.Errorf("failed to write value expression in send statement: %w", err)
+
+	c.tsw.WriteLiterally("{ ")
+	// Dynamically build the destructuring pattern
+	parts := []string{}
+	if !valueIsBlank {
+		parts = append(parts, fmt.Sprintf("value: %s", valueName))
+	}
+	if !okIsBlank {
+		parts = append(parts, fmt.Sprintf("ok: %s", okName))
+	}
+	c.tsw.WriteLiterally(strings.Join(parts, ", "))
+	c.tsw.WriteLiterally(" } = goscript.typeAssert<")
+
+	// Write the asserted type for the generic
+	c.WriteTypeExpr(assertedType)
+	c.tsw.WriteLiterally(">(")
+
+	// Write the interface expression
+	if err := c.WriteValueExpr(interfaceExpr); err != nil {
+		return fmt.Errorf("failed to write interface expression in type assertion call: %w", err)
 	}
+	c.tsw.WriteLiterally(", ")
+	c.tsw.WriteLiterally(fmt.Sprintf("'%s'", typeName))
 	c.tsw.WriteLiterally(")")
+
+	if tok != token.DEFINE {
+		c.tsw.WriteLiterally(")")
+	}
+
 	c.tsw.WriteLine("") // Add newline after the statement
+
 	return nil
 }

package/compiler/writer.go

@@ -54,7 +54,7 @@ func (w *TSCodeWriter) Indent(count int) {
 
 // WriteImport writes a TypeScript import.
 func (w *TSCodeWriter) WriteImport(symbolName, importPath string) {
-	w.WriteLinef("import * as %s from %q;", symbolName, importPath)
+	w.WriteLinef("import * as %s from %q", symbolName, importPath)
 }
 
 // WriteCommentLine writes a comment as a // line.
@@ -78,7 +78,7 @@ func (w *TSCodeWriter) WriteLiterally(literal string) {
 	if w.lineWritten {
 		w.WriteLinePreamble()
 	}
-	w.w.Write([]byte(literal))
+	w.w.Write([]byte(literal)) //nolint:errcheck
 }
 
 // WriteSectionTail writes the end of a section.