goscript 0.0.21 → 0.0.23

package/compiler/stmt-range.go

@@ -0,0 +1,235 @@
+package compiler
+
+import (
+	"fmt"
+	"go/ast"
+	"go/types"
+
+	"github.com/pkg/errors"
+)
+
+// WriteStmtRange translates a Go `for...range` statement (`ast.RangeStmt`)
+// into an equivalent TypeScript loop. The translation depends on the type of
+// the expression being ranged over (`exp.X`), determined using `go/types` info.
+//
+//   - **Maps (`*types.Map`):**
+//     `for k, v := range myMap` becomes `for (const [k_ts, v_ts] of myMap_ts.entries()) { const k = k_ts; const v = v_ts; ...body... }`.
+//     If only `k` or `v` (or neither) is used, the corresponding TypeScript const declaration is adjusted.
+//
+//   - **Strings (`*types.Basic` with `IsString` info):**
+//     `for i, r := range myString` becomes:
+//     `const _runes = $.stringToRunes(myString_ts);`
+//     `for (let i_ts = 0; i_ts < _runes.length; i_ts++) { const r_ts = _runes[i_ts]; ...body... }`.
+//     The index variable `i_ts` uses the Go key variable name if provided (and not `_`).
+//     The rune variable `r_ts` uses the Go value variable name.
+//
+//   - **Integers (`*types.Basic` with `IsInteger` info, Go 1.22+):**
+//     `for i := range N` becomes `for (let i_ts = 0; i_ts < N_ts; i_ts++) { ...body... }`.
+//     `for i, v := range N` becomes `for (let i_ts = 0; i_ts < N_ts; i_ts++) { const v_ts = i_ts; ...body... }`.
+//
+// - **Arrays (`*types.Array`) and Slices (`*types.Slice`):**
+//   - If both key (index) and value are used (`for i, val := range arr`):
+//     `for (let i_ts = 0; i_ts < arr_ts.length; i_ts++) { const val_ts = arr_ts[i_ts]; ...body... }`.
+//   - If only the key (index) is used (`for i := range arr`):
+//     `for (let i_ts = 0; i_ts < arr_ts.length; i_ts++) { ...body... }`.
+//   - If only the value is used (`for _, val := range arr`):
+//     `for (const v_ts of arr_ts) { const val_ts = v_ts; ...body... }`.
+//   - If neither is used (e.g., `for range arr`), a simple index loop `for (let _i = 0; ...)` is generated.
+//     The index variable `i_ts` uses the Go key variable name if provided.
+//
+// Loop variables (`exp.Key`, `exp.Value`) are declared as `const` inside the loop
+// body if they are not blank identifiers (`_`). The loop body (`exp.Body`) is
+// translated using `WriteStmtBlock` (or `WriteStmt` for array/slice with key and value).
+// If the ranged type is not supported, a comment is written, and an error is returned.
+func (c *GoToTSCompiler) WriteStmtRange(exp *ast.RangeStmt) error {
+	// Get the type of the iterable expression
+	iterType := c.pkg.TypesInfo.TypeOf(exp.X)
+	underlying := iterType.Underlying()
+
+	// Handle map types
+	if _, ok := underlying.(*types.Map); ok {
+		// Use for-of with entries() for proper Map iteration
+		c.tsw.WriteLiterally("for (const [k, v] of ")
+		if err := c.WriteValueExpr(exp.X); err != nil {
+			return fmt.Errorf("failed to write range loop map expression: %w", err)
+		}
+		c.tsw.WriteLiterally(".entries()) {")
+		c.tsw.Indent(1)
+		c.tsw.WriteLine("")
+		// If a key variable is provided and is not blank, declare it as a constant
+		if exp.Key != nil {
+			if ident, ok := exp.Key.(*ast.Ident); ok && ident.Name != "_" {
+				c.tsw.WriteLiterally("const ")
+				c.WriteIdent(ident, false)
+				c.tsw.WriteLiterally(" = k")
+				c.tsw.WriteLine("")
+			}
+		}
+		// If a value variable is provided and is not blank, use the value from entries()
+		if exp.Value != nil {
+			if ident, ok := exp.Value.(*ast.Ident); ok && ident.Name != "_" {
+				c.tsw.WriteLiterally("const ")
+				c.WriteIdent(ident, false)
+				c.tsw.WriteLiterally(" = v")
+				c.tsw.WriteLine("")
+			}
+		}
+		// Write the loop body
+		if err := c.WriteStmtBlock(exp.Body, false); err != nil {
+			return fmt.Errorf("failed to write range loop map body: %w", err)
+		}
+		c.tsw.Indent(-1)
+		c.tsw.WriteLine("}")
+		return nil
+	}
+
+	// Handle basic types (string, integer)
+	if basic, ok := underlying.(*types.Basic); ok {
+		if basic.Info()&types.IsString != 0 {
+			// Add a scope to avoid collision of _runes variable
+			c.tsw.WriteLine("{")
+			c.tsw.Indent(1)
+
+			// Convert the string to runes using $.stringToRunes
+			c.tsw.WriteLiterally("const _runes = $.stringToRunes(")
+			if err := c.WriteValueExpr(exp.X); err != nil {
+				return fmt.Errorf("failed to write range loop string conversion expression: %w", err)
+			}
+			c.tsw.WriteLiterally(")")
+			c.tsw.WriteLine("")
+
+			// Determine the index variable name for the generated loop
+			indexVarName := "i" // Default name
+			if exp.Key != nil {
+				if keyIdent, ok := exp.Key.(*ast.Ident); ok && keyIdent.Name != "_" {
+					indexVarName = keyIdent.Name
+				}
+			}
+			c.tsw.WriteLiterallyf("for (let %s = 0; %s < _runes.length; %s++) {", indexVarName, indexVarName, indexVarName)
+			c.tsw.Indent(1)
+			c.tsw.WriteLine("")
+			// Declare value if provided and not blank
+			if exp.Value != nil {
+				if ident, ok := exp.Value.(*ast.Ident); ok && ident.Name != "_" {
+					c.tsw.WriteLiterally("const ")
+					c.WriteIdent(ident, false)
+					c.tsw.WriteLiterally(" = _runes[i]") // TODO: should be indexVarName?
+					c.tsw.WriteLine("")
+				}
+			}
+			if err := c.WriteStmtBlock(exp.Body, false); err != nil {
+				return fmt.Errorf("failed to write range loop string body: %w", err)
+			}
+			c.tsw.Indent(-1)
+			c.tsw.WriteLine("}")
+
+			// outer }
+			c.tsw.Indent(-1)
+			c.tsw.WriteLine("}")
+			return nil
+		} else if basic.Info()&types.IsInteger != 0 {
+			// The value variable is not allowed ranging over an integer.
+			if exp.Value != nil {
+				return errors.Errorf("ranging over an integer supports key variable only (not value variable): %v", exp)
+			}
+
+			// Handle ranging over an integer (Go 1.22+)
+			// Determine the index variable name for the generated loop
+			indexVarName := "_i" // Default name
+			if exp.Key != nil {
+				if keyIdent, ok := exp.Key.(*ast.Ident); ok && keyIdent.Name != "_" {
+					indexVarName = keyIdent.Name
+				}
+			}
+
+			c.tsw.WriteLiterallyf("for (let %s = 0; %s < ", indexVarName, indexVarName)
+			if err := c.WriteValueExpr(exp.X); err != nil { // This is N
+				return fmt.Errorf("failed to write range loop integer expression: %w", err)
+			}
+			c.tsw.WriteLiterallyf("; %s++) ", indexVarName)
+
+			// write body
+			if err := c.WriteStmtBlock(exp.Body, false); err != nil {
+				return fmt.Errorf("failed to write range loop integer body: %w", err)
+			}
+
+			return nil
+		}
+	}
+
+	// Handle array and slice types
+	_, isSlice := underlying.(*types.Slice)
+	_, isArray := underlying.(*types.Array)
+	if isArray || isSlice {
+		// Determine the index variable name for the generated loop
+		indexVarName := "_i" // Default name
+		if exp.Key != nil {
+			if keyIdent, ok := exp.Key.(*ast.Ident); ok && keyIdent.Name != "_" {
+				indexVarName = keyIdent.Name
+			}
+		}
+		// If both key and value are provided, use an index loop and assign both
+		if exp.Key != nil && exp.Value != nil {
+			c.tsw.WriteLiterallyf("for (let %s = 0; %s < $.len(", indexVarName, indexVarName)
+			if err := c.WriteValueExpr(exp.X); err != nil { // Write the expression for the iterable
+				return fmt.Errorf("failed to write range loop array/slice expression (key and value): %w", err)
+			}
+			c.tsw.WriteLiterallyf("); %s++) {", indexVarName)
+			c.tsw.Indent(1)
+			c.tsw.WriteLine("")
+			// Declare value if not blank
+			if ident, ok := exp.Value.(*ast.Ident); ok && ident.Name != "_" {
+				c.tsw.WriteLiterally("const ")
+				c.WriteIdent(ident, false)
+				c.tsw.WriteLiterally(" = ")
+				if err := c.WriteValueExpr(exp.X); err != nil {
+					return fmt.Errorf("failed to write range loop array/slice value expression: %w", err)
+				}
+				c.tsw.WriteLiterallyf("![%s]", indexVarName) // Use indexVarName with not-null assert
+				c.tsw.WriteLine("")
+			}
+			if err := c.WriteStmt(exp.Body); err != nil {
+				return fmt.Errorf("failed to write range loop array/slice body (key and value): %w", err)
+			}
+			c.tsw.Indent(-1)
+			c.tsw.WriteLine("}")
+			return nil
+		} else if exp.Key != nil && exp.Value == nil { // Only key provided
+			c.tsw.WriteLiterallyf("for (let %s = 0; %s < $.len(", indexVarName, indexVarName)
+			// Write the expression for the iterable
+			if err := c.WriteValueExpr(exp.X); err != nil {
+				return fmt.Errorf("failed to write expression for the iterable: %w", err)
+			}
+			c.tsw.WriteLiterallyf("); %s++) {", indexVarName)
+			c.tsw.Indent(1)
+			c.tsw.WriteLine("")
+			if err := c.WriteStmtBlock(exp.Body, false); err != nil {
+				return fmt.Errorf("failed to write range loop array/slice body (only key): %w", err)
+			}
+			c.tsw.Indent(-1)
+			c.tsw.WriteLine("}")
+			return nil
+		} else if exp.Key == nil && exp.Value != nil { // Only value provided
+			// I think this is impossible. See for_range_value_only test.
+			return errors.Errorf("unexpected value without key in for range expression: %v", exp)
+		} else {
+			// Fallback: simple index loop without declaring range variables, use _i
+			indexVarName := "_i"
+			c.tsw.WriteLiterallyf("for (let %s = 0; %s < $.len(", indexVarName, indexVarName)
+			if err := c.WriteValueExpr(exp.X); err != nil {
+				return fmt.Errorf("failed to write range loop array/slice length expression (fallback): %w", err)
+			}
+			c.tsw.WriteLiterallyf("); %s++) {", indexVarName)
+			c.tsw.Indent(1)
+			c.tsw.WriteLine("")
+			if err := c.WriteStmtBlock(exp.Body, false); err != nil {
+				return fmt.Errorf("failed to write range loop array/slice body (fallback): %w", err)
+			}
+			c.tsw.Indent(-1)
+			c.tsw.WriteLine("}")
+			return nil
+		}
+	}
+
+	return errors.Errorf("unsupported range loop type: %T for expression %v", underlying, exp)
+}

