ColesTypescriptToCSharp 1.0.0

CSharpToTypeScript

A .NET library that converts C# types to TypeScript type definitions. It recursively discovers related types and generates properly organized .ts files with imports.

Features

• Automatic Type Discovery - Add root types and all related types are automatically discovered
• Namespace Organization - Types are grouped into separate .ts files by namespace
• Cross-Namespace Imports - Automatically generates import statements between files
• Inheritance Support - Emits extends clauses for class hierarchies
• Comprehensive Type Mapping - Handles primitives, collections, generics, enums, records, and more
• JSON Attribute Support - Respects [JsonIgnore] and [JsonPropertyName] attributes
• Configurable Output - Customize naming conventions, enum styles, and nullability handling

Installation

dotnet add package CSharpToTypeScript

Quick Start

using SessionTracker;

// Create a converter with default options
var converter = new TypeScriptConverter();

// Add root types - related types are discovered automatically
converter.AddType<Order>();

// Generate files to a directory
converter.WriteToDirectory("./generated-types");

Configuration

var converter = new TypeScriptConverter(new TypeScriptConverterOptions
{
    // Enum output style: Numeric or StringLiteral
    EnumStyle = EnumStyle.StringLiteral,
    
    // Property naming: CamelCase or PreserveOriginal
    PropertyNaming = PropertyNamingStyle.CamelCase,
    
    // File naming: Dots (MyApp.Models.ts) or Underscores (MyApp_Models.ts)
    FileNaming = FileNamingStyle.Dots,
    
    // Include 'extends' for classes with base types
    IncludeInheritance = true,
    
    // Honor [JsonIgnore], [JsonPropertyName] attributes
    RespectJsonAttributes = true,
    
    // Nullable handling: UseNullUnion (T | null), Optional (T?), or Ignore
    NullableHandling = NullableHandling.UseNullUnion,
    
    // Generate index.ts barrel file
    GenerateBarrelFile = true,
});

Example

Given these C# types:

namespace MyApp.Models
{
    public class User
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public DateTime CreatedAt { get; set; }
    }
}

namespace MyApp.Models.Orders
{
    public class Order
    {
        public Guid Id { get; set; }
        public User Customer { get; set; }
        public List<OrderItem> Items { get; set; }
        public OrderStatus Status { get; set; }
    }
    
    public enum OrderStatus { Pending, Shipped, Delivered }
}

The converter generates:

MyApp.Models.ts

export interface User {
  id: number;
  name: string;
  createdAt: string;
}

MyApp.Models.Orders.ts

import { User } from './MyApp.Models';

export interface Order {
  id: string;
  customer: User;
  items: OrderItem[];
  status: OrderStatus;
}

export interface OrderItem {
  productName: string;
  price: number;
  quantity: number;
}

export enum OrderStatus {
  Pending = 0,
  Shipped = 1,
  Delivered = 2,
}

Type Mapping Reference

In-Memory Generation

// Get output without writing to disk
Dictionary<string, string> files = converter.GetOutput();

foreach (var (fileName, content) in files)
{
    Console.WriteLine($"=== {fileName} ===");
    Console.WriteLine(content);
}

License

MIT