Merge pull request #91 from PY44N/main

Add Support for Typescript Enum & Union Generation

Author: gzuidhof

README.md

@@ -53,7 +53,7 @@ type ListUsersResponse struct {
 }
 ```
 
-_Typescript output_
+_Typescript output (with default `enum_style: "const"`)_
 
 ```typescript
 /**
@@ -141,7 +141,7 @@ err := gen.Generate()
 # You can specify default mappings that will apply to all packages.
 type_mappings:
   time.Time: "string /* RFC3339 */"
-  
+
 # You can specify more than one package
 packages:
   # The package path just like you would import it in Go
@@ -173,6 +173,12 @@ packages:
     # Package that the generates Typescript types should extend. This is useful when
     # attaching your types to a generic ORM.
     extends: "SomeType"
+
+    # Enum generation style. Supported values: "const" (default), "enum", "union".
+    # "const" generates individual export const declarations (traditional behavior).
+    # "enum" generates TypeScript enum declarations for Go const groups.
+    # "union" generates TypeScript union type declarations for Go const groups.
+    enum_style: "enum"
 ```
 
 See also the source file [tygo/config.go](./tygo/config.go).
@@ -207,10 +213,11 @@ You could use the `frontmatter` field in the config to inject `export type Genre
 
 **`tygo:emit` directive**
 
-Another way to generate types that cannot be directly represented in Go is to use a `//tygo:emit` directive to 
+Another way to generate types that cannot be directly represented in Go is to use a `//tygo:emit` directive to
 directly emit literal TS code.
-The directive can be used in two ways. A `tygo:emit` directive on a struct will emit the remainder of the directive 
+The directive can be used in two ways. A `tygo:emit` directive on a struct will emit the remainder of the directive
 text before the struct.
+
 ```golang
 // Golang input
 
@@ -222,7 +229,7 @@ type Book struct {
 ```
 
 ```typescript
-export type Genre = "novel" | "crime" | "fantasy"
+export type Genre = "novel" | "crime" | "fantasy";
 
 export interface Book {
   title: string;
@@ -231,11 +238,12 @@ export interface Book {
 ```
 
 A `//tygo:emit` directive on a string var will emit the contents of the var, useful for multi-line content.
+
 ```golang
 //tygo:emit
 var _ = `export type StructAsTuple=[
-  a:number, 
-  b:number, 
+  a:number,
+  b:number,
   c:string,
 ]
 `
@@ -245,16 +253,11 @@ type CustomMarshalled struct {
 ```
 
 ```typescript
-export type StructAsTuple=[
-  a:number, 
-  b:number, 
-  c:string,
-]
+export type StructAsTuple = [a: number, b: number, c: string];
 
 export interface CustomMarshalled {
   content: StructAsTuple[];
 }
-
 ```
 
 Generating types this way is particularly useful for tuple types, because a comma cannot be used in the `tstype` tag.