package/compiler/stmt-select.go

@@ -0,0 +1,211 @@
+package compiler
+
+import (
+	"fmt"
+	"go/ast"
+	"go/token"
+
+	"github.com/pkg/errors"
+)
+
+// WriteStmtSelect translates a Go `select` statement into an asynchronous
+// TypeScript operation using the `$.selectStatement` runtime helper.
+// Go's `select` provides non-deterministic choice over channel operations.
+// This is emulated by constructing an array of `SelectCase` objects, one for
+// each `case` in the Go `select`, and passing it to `$.selectStatement`.
+//
+// Each `SelectCase` object includes:
+//   - `id`: A unique identifier for the case.
+//   - `isSend`: `true` for send operations (`case ch <- val:`), `false` for receives.
+//   - `channel`: The TypeScript channel object.
+//   - `value` (for sends): The value being sent.
+//   - `onSelected: async (result) => { ... }`: A callback executed when this case
+//     is chosen. `result` contains `{ value, ok }` for receives.
+//   - Inside `onSelected`, assignments for receive operations (e.g., `v := <-ch`,
+//     `v, ok := <-ch`) are handled by declaring/assigning variables from `result.value`
+//     and `result.ok`.
+//   - The original Go case body is then translated within this callback.
+//
+// A `default` case in Go `select` is translated to a `SelectCase` with `id: -1`
+// and its body in the `onSelected` handler. The `$.selectStatement` helper
+// is informed if a default case exists.
+// The entire `$.selectStatement(...)` call is `await`ed because channel
+// operations are asynchronous in the TypeScript model.
+func (c *GoToTSCompiler) WriteStmtSelect(exp *ast.SelectStmt) error {
+	// This is our implementation of the select statement, which will use Promise.race
+	// to achieve the same semantics as Go's select statement.
+
+	// Variable to track whether we have a default case
+	hasDefault := false
+
+	// Start the selectStatement call and the array literal
+	c.tsw.WriteLiterally("await $.selectStatement(")
+	c.tsw.WriteLine("[") // Put bracket on new line
+	c.tsw.Indent(1)
+
+	// For each case clause, generate a SelectCase object directly into the array literal
+	for i, stmt := range exp.Body.List {
+		if commClause, ok := stmt.(*ast.CommClause); ok {
+			if commClause.Comm == nil {
+				// This is a default case
+				hasDefault = true
+				// Add a SelectCase object for the default case with a special ID
+				c.tsw.WriteLiterally("{") // Start object literal
+				c.tsw.Indent(1)
+				c.tsw.WriteLine("")
+				c.tsw.WriteLiterally("id: -1,") // Special ID for default case
+				c.tsw.WriteLine("")
+				c.tsw.WriteLiterally("isSend: false,") // Default case is neither send nor receive, but needs a value
+				c.tsw.WriteLine("")
+				c.tsw.WriteLiterally("channel: null,") // No channel for default case
+				c.tsw.WriteLine("")
+				c.tsw.WriteLiterally("onSelected: async (result) => {") // Mark as async because case body might contain await
+				c.tsw.Indent(1)
+				c.tsw.WriteLine("")
+				// Write the case body
+				for _, bodyStmt := range commClause.Body {
+					if err := c.WriteStmt(bodyStmt); err != nil {
+						return fmt.Errorf("failed to write statement in select default case body (onSelected): %w", err)
+					}
+				}
+				c.tsw.Indent(-1)
+				c.tsw.WriteLine("}") // Close onSelected handler
+				c.tsw.Indent(-1)
+				c.tsw.WriteLiterally("},") // Close SelectCase object and add comma
+				c.tsw.WriteLine("")
+
+				continue
+			}
+
+			// Generate a unique ID for this case
+			caseID := i
+
+			// Start writing the SelectCase object
+			c.tsw.WriteLiterally("{") // Start object literal
+			c.tsw.Indent(1)
+			c.tsw.WriteLine("")
+			c.tsw.WriteLiterallyf("id: %d,", caseID)
+			c.tsw.WriteLine("")
+
+			// Handle different types of comm statements
+			switch comm := commClause.Comm.(type) {
+			case *ast.AssignStmt:
+				// This is a receive operation with assignment: case v := <-ch: or case v, ok := <-ch:
+				if len(comm.Rhs) == 1 {
+					if unaryExpr, ok := comm.Rhs[0].(*ast.UnaryExpr); ok && unaryExpr.Op == token.ARROW {
+						// It's a receive operation
+						c.tsw.WriteLiterally("isSend: false,")
+						c.tsw.WriteLine("")
+						c.tsw.WriteLiterally("channel: ")
+						if err := c.WriteValueExpr(unaryExpr.X); err != nil { // The channel expression
+							return fmt.Errorf("failed to write channel expression in select receive case: %w", err)
+						}
+						c.tsw.WriteLiterally(",")
+						c.tsw.WriteLine("")
+					} else {
+						c.tsw.WriteCommentLinef("unhandled RHS in select assignment case: %T", comm.Rhs[0])
+					}
+				} else {
+					c.tsw.WriteCommentLinef("unhandled RHS count in select assignment case: %d", len(comm.Rhs))
+				}
+			case *ast.ExprStmt:
+				// This is a simple receive: case <-ch:
+				if unaryExpr, ok := comm.X.(*ast.UnaryExpr); ok && unaryExpr.Op == token.ARROW {
+					c.tsw.WriteLiterally("isSend: false,")
+					c.tsw.WriteLine("")
+					c.tsw.WriteLiterally("channel: ")
+					if err := c.WriteValueExpr(unaryExpr.X); err != nil { // The channel expression
+						return fmt.Errorf("failed to write channel expression in select receive case: %w", err)
+					}
+					c.tsw.WriteLiterally(",")
+					c.tsw.WriteLine("")
+				} else {
+					c.tsw.WriteCommentLinef("unhandled expression in select case: %T", comm.X)
+				}
+			case *ast.SendStmt:
+				// This is a send operation: case ch <- v:
+				c.tsw.WriteLiterally("isSend: true,")
+				c.tsw.WriteLine("")
+				c.tsw.WriteLiterally("channel: ")
+				if err := c.WriteValueExpr(comm.Chan); err != nil { // The channel expression
+					return fmt.Errorf("failed to write channel expression in select send case: %w", err)
+				}
+				c.tsw.WriteLiterally(",")
+				c.tsw.WriteLine("")
+				c.tsw.WriteLiterally("value: ")
+				if err := c.WriteValueExpr(comm.Value); err != nil { // The value expression
+					return fmt.Errorf("failed to write value expression in select send case: %w", err)
+				}
+				c.tsw.WriteLiterally(",")
+				c.tsw.WriteLine("")
+			default:
+				c.tsw.WriteCommentLinef("unhandled comm statement in select case: %T", comm)
+			}
+
+			// Add the onSelected handler to execute the case body after the select resolves
+			c.tsw.WriteLiterally("onSelected: async (result) => {") // Mark as async because case body might contain await
+			c.tsw.Indent(1)
+			c.tsw.WriteLine("")
+
+			// Handle assignment for channel receives if needed (inside the onSelected handler)
+			if assignStmt, ok := commClause.Comm.(*ast.AssignStmt); ok {
+				// This is a receive operation with assignment
+				if len(assignStmt.Lhs) == 1 {
+					// Simple receive: case v := <-ch:
+					valIdent, ok := assignStmt.Lhs[0].(*ast.Ident)
+					if ok && valIdent.Name != "_" { // Check for blank identifier
+						c.tsw.WriteLiterally("const ")
+						c.WriteIdent(valIdent, false)
+						c.tsw.WriteLiterally(" = result.value")
+						c.tsw.WriteLine("")
+					}
+				} else if len(assignStmt.Lhs) == 2 {
+					// Receive with ok: case v, ok := <-ch:
+					valIdent, valOk := assignStmt.Lhs[0].(*ast.Ident)
+					okIdent, okOk := assignStmt.Lhs[1].(*ast.Ident)
+
+					if valOk && valIdent.Name != "_" {
+						c.tsw.WriteLiterally("const ")
+						c.WriteIdent(valIdent, false)
+						c.tsw.WriteLiterally(" = result.value")
+						c.tsw.WriteLine("")
+					}
+
+					if okOk && okIdent.Name != "_" {
+						c.tsw.WriteLiterally("const ")
+						c.WriteIdent(okIdent, false)
+						c.tsw.WriteLiterally(" = result.ok")
+						c.tsw.WriteLine("")
+					}
+				}
+			}
+			// Note: Simple receive (case <-ch:) and send (case ch <- v:) don't require assignment here,
+			// as the operation was already performed by selectReceive/selectSend and the result is in 'result'.
+
+			// Write the case body
+			for _, bodyStmt := range commClause.Body {
+				if err := c.WriteStmt(bodyStmt); err != nil {
+					return fmt.Errorf("failed to write statement in select case body (onSelected): %w", err)
+				}
+			}
+
+			c.tsw.Indent(-1)
+			c.tsw.WriteLine("}") // Close onSelected handler
+			c.tsw.Indent(-1)
+			c.tsw.WriteLiterally("},") // Close SelectCase object and add comma
+			c.tsw.WriteLine("")
+
+		} else {
+			return errors.Errorf("unknown statement in select body: %T", stmt)
+		}
+	}
+
+	// Close the array literal and the selectStatement call
+	c.tsw.Indent(-1)
+	c.tsw.WriteLiterally("], ")
+	c.tsw.WriteLiterallyf("%t", hasDefault)
+	c.tsw.WriteLiterally(")")
+	c.tsw.WriteLine("")
+
+	return nil
+}

