@tsonic/emitter 0.0.1

package/testcases/real-world/todo-list/config.yaml

@@ -0,0 +1 @@
+- todo-list.ts: should emit real-world todo-list program

package/testcases/real-world/todo-list/todo-list.ts

@@ -0,0 +1,52 @@
+export interface Todo {
+  id: number;
+  title: string;
+  completed: boolean;
+  createdAt: Date;
+}
+
+export class TodoList {
+  private todos: Todo[] = [];
+  private nextId: number = 1;
+
+  addTodo(title: string): Todo {
+    const todo: Todo = {
+      id: this.nextId++,
+      title: title,
+      completed: false,
+      createdAt: new Date(),
+    };
+    this.todos.push(todo);
+    return todo;
+  }
+
+  completeTodo(id: number): boolean {
+    const todo = this.todos.find((t) => t.id === id);
+    if (todo) {
+      todo.completed = true;
+      return true;
+    }
+    return false;
+  }
+
+  getActiveTodos(): Todo[] {
+    return this.todos.filter((t) => !t.completed);
+  }
+
+  getCompletedTodos(): Todo[] {
+    return this.todos.filter((t) => t.completed);
+  }
+
+  getAllTodos(): Todo[] {
+    return [...this.todos];
+  }
+}
+
+export function createSampleTodoList(): TodoList {
+  const list = new TodoList();
+  list.addTodo("Buy groceries");
+  list.addTodo("Write code");
+  list.addTodo("Exercise");
+  list.completeTodo(1);
+  return list;
+}

package/testcases/real-world/type-guards/config.yaml

@@ -0,0 +1 @@
+- type-guards.ts: should emit real-world type-guards program

package/testcases/real-world/type-guards/type-guards.ts

@@ -0,0 +1,71 @@
+export interface User {
+  type: "user";
+  id: number;
+  username: string;
+  email: string;
+}
+
+export interface Admin {
+  type: "admin";
+  id: number;
+  username: string;
+  email: string;
+  permissions: string[];
+}
+
+export interface Guest {
+  type: "guest";
+  sessionId: string;
+}
+
+export type Account = User | Admin | Guest;
+
+export function isUser(account: Account): account is User {
+  return account.type === "user";
+}
+
+export function isAdmin(account: Account): account is Admin {
+  return account.type === "admin";
+}
+
+export function isGuest(account: Account): account is Guest {
+  return account.type === "guest";
+}
+
+export function getAccountDescription(account: Account): string {
+  if (isUser(account)) {
+    return `User: ${account.username} (${account.email})`;
+  } else if (isAdmin(account)) {
+    return `Admin: ${account.username} with ${account.permissions.length} permissions`;
+  } else if (isGuest(account)) {
+    return `Guest session: ${account.sessionId}`;
+  }
+  return "Unknown account type";
+}
+
+export function hasEmail(account: Account): boolean {
+  return isUser(account) || isAdmin(account);
+}
+
+export function getPermissions(account: Account): string[] {
+  if (isAdmin(account)) {
+    return account.permissions;
+  }
+  return [];
+}
+
+// Type guards with typeof
+export function processValue(value: string | number | boolean): string {
+  if (typeof value === "string") {
+    return value.toUpperCase();
+  } else if (typeof value === "number") {
+    return value.toFixed(2);
+  } else {
+    return value ? "yes" : "no";
+  }
+}
+
+// Array type guard
+export function isStringArray(arr: unknown): arr is string[] {
+  return Array.isArray(arr) && arr.every((item) => typeof item === "string");
+}

package/testcases/structs/basic/Point.ts

@@ -0,0 +1,9 @@
+// Define struct marker inline for testing
+interface struct {
+  readonly __brand: "struct";
+}
+
+export interface Point extends struct {
+  x: number;
+  y: number;
+}

package/testcases/structs/basic/config.yaml

@@ -0,0 +1 @@
+- Point.ts: should emit basic struct with properties

package/testcases/types/conditional/ConditionalTypes.ts

@@ -0,0 +1,35 @@
+export type StringOrNumber = string | number | boolean;
+
+// Using built-in conditional utility types
+export type OnlyStrings = Extract<StringOrNumber, string>;
+export type NoStrings = Exclude<StringOrNumber, string>;
+export type NonNullableValue = NonNullable<string | null | undefined>;
+
+// Custom conditional type
+export type IsArray<T> = T extends any[] ? true : false;
+
+export type ArrayCheck1 = IsArray<string[]>;
+export type ArrayCheck2 = IsArray<string>;
+
+// More complex conditional type
+export type Unwrap<T> = T extends Promise<infer U> ? U : T;
+
+export type UnwrappedString = Unwrap<Promise<string>>;
+export type UnwrappedNumber = Unwrap<number>;
+
+// Function using conditional type
+export function processValue<T extends string | number>(
+  value: T
+): T extends string ? number : string {
+  if (typeof value === "string") {
+    return value.length as any;
+  }
+  return value.toString() as any;
+}
+
+// ReturnType utility
+export function greet(name: string): string {
+  return `Hello ${name}`;
+}
+
+export type GreetReturn = ReturnType<typeof greet>;

