initial commit

internal/tsconvert/types.go

@@ -0,0 +1,92 @@
+// Package tsconvert provides utilities for converting Go types to TypeScript definitions.
+package tsconvert
+
+import (
+	"fmt"
+	"regexp"
+)
+
+// TypeDecl represents a TypeScript type declaration.
+type TypeDecl struct {
+	Name       string // e.g., "UserConfig"
+	Definition string // e.g., "interface UserConfig { name: string }"
+}
+
+// TypeSet manages a collection of type declarations with deduplication support.
+type TypeSet struct {
+	types map[string]string // name -> definition
+}
+
+// NewTypeSet creates a new empty TypeSet.
+func NewTypeSet() *TypeSet {
+	return &TypeSet{
+		types: make(map[string]string),
+	}
+}
+
+// Add adds a type declaration to the set.
+// Returns an error if a type with the same name but different definition already exists.
+func (ts *TypeSet) Add(name, definition string) error {
+	if existing, ok := ts.types[name]; ok {
+		if existing != definition {
+			return fmt.Errorf("type conflict: %s has conflicting definitions", name)
+		}
+		// Same name and definition, no conflict
+		return nil
+	}
+	ts.types[name] = definition
+	return nil
+}
+
+// Get retrieves a type definition by name.
+func (ts *TypeSet) Get(name string) (string, bool) {
+	def, ok := ts.types[name]
+	return def, ok
+}
+
+// All returns all type declarations as a map.
+func (ts *TypeSet) All() map[string]string {
+	result := make(map[string]string, len(ts.types))
+	for k, v := range ts.types {
+		result[k] = v
+	}
+	return result
+}
+
+// Names returns all type names in the set.
+func (ts *TypeSet) Names() []string {
+	names := make([]string, 0, len(ts.types))
+	for name := range ts.types {
+		names = append(names, name)
+	}
+	return names
+}
+
+// Merge merges another TypeSet into this one.
+// Returns an error if there are conflicting definitions.
+func (ts *TypeSet) Merge(other *TypeSet) error {
+	for name, def := range other.types {
+		if err := ts.Add(name, def); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// ExtractName extracts the type name from a TypeScript declaration.
+// Supports "interface Name {...}" and "type Name = ..." patterns.
+func ExtractName(definition string) string {
+	// Try interface pattern: "interface Name { ... }"
+	interfaceRe := regexp.MustCompile(`^interface\s+(\w+)`)
+	if matches := interfaceRe.FindStringSubmatch(definition); len(matches) > 1 {
+		return matches[1]
+	}
+
+	// Try type alias pattern: "type Name = ..."
+	typeRe := regexp.MustCompile(`^type\s+(\w+)`)
+	if matches := typeRe.FindStringSubmatch(definition); len(matches) > 1 {
+		return matches[1]
+	}
+
+	return ""
+}