package/compiler/stmt-type-switch.go

@@ -0,0 +1,147 @@
+package compiler
+
+import (
+	"fmt"
+	"go/ast"
+
+	"github.com/pkg/errors"
+)
+
+// WriteStmtTypeSwitch translates a Go `type switch` statement (`ast.TypeSwitchStmt`)
+// into its TypeScript equivalent using the `$.typeSwitch` helper.
+func (c *GoToTSCompiler) WriteStmtTypeSwitch(stmt *ast.TypeSwitchStmt) error {
+	// Outer block for scoping Init variable
+	if stmt.Init != nil {
+		c.tsw.WriteLine("{")
+		c.tsw.Indent(1)
+		if err := c.WriteStmt(stmt.Init); err != nil {
+			return fmt.Errorf("failed to write type switch init statement: %w", err)
+		}
+	}
+
+	// Extract the subject expression and case variable identifier
+	var subjectExpr ast.Expr
+	var caseVarIdent *ast.Ident // The variable in 'v := x.(type)'
+
+	switch assignNode := stmt.Assign.(type) {
+	case *ast.AssignStmt: // v := x.(type)
+		if len(assignNode.Lhs) != 1 || len(assignNode.Rhs) != 1 {
+			return errors.Errorf("TypeSwitchStmt AssignStmt: expected 1 LHS and 1 RHS, got %d and %d", len(assignNode.Lhs), len(assignNode.Rhs))
+		}
+		ident, ok := assignNode.Lhs[0].(*ast.Ident)
+		if !ok {
+			return errors.Errorf("TypeSwitchStmt AssignStmt LHS is not *ast.Ident: %T", assignNode.Lhs[0])
+		}
+		caseVarIdent = ident
+		typeAssert, ok := assignNode.Rhs[0].(*ast.TypeAssertExpr)
+		if !ok {
+			return errors.Errorf("TypeSwitchStmt AssignStmt RHS is not *ast.TypeAssertExpr: %T", assignNode.Rhs[0])
+		}
+		if typeAssert.Type != nil {
+			return errors.Errorf("TypeSwitchStmt AssignStmt TypeAssertExpr.Type is not nil")
+		}
+		subjectExpr = typeAssert.X
+	case *ast.ExprStmt: // x.(type)
+		typeAssert, ok := assignNode.X.(*ast.TypeAssertExpr)
+		if !ok {
+			return errors.Errorf("TypeSwitchStmt ExprStmt.X is not *ast.TypeAssertExpr: %T", assignNode.X)
+		}
+		if typeAssert.Type != nil {
+			return errors.Errorf("TypeSwitchStmt ExprStmt TypeAssertExpr.Type is not nil")
+		}
+		subjectExpr = typeAssert.X
+	default:
+		return errors.Errorf("unknown Assign type in TypeSwitchStmt: %T", stmt.Assign)
+	}
+
+	// Build the array of case configurations for $.typeSwitch
+	c.tsw.WriteLiterally("$.typeSwitch(")
+	if err := c.WriteValueExpr(subjectExpr); err != nil {
+		c.tsw.Indent(-1)
+		c.tsw.WriteLine("} // End TypeSwitchStmt due to error in subject")
+		return fmt.Errorf("failed to write subject expression in type switch: %w", err)
+	}
+
+	// case list
+	c.tsw.WriteLiterally(", [")
+
+	stmtBodyList := stmt.Body.List
+	var defaultCaseBody []ast.Stmt
+
+	for i, caseClauseStmt := range stmtBodyList {
+		caseClause, ok := caseClauseStmt.(*ast.CaseClause)
+		if !ok {
+			return errors.Errorf("unexpected statement in TypeSwitchStmt Body: not *ast.CaseClause but %T", caseClauseStmt)
+		}
+
+		if len(caseClause.List) == 0 { // Default case
+			defaultCaseBody = caseClause.Body
+			continue // Process default case after type cases
+		}
+
+		// Type case(s)
+		if i != 0 {
+			c.tsw.WriteLiterally(",")
+			c.tsw.WriteLine("")
+		}
+
+		c.tsw.WriteLiterally("{ types: [")
+		for j, typeExpr := range caseClause.List {
+			if j > 0 {
+				c.tsw.WriteLiterally(", ")
+			}
+			c.writeTypeDescription(typeExpr) // Descriptor for $.is or $.typeAssert
+		}
+		c.tsw.WriteLiterally("], body: (")
+
+		// Add case variable if it exists and is not '_'
+		if caseVarIdent != nil && caseVarIdent.Name != "_" {
+			c.WriteIdent(caseVarIdent, false) // isDeclaration = false for the parameter
+			// Note: TypeScript type inference should handle the parameter type based on the case type(s)
+		}
+
+		c.tsw.WriteLiterally(") => {")
+
+		caseClauseBody := caseClause.Body
+		if len(caseClauseBody) != 0 {
+			c.tsw.Indent(1)
+			c.tsw.WriteLine("")
+		}
+
+		for _, bodyStmt := range caseClauseBody {
+			if err := c.WriteStmt(bodyStmt); err != nil {
+				return fmt.Errorf("failed to write statement in type switch case body: %w", err)
+			}
+		}
+
+		if len(caseClauseBody) != 0 {
+			c.tsw.Indent(-1)
+		}
+		c.tsw.WriteLiterally("}") // Close case body function
+		c.tsw.WriteLiterally("}") // Close case object
+	}
+
+	c.tsw.WriteLiterally("]") // Close cases array
+
+	// Add default case function if it exists
+	if len(defaultCaseBody) != 0 {
+		c.tsw.WriteLiterally(", () => {")
+		c.tsw.Indent(1)
+		c.tsw.WriteLine("")
+		for _, bodyStmt := range defaultCaseBody {
+			if err := c.WriteStmt(bodyStmt); err != nil {
+				return fmt.Errorf("failed to write statement in type switch default case body: %w", err)
+			}
+		}
+		c.tsw.Indent(-1)
+		c.tsw.WriteLiterally("}") // Close default case function
+	}
+
+	c.tsw.WriteLine(")") // Close $.typeSwitch call
+	if stmt.Init != nil {
+		c.tsw.Indent(-1)
+		c.tsw.WriteLine("}") // Close outer block
+	}
+
+	return nil
+}