package/testcases/types/conditional/config.yaml

@@ -0,0 +1 @@
+- ConditionalTypes.ts: should emit conditional types (Extract, Exclude, NonNullable)

package/testcases/types/constants/ModuleConstants.ts

@@ -0,0 +1,6 @@
+// Module-level constants without explicit type annotations
+// C# doesn't allow 'var' for class-level fields
+export const PI = 3.14159;
+export const MESSAGE = "Hello, World!";
+export const COUNT = 42;
+export const IS_ENABLED = true;

package/testcases/types/constants/config.yaml

@@ -0,0 +1 @@
+- ModuleConstants.ts: should emit module-level constants with explicit CLR types

package/testcases/types/generics/Generics.ts

@@ -0,0 +1,15 @@
+export function identity<T>(value: T): T {
+  return value;
+}
+
+export function firstElement<T>(arr: T[]): T | undefined {
+  return arr[0];
+}
+
+export class Box<T> {
+  constructor(public value: T) {}
+
+  getValue(): T {
+    return this.value;
+  }
+}

package/testcases/types/generics/config.yaml

@@ -0,0 +1 @@
+- Generics.ts: should emit generic functions and classes with type parameters

package/testcases/types/interfaces/Interfaces.ts

@@ -0,0 +1,14 @@
+export interface User {
+  name: string;
+  email: string;
+  age: number;
+}
+
+export function greetUser(user: User): string {
+  return `Hello ${user.name}, age ${user.age}`;
+}
+
+export interface Point {
+  readonly x: number;
+  readonly y: number;
+}

package/testcases/types/interfaces/config.yaml

@@ -0,0 +1 @@
+- Interfaces.ts: should emit interfaces as C# classes with auto-properties

package/testcases/types/mapped/MappedTypes.ts

@@ -0,0 +1,27 @@
+export interface Person {
+  name: string;
+  age: number;
+  email: string;
+}
+
+// Using built-in utility types
+export type PartialPerson = Partial<Person>;
+export type RequiredPerson = Required<Person>;
+export type ReadonlyPerson = Readonly<Person>;
+
+// Custom mapped type
+export type Nullable<T> = {
+  [P in keyof T]: T[P] | null;
+};
+
+export type NullablePerson = Nullable<Person>;
+
+// Function using mapped types
+export function updatePerson(person: Person, updates: Partial<Person>): Person {
+  return { ...person, ...updates };
+}
+
+// Function with readonly parameter
+export function displayPerson(person: Readonly<Person>): string {
+  return `${person.name} (${person.age})`;
+}

package/testcases/types/mapped/config.yaml

@@ -0,0 +1 @@
+- MappedTypes.ts: should emit mapped types (Partial, Required, Readonly)

package/testcases/types/tuples-intersections/TuplesAndIntersections.ts

@@ -0,0 +1,46 @@
+// Tuple types
+export type Point2D = [number, number];
+export type Point3D = [number, number, number];
+export type NamedPoint = [x: number, y: number];
+
+// Variadic tuples
+export type Coords = [...number[]];
+export type StringWithNumbers = [string, ...number[]];
+
+// Intersection types
+export interface Named {
+  name: string;
+}
+
+export interface Aged {
+  age: number;
+}
+
+export type Person = Named & Aged;
+
+// Complex intersection
+export interface Serializable {
+  toJSON(): string;
+}
+
+export type SerializablePerson = Person & Serializable;
+
+// Functions using tuples
+export function distance(point: Point2D): number {
+  const [x, y] = point;
+  return Math.sqrt(x * x + y * y);
+}
+
+export function createPoint(x: number, y: number): Point2D {
+  return [x, y];
+}
+
+// Function using intersection
+export function greetPerson(person: Person): string {
+  return `${person.name} is ${person.age} years old`;
+}
+
+// Rest elements with tuples
+export function sum(...nums: [...number[]]): number {
+  return nums.reduce((a, b) => a + b, 0);
+}

package/testcases/types/tuples-intersections/config.yaml

@@ -0,0 +1 @@
+- TuplesAndIntersections.ts: should emit tuple types and intersection types

package/testcases/types/unions/UnionTypes.ts

@@ -0,0 +1,11 @@
+export function process(value: string | number): string {
+  if (typeof value === "string") {
+    return value.toUpperCase();
+  } else {
+    return value.toString();
+  }
+}
+
+export function maybeString(value: string | null): number {
+  return value?.length ?? 0;
+}

package/testcases/types/unions/config.yaml

@@ -0,0 +1 @@
+- UnionTypes.ts: should emit union types as Union<T1, T2> or nullable

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "composite": true,
+    "declaration": true,
+    "declarationMap": true,
+    "tsBuildInfoFile": "./dist/.tsbuildinfo"
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist"],
+  "references": [{ "path": "../frontend" }]
+}