@@ -396,6 +399,111 @@ export interface ABCD<
 }
 ```
 
+## TypeScript Enum and Union Generation
+
+Tygo can generate native TypeScript enums or union types from Go const groups. When `enum_style: "enum"` is configured, tygo detects Go constant groups that follow enum-like patterns and converts them to TypeScript enums. When `enum_style: "union"` is configured, the same const groups are converted to TypeScript union types instead.
+
+### Requirements for Enum/Union Generation
+
+For a const group to be recognized as an enum or union:
+
+1. It must contain at least 2 exported constants
+2. All constants should share the same type (e.g., `UserRole`)
+3. Constant names should follow a consistent prefix pattern (e.g., `UserRoleDefault`, `UserRoleEditor`)
+
+### Examples
+
+**String Enums:**
+
+```go
+// Go input
+type Status = string
+const (
+    StatusActive   Status = "active"
+    StatusInactive Status = "inactive"
+    StatusPending  Status = "pending"
+)
+```
+
+```typescript
+// TypeScript output (with enum_style: "enum")
+export enum Status {
+  Active = "active",
+  Inactive = "inactive",
+  Pending = "pending",
+}
+```
+
+```typescript
+// TypeScript output (with enum_style: "union")
+export const StatusActive = "active";
+export const StatusInactive = "inactive";
+export const StatusPending = "pending";
+export type Status = typeof StatusActive | typeof StatusInactive | typeof StatusPending;
+```
+
+**Numeric Enums with iota:**
+
+```go
+// Go input
+type Priority int
+const (
+    PriorityLow Priority = iota
+    PriorityMedium
+    PriorityHigh
+)
+```
+
+```typescript
+// TypeScript output (with enum_style: "enum")
+export enum Priority {
+  Low = 0,
+  Medium,
+  High,
+}
+```
+
+```typescript
+// TypeScript output (with enum_style: "union")
+export const PriorityLow = 0;
+export const PriorityMedium = 1;
+export const PriorityHigh = 2;
+export type Priority = typeof PriorityLow | typeof PriorityMedium | typeof PriorityHigh;
+```
+
+**Mixed Const Blocks:**
+When a const block contains both enum-like constants and other constants, tygo generates an enum for the matching constants and individual const declarations for the rest:
+
+```go
+// Go input
+type UserRole = string
+const (
+    UserRoleAdmin UserRole = "admin"
+    UserRoleGuest UserRole = "guest"
+    MaxRetries = 5
+    DefaultTimeout = 30
+)
+```
+
+```typescript
+// TypeScript output (with enum_style: "enum")
+export enum UserRole {
+  Admin = "admin",
+  Guest = "guest",
+}
+export const MaxRetries = 5;
+export const DefaultTimeout = 30;
+```
+
+```typescript
+// TypeScript output (with enum_style: "union")
+export const UserRoleAdmin = "admin";
+export const UserRoleGuest = "guest";
+export type UserRole = typeof UserRoleAdmin | typeof UserRoleGuest;
+export const MaxRetries = 5;
+export const DefaultTimeout = 30;
+```
+
 ## YAML support
 
 Tygo supports generating typings for YAML-serializable objects that can be understood by Go apps.

tygo.yaml

@@ -56,10 +56,8 @@ packages:
   - path: "github.com/gzuidhof/tygo/examples/interface"
   - path: "github.com/gzuidhof/tygo/examples/directive"
   - path: "github.com/gzuidhof/tygo/examples/emit"
-    exclude_files: 
+    exclude_files:
       - "excluded.go"
   - path: "github.com/gzuidhof/tygo/examples/rune"
 
   - path: "github.com/gzuidhof/tygo/examples/globalconfig"
-  
-

tygo/config.go

@@ -10,6 +10,7 @@ import (
 const defaultOutputFilename = "index.ts"
 const defaultFallbackType = "any"
 const defaultPreserveComments = "default"
+const defaultEnumStyle = "const"
 
 type PackageConfig struct {
 	// The package path just like you would import it in Go
@@ -61,6 +62,13 @@ type PackageConfig struct {
 	// Default is "undefined".
 	// Useful for usage with JSON marshalers that output null for optional fields (e.g. gofiber JSON).
 	OptionalType string `yaml:"optional_type"`
+
+	// Set the enum generation style.
+	// Supported values: "const" (default), "enum", "union".
+	// "const" generates individual export const declarations (current behavior).
+	// "enum" generates TypeScript enum declarations.
+	// "union" generates TypeScript union type declarations.
+	EnumStyle string `yaml:"enum_style"`
 }
 
 type Config struct {
@@ -128,6 +136,19 @@ func normalizeOptionalType(optional string) (string, error) {
 	}
 }
 
+func normalizeEnumStyle(enumStyle string) (string, error) {
+	switch enumStyle {
+	case "", "const":
+		return "const", nil
+	case "enum":
+		return "enum", nil
+	case "union":
+		return "union", nil
+	default:
+		return "", fmt.Errorf("unsupported enum_style: %s", enumStyle)
+	}
+}
+
 func (c PackageConfig) IsFileIgnored(pathToFile string) bool {
 	basename := filepath.Base(pathToFile)
 	for _, ef := range c.ExcludeFiles {
@@ -172,6 +193,10 @@ func (pc PackageConfig) Normalize() (PackageConfig, error) {
 		pc.PreserveComments = defaultPreserveComments
 	}
 
+	if pc.EnumStyle == "" {
+		pc.EnumStyle = defaultEnumStyle
+	}
+
 	var err error
 	pc.Flavor, err = normalizeFlavor(pc.Flavor)
 	if err != nil {
@@ -188,6 +213,11 @@ func (pc PackageConfig) Normalize() (PackageConfig, error) {
 		return pc, fmt.Errorf("invalid optional_type config for package %s: %s", pc.Path, err)
 	}
 
+	pc.EnumStyle, err = normalizeEnumStyle(pc.EnumStyle)
+	if err != nil {
+		return pc, fmt.Errorf("invalid enum_style config for package %s: %s", pc.Path, err)
+	}
+
 	return pc, nil
 }
 

tygo/convert_string.go

@@ -28,8 +28,9 @@ func ConvertGoToTypescript(goCode string, pkgConfig PackageConfig) (string, erro
 	}
 
 	pkgGen := &PackageGenerator{
-		conf: &pkgConfig,
-		pkg:  nil,
+		conf:           &pkgConfig,
+		pkg:            nil,
+		generatedEnums: make(map[string]bool),
 	}
 
 	s := new(strings.Builder)

tygo/generator.go

@@ -18,9 +18,10 @@ type Tygo struct {
 
 // Responsible for generating the code for an input package
 type PackageGenerator struct {
-	conf    *PackageConfig
-	pkg     *packages.Package
-	GoFiles []string
+	conf          *PackageConfig
+	pkg           *packages.Package
+	GoFiles       []string
+	generatedEnums map[string]bool // Track types that have been generated as enums
 }
 
 func New(config *Config) *Tygo {
@@ -56,9 +57,10 @@ func (g *Tygo) Generate() error {
 		pkgConfig := g.conf.PackageConfig(pkg.ID)
 
 		pkgGen := &PackageGenerator{
-			conf:    pkgConfig,
-			GoFiles: pkg.GoFiles,
-			pkg:     pkg,
+			conf:           pkgConfig,
+			GoFiles:        pkg.GoFiles,
+			pkg:            pkg,
+			generatedEnums: make(map[string]bool),
 		}
 		g.packageGenerators[pkg.PkgPath] = pkgGen
 		code, err := pkgGen.Generate()

tygo/package_generator.go

@@ -6,8 +6,24 @@ import (
 	"strings"
 )
 
+// preProcessEnums scans the file for const declarations that will be converted to enums
+// and marks the corresponding types to prevent duplicate type declarations
+func (g *PackageGenerator) preProcessEnums(file *ast.File) {
+	ast.Inspect(file, func(n ast.Node) bool {
+		if decl, ok := n.(*ast.GenDecl); ok && decl.Tok == token.CONST {
+			if enumGroup := g.detectEnumGroup(decl); enumGroup != nil {
+				g.generatedEnums[enumGroup.typeName] = true
+			}
+		}
+		return true
+	})
+}
+
 // generateFile writes the generated code for a single file to the given strings.Builder.
 func (g *PackageGenerator) generateFile(s *strings.Builder, file *ast.File, filepath string) {
+	// First pass: identify types that will be generated as enums
+	g.preProcessEnums(file)
+
 	first := true
 
 	ast.Inspect(file, func(n ast.Node) bool {