goscript 0.0.58 → 0.0.59

package/compiler/composite-lit.go

@@ -79,11 +79,7 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 			// Check if it's a []byte literal
 			isByteSliceLiteral := false
 			if typInfo := c.pkg.TypesInfo.TypeOf(exp.Type); typInfo != nil {
-				if sliceT, ok := typInfo.Underlying().(*types.Slice); ok {
-					if basicElem, ok := sliceT.Elem().(*types.Basic); ok && basicElem.Kind() == types.Uint8 {
-						isByteSliceLiteral = true
-					}
-				}
+				isByteSliceLiteral = c.isByteSliceType(typInfo)
 			}
 
 			if isByteSliceLiteral {
@@ -287,96 +283,12 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 
 			if isStructLiteral && structType != nil {
 				// --- Struct Literal Handling (Nested) ---
-				directFields := make(map[string]ast.Expr)
-				embeddedFields := make(map[string]map[string]ast.Expr) // map[EmbeddedPropName]map[FieldName]ValueExpr
-				explicitEmbedded := make(map[string]ast.Expr)          // Tracks explicitly initialized embedded structs
-
-				// Pre-populate embeddedFields map keys using the correct property name
-				for i := 0; i < structType.NumFields(); i++ {
-					field := structType.Field(i)
-					if field.Anonymous() {
-						fieldType := field.Type()
-						if ptr, ok := fieldType.(*types.Pointer); ok {
-							fieldType = ptr.Elem()
-						}
-						if named, ok := fieldType.(*types.Named); ok {
-							// Use the type name as the property name in TS
-							embeddedPropName := named.Obj().Name()
-							embeddedFields[embeddedPropName] = make(map[string]ast.Expr)
-						}
-					}
-				}
-
-				// Group literal elements by direct vs embedded fields
-				for _, elt := range exp.Elts {
-					kv, ok := elt.(*ast.KeyValueExpr)
-					if !ok {
-						continue
-					} // Skip non-key-value
-					keyIdent, ok := kv.Key.(*ast.Ident)
-					if !ok {
-						continue
-					} // Skip non-ident keys
-					keyName := keyIdent.Name
-
-					// Check if this is an explicit embedded struct initialization
-					// e.g., Person: Person{...} or Person: personVar
-					if _, isEmbedded := embeddedFields[keyName]; isEmbedded {
-						// This is an explicit initialization of an embedded struct
-						explicitEmbedded[keyName] = kv.Value
-						continue
-					}
-
-					isDirectField := false
-					for i := range structType.NumFields() {
-						field := structType.Field(i)
-						if field.Name() == keyName {
-							isDirectField = true
-							directFields[keyName] = kv.Value
-							break
-						}
-					}
-
-					// For anonymous structs, all fields are direct fields
-					if isAnonymousStruct {
-						directFields[keyName] = kv.Value
-						isDirectField = true
-					}
-
-					// If not a direct field, return an error
-					if !isDirectField {
-						// This field was not found as a direct field in the struct
-						return fmt.Errorf("field %s not found in type %s for composite literal",
-							keyName, litType.String())
-					}
-				}
-
-				// Handle the case where an anonymous struct has values without keys
-				// This block processes non-key-value elements and associates them with struct fields.
-				if isAnonymousStruct && len(exp.Elts) > 0 && len(directFields) == 0 {
-					// Check if any elements in the composite literal are not key-value pairs.
-					hasNonKeyValueElts := false
-					for _, elt := range exp.Elts {
-						// If an element is not a key-value pair, set the flag to true.
-						if _, isKV := elt.(*ast.KeyValueExpr); !isKV {
-							hasNonKeyValueElts = true
-							break
-						}
-					}
-
-					if hasNonKeyValueElts {
-						// Get the fields from the struct type
-						for i := 0; i < structType.NumFields(); i++ {
-							field := structType.Field(i)
-							// If we have a value for this field position
-							if i < len(exp.Elts) {
-								// Check if it's not a key-value pair
-								if _, isKV := exp.Elts[i].(*ast.KeyValueExpr); !isKV {
-									directFields[field.Name()] = exp.Elts[i]
-								}
-							}
-						}
-					}
+				// Categorize fields into direct, embedded, and explicit embedded
+				directFields, embeddedFields, explicitEmbedded, err := c.categorizeStructFields(
+					exp, structType, litType, isAnonymousStruct,
+				)
+				if err != nil {
+					return err
 				}
 
 				// Write the object literal
@@ -388,107 +300,9 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 					c.tsw.WriteLiterally("({")
 				}
 
-				firstFieldWritten := false
-
-				// Write direct fields that aren't embedded struct names
-				directKeys := make([]string, 0, len(directFields))
-				for k := range directFields {
-					// Skip embedded struct names - we'll handle those separately
-					if _, isEmbedded := embeddedFields[k]; !isEmbedded {
-						directKeys = append(directKeys, k)
-					}
-				}
-				slices.Sort(directKeys)
-				for _, keyName := range directKeys {
-					if firstFieldWritten {
-						c.tsw.WriteLiterally(", ")
-					}
-
-					// Convert field name for protobuf types
-					fieldName := c.convertProtobufFieldNameInLiteral(keyName, litType)
-
-					c.tsw.WriteLiterally(fieldName)
-					c.tsw.WriteLiterally(": ")
-					if err := c.WriteVarRefedValue(directFields[keyName]); err != nil {
-						return err
-					}
-					firstFieldWritten = true
-				}
-
-				// Write explicitly initialized embedded structs
-				explicitKeys := make([]string, 0, len(explicitEmbedded))
-				for k := range explicitEmbedded {
-					explicitKeys = append(explicitKeys, k)
-				}
-				slices.Sort(explicitKeys)
-				for _, embeddedName := range explicitKeys {
-					if firstFieldWritten {
-						c.tsw.WriteLiterally(", ")
-					}
-					c.tsw.WriteLiterally(embeddedName)
-					c.tsw.WriteLiterally(": ")
-
-					// Check if the embedded value is a composite literal for a struct
-					// If so, extract the fields and write them directly
-					if compLit, ok := explicitEmbedded[embeddedName].(*ast.CompositeLit); ok {
-						// Write initialization fields directly without the 'new Constructor'
-						c.tsw.WriteLiterally("{")
-						for i, elem := range compLit.Elts {
-							if i > 0 {
-								c.tsw.WriteLiterally(", ")
-							}
-							if err := c.WriteVarRefedValue(elem); err != nil {
-								return err
-							}
-						}
-						c.tsw.WriteLiterally("}")
-					} else {
-						// Not a composite literal, write it normally
-						if err := c.WriteVarRefedValue(explicitEmbedded[embeddedName]); err != nil {
-							return err
-						}
-					}
-					firstFieldWritten = true
-				}
-
-				// Write embedded fields for structs that weren't explicitly initialized
-				embeddedKeys := make([]string, 0, len(embeddedFields))
-				for k := range embeddedFields {
-					// Skip embedded structs that were explicitly initialized
-					if _, wasExplicit := explicitEmbedded[k]; !wasExplicit {
-						embeddedKeys = append(embeddedKeys, k)
-					}
-				}
-				slices.Sort(embeddedKeys)
-				for _, embeddedPropName := range embeddedKeys {
-					fieldsMap := embeddedFields[embeddedPropName]
-					if len(fieldsMap) == 0 {
-						continue
-					} // Skip empty embedded initializers
-
-					if firstFieldWritten {
-						c.tsw.WriteLiterally(", ")
-					}
-					c.tsw.WriteLiterally(embeddedPropName) // Use the Type name as the property key
-					c.tsw.WriteLiterally(": {")
-
-					innerKeys := make([]string, 0, len(fieldsMap))
-					for k := range fieldsMap {
-						innerKeys = append(innerKeys, k)
-					}
-					slices.Sort(innerKeys)
-					for i, keyName := range innerKeys {
-						if i > 0 {
-							c.tsw.WriteLiterally(", ")
-						}
-						c.tsw.WriteLiterally(keyName) // Field name within the embedded struct
-						c.tsw.WriteLiterally(": ")
-						if err := c.WriteVarRefedValue(fieldsMap[keyName]); err != nil {
-							return err
-						}
-					}
-					c.tsw.WriteLiterally("}")
-					firstFieldWritten = true
+				// Write all fields
+				if err := c.writeStructLiteralFields(directFields, embeddedFields, explicitEmbedded, litType); err != nil {
+					return err
 				}
 
 				// Close the object literal
@@ -714,3 +528,226 @@ func (c *GoToTSCompiler) evaluateConstantExpr(expr ast.Expr) interface{} {
 	}
 	return nil
 }
+
+// categorizeStructFields organizes the elements of a struct composite literal into
+// three categories: direct fields, embedded fields, and explicitly initialized embedded structs.
+// Returns maps for direct fields, embedded fields (nested map), and explicit embedded initializations.
+func (c *GoToTSCompiler) categorizeStructFields(
+	exp *ast.CompositeLit,
+	structType *types.Struct,
+	litType types.Type,
+	isAnonymousStruct bool,
+) (
+	directFields map[string]ast.Expr,
+	embeddedFields map[string]map[string]ast.Expr,
+	explicitEmbedded map[string]ast.Expr,
+	err error,
+) {
+	directFields = make(map[string]ast.Expr)
+	embeddedFields = make(map[string]map[string]ast.Expr)
+	explicitEmbedded = make(map[string]ast.Expr)
+
+	// Pre-populate embeddedFields map keys using the correct property name
+	for i := 0; i < structType.NumFields(); i++ {
+		field := structType.Field(i)
+		if field.Anonymous() {
+			fieldType := field.Type()
+			if ptr, ok := fieldType.(*types.Pointer); ok {
+				fieldType = ptr.Elem()
+			}
+			if named, ok := fieldType.(*types.Named); ok {
+				// Use the type name as the property name in TS
+				embeddedPropName := named.Obj().Name()
+				embeddedFields[embeddedPropName] = make(map[string]ast.Expr)
+			}
+		}
+	}
+
+	// Group literal elements by direct vs embedded fields
+	for _, elt := range exp.Elts {
+		kv, ok := elt.(*ast.KeyValueExpr)
+		if !ok {
+			continue
+		} // Skip non-key-value
+		keyIdent, ok := kv.Key.(*ast.Ident)
+		if !ok {
+			continue
+		} // Skip non-ident keys
+		keyName := keyIdent.Name
+
+		// Check if this is an explicit embedded struct initialization
+		// e.g., Person: Person{...} or Person: personVar
+		if _, isEmbedded := embeddedFields[keyName]; isEmbedded {
+			// This is an explicit initialization of an embedded struct
+			explicitEmbedded[keyName] = kv.Value
+			continue
+		}
+
+		isDirectField := false
+		for i := range structType.NumFields() {
+			field := structType.Field(i)
+			if field.Name() == keyName {
+				isDirectField = true
+				directFields[keyName] = kv.Value
+				break
+			}
+		}
+
+		// For anonymous structs, all fields are direct fields
+		if isAnonymousStruct {
+			directFields[keyName] = kv.Value
+			isDirectField = true
+		}
+
+		// If not a direct field, return an error
+		if !isDirectField {
+			return nil, nil, nil, fmt.Errorf("field %s not found in type %s for composite literal",
+				keyName, litType.String())
+		}
+	}
+
+	// Handle the case where an anonymous struct has values without keys
+	// This block processes non-key-value elements and associates them with struct fields.
+	if isAnonymousStruct && len(exp.Elts) > 0 && len(directFields) == 0 {
+		// Check if any elements in the composite literal are not key-value pairs.
+		hasNonKeyValueElts := false
+		for _, elt := range exp.Elts {
+			// If an element is not a key-value pair, set the flag to true.
+			if _, isKV := elt.(*ast.KeyValueExpr); !isKV {
+				hasNonKeyValueElts = true
+				break
+			}
+		}
+
+		if hasNonKeyValueElts {
+			// Get the fields from the struct type
+			for i := 0; i < structType.NumFields(); i++ {
+				field := structType.Field(i)
+				// If we have a value for this field position
+				if i < len(exp.Elts) {
+					// Check if it's not a key-value pair
+					if _, isKV := exp.Elts[i].(*ast.KeyValueExpr); !isKV {
+						directFields[field.Name()] = exp.Elts[i]
+					}
+				}
+			}
+		}
+	}
+
+	return directFields, embeddedFields, explicitEmbedded, nil
+}
+
+// writeStructLiteralFields writes the field initializations for a struct composite literal.
+// It handles direct fields, explicitly initialized embedded structs, and implicitly initialized
+// embedded fields, writing them in sorted order.
+func (c *GoToTSCompiler) writeStructLiteralFields(
+	directFields map[string]ast.Expr,
+	embeddedFields map[string]map[string]ast.Expr,
+	explicitEmbedded map[string]ast.Expr,
+	litType types.Type,
+) error {
+	firstFieldWritten := false
+
+	// Write direct fields that aren't embedded struct names
+	directKeys := make([]string, 0, len(directFields))
+	for k := range directFields {
+		// Skip embedded struct names - we'll handle those separately
+		if _, isEmbedded := embeddedFields[k]; !isEmbedded {
+			directKeys = append(directKeys, k)
+		}
+	}
+	slices.Sort(directKeys)
+	for _, keyName := range directKeys {
+		if firstFieldWritten {
+			c.tsw.WriteLiterally(", ")
+		}
+
+		// Convert field name for protobuf types
+		fieldName := c.convertProtobufFieldNameInLiteral(keyName, litType)
+
+		c.tsw.WriteLiterally(fieldName)
+		c.tsw.WriteLiterally(": ")
+		if err := c.WriteVarRefedValue(directFields[keyName]); err != nil {
+			return err
+		}
+		firstFieldWritten = true
+	}
+
+	// Write explicitly initialized embedded structs
+	explicitKeys := make([]string, 0, len(explicitEmbedded))
+	for k := range explicitEmbedded {
+		explicitKeys = append(explicitKeys, k)
+	}
+	slices.Sort(explicitKeys)
+	for _, embeddedName := range explicitKeys {
+		if firstFieldWritten {
+			c.tsw.WriteLiterally(", ")
+		}
+		c.tsw.WriteLiterally(embeddedName)
+		c.tsw.WriteLiterally(": ")
+
+		// Check if the embedded value is a composite literal for a struct
+		// If so, extract the fields and write them directly
+		if compLit, ok := explicitEmbedded[embeddedName].(*ast.CompositeLit); ok {
+			// Write initialization fields directly without the 'new Constructor'
+			c.tsw.WriteLiterally("{")
+			for i, elem := range compLit.Elts {
+				if i > 0 {
+					c.tsw.WriteLiterally(", ")
+				}
+				if err := c.WriteVarRefedValue(elem); err != nil {
+					return err
+				}
+			}
+			c.tsw.WriteLiterally("}")
+		} else {
+			// Not a composite literal, write it normally
+			if err := c.WriteVarRefedValue(explicitEmbedded[embeddedName]); err != nil {
+				return err
+			}
+		}
+		firstFieldWritten = true
+	}
+
+	// Write embedded fields for structs that weren't explicitly initialized
+	embeddedKeys := make([]string, 0, len(embeddedFields))
+	for k := range embeddedFields {
+		// Skip embedded structs that were explicitly initialized
+		if _, wasExplicit := explicitEmbedded[k]; !wasExplicit {
+			embeddedKeys = append(embeddedKeys, k)
+		}
+	}
+	slices.Sort(embeddedKeys)
+	for _, embeddedPropName := range embeddedKeys {
+		fieldsMap := embeddedFields[embeddedPropName]
+		if len(fieldsMap) == 0 {
+			continue
+		} // Skip empty embedded initializers
+
+		if firstFieldWritten {
+			c.tsw.WriteLiterally(", ")
+		}
+		c.tsw.WriteLiterally(embeddedPropName) // Use the Type name as the property key
+		c.tsw.WriteLiterally(": {")
+
+		innerKeys := make([]string, 0, len(fieldsMap))
+		for k := range fieldsMap {
+			innerKeys = append(innerKeys, k)
+		}
+		slices.Sort(innerKeys)
+		for i, keyName := range innerKeys {
+			if i > 0 {
+				c.tsw.WriteLiterally(", ")
+			}
+			c.tsw.WriteLiterally(keyName) // Field name within the embedded struct
+			c.tsw.WriteLiterally(": ")
+			if err := c.WriteVarRefedValue(fieldsMap[keyName]); err != nil {
+				return err
+			}
+		}
+		c.tsw.WriteLiterally("}")
+		firstFieldWritten = true
+	}
+
+	return nil
+}

package/compiler/constraint.go

@@ -0,0 +1,88 @@
+package compiler
+
+import "go/types"
+
+// ConstraintInfo holds information about types found in an interface constraint
+type ConstraintInfo struct {
+	HasMap        bool
+	HasSlice      bool
+	HasString     bool
+	HasByteSlice  bool
+	MapValueType  types.Type
+	SliceElemType types.Type
+}
+
+// analyzeConstraint analyzes an interface constraint and returns information about the types it contains
+func analyzeConstraint(iface *types.Interface) ConstraintInfo {
+	info := ConstraintInfo{}
+
+	for i := 0; i < iface.NumEmbeddeds(); i++ {
+		embedded := iface.EmbeddedType(i)
+		if union, ok := embedded.(*types.Union); ok {
+			for j := 0; j < union.Len(); j++ {
+				term := union.Term(j)
+				checkType(term.Type(), &info)
+			}
+		} else {
+			checkType(embedded, &info)
+		}
+	}
+
+	return info
+}
+
+func checkType(t types.Type, info *ConstraintInfo) {
+	underlying := t.Underlying()
+
+	if mapType, isMap := underlying.(*types.Map); isMap {
+		info.HasMap = true
+		if info.MapValueType == nil {
+			info.MapValueType = mapType.Elem()
+		}
+		return
+	}
+
+	if sliceType, isSlice := underlying.(*types.Slice); isSlice {
+		info.HasSlice = true
+		if info.SliceElemType == nil {
+			info.SliceElemType = sliceType.Elem()
+		}
+
+		if elemType, isBasic := sliceType.Elem().(*types.Basic); isBasic && elemType.Kind() == types.Uint8 {
+			info.HasByteSlice = true
+		}
+		return
+	}
+
+	if basicType, isBasic := underlying.(*types.Basic); isBasic {
+		if (basicType.Info() & types.IsString) != 0 {
+			info.HasString = true
+		}
+	}
+}
+
+// hasMapConstraint checks if an interface constraint includes map types
+func hasMapConstraint(iface *types.Interface) bool {
+	return analyzeConstraint(iface).HasMap
+}
+
+// hasSliceConstraint checks if an interface constraint includes slice types
+func hasSliceConstraint(iface *types.Interface) bool {
+	return analyzeConstraint(iface).HasSlice
+}
+
+// hasMixedStringByteConstraint checks if an interface constraint includes both string and []byte types
+func hasMixedStringByteConstraint(iface *types.Interface) bool {
+	info := analyzeConstraint(iface)
+	return info.HasString && info.HasByteSlice
+}
+
+// getMapValueTypeFromConstraint extracts the value type from a map constraint
+func getMapValueTypeFromConstraint(iface *types.Interface) types.Type {
+	return analyzeConstraint(iface).MapValueType
+}
+
+// getSliceElementTypeFromConstraint extracts the element type from a slice constraint
+func getSliceElementTypeFromConstraint(iface *types.Interface) types.Type {
+	return analyzeConstraint(iface).SliceElemType
+}

package/compiler/decl.go

@@ -55,7 +55,8 @@ func (c *GoToTSCompiler) WriteDecls(decls []ast.Decl) error {
 	// Sort type declarations by dependencies
 	sortedTypeSpecs, err := c.sortTypeSpecsByDependencies(typeSpecs)
 	if err != nil {
-		return fmt.Errorf("failed to sort type declarations: %w", err)
+		// Surface the error instead of silently falling back
+		return fmt.Errorf("circular dependency detected sorting type declarations: %w", err)
 	}
 
 	// Sort variable declarations by type dependencies
@@ -147,12 +148,20 @@ func (c *GoToTSCompiler) sortTypeSpecsByDependencies(typeSpecs []*ast.TypeSpec)
 	return result, nil
 }
 
-// extractTypeDependencies extracts structural type dependencies from a type expression.
-// Only dependencies that affect class initialization order are considered:
-// - Struct field types (cause initialization order issues)
-// - Embedded types (directly affect struct layout)
-// - Type aliases (direct type references)
-// Method parameters and return types are ignored as they're just annotations.
+// extractTypeDependencies extracts only the dependencies that cause TypeScript initialization order issues.
+// These are dependencies where the constructor of one type directly instantiates another type.
+//
+// TRUE dependencies (cause initialization issues):
+// - Direct struct fields (non-pointer): type A struct { b B } -> A constructor calls new B()
+// - Embedded struct fields: type A struct { B } -> A constructor calls new B()
+// - Direct type aliases: type A B -> A directly wraps B
+// - Array/slice of structs: type A []B -> needs B for default values
+//
+// FALSE dependencies (don't cause initialization issues):
+// - Pointer fields: type A struct { b *B } -> just stores reference, no constructor call
+// - Interface fields: type A struct { b SomeInterface } -> stores interface, no concrete instantiation
+// - Map types: type A map[K]V -> map initialized empty, no constructor calls
+// - Array/slice of pointers: type A []*B -> array of pointers, no constructor calls
 func (c *GoToTSCompiler) extractTypeDependencies(typeExpr ast.Expr, typeSpecMap map[string]*ast.TypeSpec) []string {
 	var deps []string
 
@@ -164,35 +173,32 @@ func (c *GoToTSCompiler) extractTypeDependencies(typeExpr ast.Expr, typeSpecMap
 		}
 
 	case *ast.StructType:
-		// Struct type - check field types only
+		// Struct type - check field types, but be more selective
 		if t.Fields != nil {
 			for _, field := range t.Fields.List {
-				fieldDeps := c.extractTypeDependencies(field.Type, typeSpecMap)
+				fieldDeps := c.extractStructFieldDependencies(field.Type, typeSpecMap)
 				deps = append(deps, fieldDeps...)
 			}
 		}
 
 	case *ast.ArrayType:
-		// Array type - check element type
-		elemDeps := c.extractTypeDependencies(t.Elt, typeSpecMap)
-		deps = append(deps, elemDeps...)
+		// Array/slice type - only depends on element type if element is a struct (not pointer)
+		if !c.isPointerType(t.Elt) {
+			elemDeps := c.extractTypeDependencies(t.Elt, typeSpecMap)
+			deps = append(deps, elemDeps...)
+		}
+		// Arrays of pointers don't create initialization dependencies
 
 	case *ast.StarExpr:
-		// Pointer type - check pointed-to type
-		ptrDeps := c.extractTypeDependencies(t.X, typeSpecMap)
-		deps = append(deps, ptrDeps...)
+		// Pointer types don't create initialization dependencies
+		// The pointed-to type doesn't need to be initialized when creating a pointer field
 
 	case *ast.MapType:
-		// Map type - check key and value types
-		keyDeps := c.extractTypeDependencies(t.Key, typeSpecMap)
-		valueDeps := c.extractTypeDependencies(t.Value, typeSpecMap)
-		deps = append(deps, keyDeps...)
-		deps = append(deps, valueDeps...)
+		// Map types don't create initialization dependencies
+		// Maps are initialized empty, no constructor calls needed
 
 	case *ast.InterfaceType:
-		// Interface type - methods don't create initialization dependencies
-		// Only embedded interfaces matter, but those are rare and complex to handle
-		// For now, interfaces are considered to have no dependencies
+		// Interface types don't create initialization dependencies
 
 	case *ast.FuncType:
 		// Function types don't create initialization dependencies
@@ -208,6 +214,44 @@ func (c *GoToTSCompiler) extractTypeDependencies(typeExpr ast.Expr, typeSpecMap
 	return deps
 }
 
+// extractStructFieldDependencies extracts dependencies from struct field types
+func (c *GoToTSCompiler) extractStructFieldDependencies(fieldType ast.Expr, typeSpecMap map[string]*ast.TypeSpec) []string {
+	var deps []string
+
+	switch t := fieldType.(type) {
+	case *ast.Ident:
+		// Direct field type: struct { b B } - this requires B to be initialized
+		if _, isLocalType := typeSpecMap[t.Name]; isLocalType {
+			deps = append(deps, t.Name)
+		}
+
+	case *ast.StarExpr:
+		// Pointer field: struct { b *B } - this doesn't require B initialization
+		// Pointers are just references, no constructor call needed
+
+	case *ast.ArrayType:
+		// Array field: struct { b []B } or struct { b [5]B }
+		// Only create dependency if element type is not a pointer
+		if !c.isPointerType(t.Elt) {
+			elemDeps := c.extractTypeDependencies(t.Elt, typeSpecMap)
+			deps = append(deps, elemDeps...)
+		}
+
+	case *ast.MapType:
+		// Map field: struct { b map[K]V } - maps don't require initialization dependencies
+
+	case *ast.InterfaceType:
+		// Interface field: struct { b SomeInterface } - no concrete type dependency
+
+	case *ast.FuncType:
+		// Function field: struct { b func() } - no dependency
+
+		// Handle other field types as needed
+	}
+
+	return deps
+}
+
 // sortVarSpecsByTypeDependencies sorts variable declarations based on their type dependencies
 func (c *GoToTSCompiler) sortVarSpecsByTypeDependencies(varSpecs []*ast.ValueSpec, typeSpecs []*ast.TypeSpec) ([]*ast.ValueSpec, error) {
 	if len(varSpecs) <= 1 {
@@ -391,7 +435,21 @@ func (c *GoToTSCompiler) topologicalSort(dependencies map[string][]string) ([]st
 
 	// Check for cycles
 	if len(result) != len(dependencies) {
-		return nil, fmt.Errorf("circular dependency detected in type declarations")
+		// Find the remaining nodes to help debug the circular dependency
+		processed := make(map[string]bool)
+		for _, name := range result {
+			processed[name] = true
+		}
+
+		var remaining []string
+		for name := range dependencies {
+			if !processed[name] {
+				remaining = append(remaining, name)
+			}
+		}
+		sort.Strings(remaining)
+
+		return nil, fmt.Errorf("circular dependency detected in type declarations. Remaining types: %v", remaining)
 	}
 
 	return result, nil