@tsonic/emitter 0.0.1

package/testcases/real-world/async-ops/async-ops.ts

@@ -0,0 +1,67 @@
+export async function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+export async function fetchData(id: number): Promise<string> {
+  await delay(100);
+  return `Data for ID ${id}`;
+}
+
+export async function fetchMultiple(ids: number[]): Promise<string[]> {
+  const promises = ids.map((id) => fetchData(id));
+  return Promise.all(promises);
+}
+
+export async function processWithRetry<T>(
+  fn: () => Promise<T>,
+  maxRetries: number = 3
+): Promise<T> {
+  let lastError: Error | undefined;
+
+  for (let i = 0; i < maxRetries; i++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error as Error;
+      await delay(100 * (i + 1)); // Exponential backoff
+    }
+  }
+
+  throw lastError || new Error("Max retries exceeded");
+}
+
+export class AsyncCache<K, V> {
+  private cache: Map<K, V> = new Map();
+  private loading: Map<K, Promise<V>> = new Map();
+
+  async get(key: K, loader: () => Promise<V>): Promise<V> {
+    // Check cache
+    if (this.cache.has(key)) {
+      return this.cache.get(key)!;
+    }
+
+    // Check if already loading
+    if (this.loading.has(key)) {
+      return this.loading.get(key)!;
+    }
+
+    // Start loading
+    const promise = loader();
+    this.loading.set(key, promise);
+
+    try {
+      const value = await promise;
+      this.cache.set(key, value);
+      return value;
+    } finally {
+      this.loading.delete(key);
+    }
+  }
+
+  clear(): void {
+    this.cache.clear();
+    this.loading.clear();
+  }
+}

package/testcases/real-world/async-ops/config.yaml

@@ -0,0 +1 @@
+- async-ops.ts: should emit real-world async-ops program

package/testcases/real-world/business-logic/business-logic.ts

@@ -0,0 +1,215 @@
+// E-commerce domain models
+export interface Product {
+  id: string;
+  name: string;
+  price: number;
+  stock: number;
+  category: string;
+}
+
+export interface CartItem {
+  product: Product;
+  quantity: number;
+}
+
+export interface Order {
+  id: string;
+  items: CartItem[];
+  total: number;
+  status: OrderStatus;
+  createdAt: Date;
+}
+
+export type OrderStatus =
+  | "pending"
+  | "processing"
+  | "shipped"
+  | "delivered"
+  | "cancelled";
+
+export class ShoppingCart {
+  private items: CartItem[] = [];
+
+  addItem(product: Product, quantity: number): boolean {
+    if (quantity <= 0 || quantity > product.stock) {
+      return false;
+    }
+
+    const existingItem = this.items.find(
+      (item) => item.product.id === product.id
+    );
+
+    if (existingItem) {
+      const newQuantity = existingItem.quantity + quantity;
+      if (newQuantity > product.stock) {
+        return false;
+      }
+      existingItem.quantity = newQuantity;
+    } else {
+      this.items.push({ product, quantity });
+    }
+
+    return true;
+  }
+
+  removeItem(productId: string): boolean {
+    const index = this.items.findIndex((item) => item.product.id === productId);
+
+    if (index !== -1) {
+      this.items.splice(index, 1);
+      return true;
+    }
+
+    return false;
+  }
+
+  updateQuantity(productId: string, quantity: number): boolean {
+    const item = this.items.find((item) => item.product.id === productId);
+
+    if (!item) {
+      return false;
+    }
+
+    if (quantity <= 0) {
+      return this.removeItem(productId);
+    }
+
+    if (quantity > item.product.stock) {
+      return false;
+    }
+
+    item.quantity = quantity;
+    return true;
+  }
+
+  getTotal(): number {
+    return this.items.reduce(
+      (sum, item) => sum + item.product.price * item.quantity,
+      0
+    );
+  }
+
+  getItemCount(): number {
+    return this.items.reduce((sum, item) => sum + item.quantity, 0);
+  }
+
+  getItems(): CartItem[] {
+    return [...this.items];
+  }
+
+  clear(): void {
+    this.items = [];
+  }
+}
+
+export class DiscountCalculator {
+  static applyPercentageDiscount(price: number, percentage: number): number {
+    if (percentage < 0 || percentage > 100) {
+      throw new Error("Invalid discount percentage");
+    }
+    return price * (1 - percentage / 100);
+  }
+
+  static applyFixedDiscount(price: number, discount: number): number {
+    const result = price - discount;
+    return result < 0 ? 0 : result;
+  }
+
+  static calculateBulkDiscount(quantity: number, price: number): number {
+    if (quantity >= 100) {
+      return this.applyPercentageDiscount(price, 20);
+    } else if (quantity >= 50) {
+      return this.applyPercentageDiscount(price, 15);
+    } else if (quantity >= 10) {
+      return this.applyPercentageDiscount(price, 10);
+    }
+    return price;
+  }
+}
+
+export class OrderProcessor {
+  private nextOrderId: number = 1;
+
+  createOrder(cart: ShoppingCart): Order {
+    const items = cart.getItems();
+
+    if (items.length === 0) {
+      throw new Error("Cannot create order from empty cart");
+    }
+
+    const order: Order = {
+      id: `ORD-${this.nextOrderId++}`,
+      items: items,
+      total: cart.getTotal(),
+      status: "pending",
+      createdAt: new Date(),
+    };
+
+    return order;
+  }
+
+  updateOrderStatus(order: Order, newStatus: OrderStatus): void {
+    const validTransitions: Record<OrderStatus, OrderStatus[]> = {
+      pending: ["processing", "cancelled"],
+      processing: ["shipped", "cancelled"],
+      shipped: ["delivered"],
+      delivered: [],
+      cancelled: [],
+    };
+
+    const allowed = validTransitions[order.status];
+    if (!allowed.includes(newStatus)) {
+      throw new Error(`Cannot transition from ${order.status} to ${newStatus}`);
+    }
+
+    order.status = newStatus;
+  }
+
+  cancelOrder(order: Order): boolean {
+    if (order.status === "delivered") {
+      return false;
+    }
+
+    if (order.status === "cancelled") {
+      return false;
+    }
+
+    order.status = "cancelled";
+    return true;
+  }
+}
+
+export function searchProducts(products: Product[], query: string): Product[] {
+  const lowerQuery = query.toLowerCase();
+  return products.filter(
+    (p) =>
+      p.name.toLowerCase().includes(lowerQuery) ||
+      p.category.toLowerCase().includes(lowerQuery)
+  );
+}
+
+export function filterByCategory(
+  products: Product[],
+  category: string
+): Product[] {
+  return products.filter((p) => p.category === category);
+}
+
+export function filterByPriceRange(
+  products: Product[],
+  minPrice: number,
+  maxPrice: number
+): Product[] {
+  return products.filter((p) => p.price >= minPrice && p.price <= maxPrice);
+}
+
+export function sortByPrice(
+  products: Product[],
+  ascending: boolean = true
+): Product[] {
+  const sorted = [...products];
+  sorted.sort((a, b) => {
+    return ascending ? a.price - b.price : b.price - a.price;
+  });
+  return sorted;
+}

package/testcases/real-world/business-logic/config.yaml

@@ -0,0 +1 @@
+- business-logic.ts: should emit real-world business-logic program

package/testcases/real-world/calculator/calculator.ts

@@ -0,0 +1,29 @@
+export class Calculator {
+  add(a: number, b: number): number {
+    return a + b;
+  }
+
+  subtract(a: number, b: number): number {
+    return a - b;
+  }
+
+  multiply(a: number, b: number): number {
+    return a * b;
+  }
+
+  divide(a: number, b: number): number {
+    if (b === 0) {
+      throw new Error("Division by zero");
+    }
+    return a / b;
+  }
+}
+
+export function runCalculatorTests(): void {
+  const calc = new Calculator();
+
+  console.log("5 + 3 =", calc.add(5, 3));
+  console.log("10 - 4 =", calc.subtract(10, 4));
+  console.log("6 * 7 =", calc.multiply(6, 7));
+  console.log("20 / 5 =", calc.divide(20, 5));
+}

package/testcases/real-world/calculator/config.yaml

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

package/testcases/real-world/data-structures/config.yaml

@@ -0,0 +1 @@
+- data-structures.ts: should emit real-world data-structures program

package/testcases/real-world/data-structures/data-structures.ts

@@ -0,0 +1,133 @@
+export class Stack<T> {
+  private items: T[] = [];
+
+  push(item: T): void {
+    this.items.push(item);
+  }
+
+  pop(): T | undefined {
+    return this.items.pop();
+  }
+
+  peek(): T | undefined {
+    return this.items[this.items.length - 1];
+  }
+
+  isEmpty(): boolean {
+    return this.items.length === 0;
+  }
+
+  size(): number {
+    return this.items.length;
+  }
+
+  clear(): void {
+    this.items = [];
+  }
+}
+
+export class Queue<T> {
+  private items: T[] = [];
+
+  enqueue(item: T): void {
+    this.items.push(item);
+  }
+
+  dequeue(): T | undefined {
+    return this.items.shift();
+  }
+
+  front(): T | undefined {
+    return this.items[0];
+  }
+
+  isEmpty(): boolean {
+    return this.items.length === 0;
+  }
+
+  size(): number {
+    return this.items.length;
+  }
+
+  clear(): void {
+    this.items = [];
+  }
+}
+
+export class LinkedListNode<T> {
+  constructor(
+    public value: T,
+    public next: LinkedListNode<T> | null = null
+  ) {}
+}
+
+export class LinkedList<T> {
+  private head: LinkedListNode<T> | null = null;
+  private tail: LinkedListNode<T> | null = null;
+  private length: number = 0;
+
+  append(value: T): void {
+    const node = new LinkedListNode(value);
+
+    if (this.head === null) {
+      this.head = node;
+      this.tail = node;
+    } else {
+      if (this.tail) {
+        this.tail.next = node;
+      }
+      this.tail = node;
+    }
+
+    this.length++;
+  }
+
+  prepend(value: T): void {
+    const node = new LinkedListNode(value, this.head);
+    this.head = node;
+
+    if (this.tail === null) {
+      this.tail = node;
+    }
+
+    this.length++;
+  }
+
+  size(): number {
+    return this.length;
+  }
+
+  toArray(): T[] {
+    const result: T[] = [];
+    let current = this.head;
+
+    while (current !== null) {
+      result.push(current.value);
+      current = current.next;
+    }
+
+    return result;
+  }
+}
+
+export function testDataStructures(): void {
+  const stack = new Stack<number>();
+  stack.push(1);
+  stack.push(2);
+  stack.push(3);
+  console.log("Stack size:", stack.size());
+  console.log("Stack pop:", stack.pop());
+
+  const queue = new Queue<string>();
+  queue.enqueue("first");
+  queue.enqueue("second");
+  queue.enqueue("third");
+  console.log("Queue size:", queue.size());
+  console.log("Queue dequeue:", queue.dequeue());
+
+  const list = new LinkedList<number>();
+  list.append(10);
+  list.append(20);
+  list.prepend(5);
+  console.log("List as array:", list.toArray());
+}

package/testcases/real-world/functional/config.yaml

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

package/testcases/real-world/functional/functional.ts

@@ -0,0 +1,116 @@
+// Option type (Maybe monad)
+export type Option<T> = Some<T> | None;
+
+export class Some<T> {
+  readonly _tag = "Some";
+  constructor(readonly value: T) {}
+}
+
+export class None {
+  readonly _tag = "None";
+}
+
+export function some<T>(value: T): Option<T> {
+  return new Some(value);
+}
+
+export function none<T>(): Option<T> {
+  return new None();
+}
+
+export function isSome<T>(option: Option<T>): option is Some<T> {
+  return (option as Some<T>)._tag === "Some";
+}
+
+export function isNone<T>(option: Option<T>): option is None {
+  return (option as None)._tag === "None";
+}
+
+export function getOrElse<T>(option: Option<T>, defaultValue: T): T {
+  if (isSome(option)) {
+    return option.value;
+  }
+  return defaultValue;
+}
+
+// Pure functions for array operations
+export function pipe<A, B>(value: A, fn: (a: A) => B): B {
+  return fn(value);
+}
+
+export function compose<A, B, C>(f: (b: B) => C, g: (a: A) => B): (a: A) => C {
+  return (a: A) => f(g(a));
+}
+
+export function curry<A, B, C>(fn: (a: A, b: B) => C): (a: A) => (b: B) => C {
+  return (a: A) => (b: B) => fn(a, b);
+}
+
+export function partial<A, B, C>(fn: (a: A, b: B) => C, a: A): (b: B) => C {
+  return (b: B) => fn(a, b);
+}
+
+// Higher-order functions
+export function memoize<T extends any[], R>(
+  fn: (...args: T) => R
+): (...args: T) => R {
+  const cache = new Map<string, R>();
+
+  return (...args: T): R => {
+    const key = JSON.stringify(args);
+    if (cache.has(key)) {
+      return cache.get(key)!;
+    }
+
+    const result = fn(...args);
+    cache.set(key, result);
+    return result;
+  };
+}
+
+export function debounce<T extends any[]>(
+  fn: (...args: T) => void,
+  delayMs: number
+): (...args: T) => void {
+  let timeoutId: any;
+
+  return (...args: T): void => {
+    if (timeoutId !== undefined) {
+      clearTimeout(timeoutId);
+    }
+
+    timeoutId = setTimeout(() => {
+      fn(...args);
+    }, delayMs);
+  };
+}
+
+// Lazy evaluation
+export class Lazy<T> {
+  private value: T | undefined;
+  private computed: boolean = false;
+
+  constructor(private computer: () => T) {}
+
+  get(): T {
+    if (!this.computed) {
+      this.value = this.computer();
+      this.computed = true;
+    }
+    return this.value!;
+  }
+
+  map<U>(mapper: (value: T) => U): Lazy<U> {
+    return new Lazy(() => mapper(this.get()));
+  }
+}
+
+// Immutable operations
+export function assoc<T, K extends keyof T>(obj: T, key: K, value: T[K]): T {
+  return { ...obj, [key]: value };
+}
+
+export function dissoc<T, K extends keyof T>(obj: T, key: K): Omit<T, K> {
+  const { [key]: _, ...rest } = obj;
+  return rest;
+}

package/testcases/real-world/shapes/config.yaml

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

package/testcases/real-world/shapes/shapes.ts

@@ -0,0 +1,87 @@
+export abstract class Shape {
+  constructor(public color: string) {}
+
+  abstract area(): number;
+  abstract perimeter(): number;
+
+  describe(): string {
+    return `A ${this.color} shape with area ${this.area()} and perimeter ${this.perimeter()}`;
+  }
+}
+
+export class Circle extends Shape {
+  constructor(
+    color: string,
+    public radius: number
+  ) {
+    super(color);
+  }
+
+  area(): number {
+    return Math.PI * this.radius * this.radius;
+  }
+
+  perimeter(): number {
+    return 2 * Math.PI * this.radius;
+  }
+}
+
+export class Rectangle extends Shape {
+  constructor(
+    color: string,
+    public width: number,
+    public height: number
+  ) {
+    super(color);
+  }
+
+  area(): number {
+    return this.width * this.height;
+  }
+
+  perimeter(): number {
+    return 2 * (this.width + this.height);
+  }
+
+  isSquare(): boolean {
+    return this.width === this.height;
+  }
+}
+
+export class Triangle extends Shape {
+  constructor(
+    color: string,
+    public base: number,
+    public height: number,
+    public side1: number,
+    public side2: number
+  ) {
+    super(color);
+  }
+
+  area(): number {
+    return (this.base * this.height) / 2;
+  }
+
+  perimeter(): number {
+    return this.base + this.side1 + this.side2;
+  }
+}
+
+export function totalArea(shapes: Shape[]): number {
+  return shapes.reduce((sum, shape) => sum + shape.area(), 0);
+}
+
+export function findLargestShape(shapes: Shape[]): Shape | undefined {
+  if (shapes.length === 0) {
+    return undefined;
+  }
+
+  let largest = shapes[0];
+  for (const shape of shapes) {
+    if (shape.area() > largest.area()) {
+      largest = shape;
+    }
+  }
+  return largest;
+}

package/testcases/real-world/string-utils/config.yaml

@@ -0,0 +1 @@
+- string-utils.ts: should emit real-world string-utils program

package/testcases/real-world/string-utils/string-utils.ts

@@ -0,0 +1,47 @@
+export function capitalize(str: string): string {
+  if (str.length === 0) {
+    return str;
+  }
+  return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+}
+
+export function reverse(str: string): string {
+  return str.split("").reverse().join("");
+}
+
+export function truncate(str: string, maxLength: number): string {
+  if (str.length <= maxLength) {
+    return str;
+  }
+  return str.slice(0, maxLength - 3) + "...";
+}
+
+export function countWords(str: string): number {
+  return str.trim().split(/\s+/).length;
+}
+
+export function isPalindrome(str: string): boolean {
+  const cleaned = str.toLowerCase().replace(/[^a-z0-9]/g, "");
+  return cleaned === reverse(cleaned);
+}
+
+// Generic array utilities
+export function first<T>(arr: T[]): T | undefined {
+  return arr[0];
+}
+
+export function last<T>(arr: T[]): T | undefined {
+  return arr[arr.length - 1];
+}
+
+export function unique<T>(arr: T[]): T[] {
+  return arr.filter((item, index) => arr.indexOf(item) === index);
+}
+
+export function chunk<T>(arr: T[], size: number): T[][] {
+  const result: T[][] = [];
+  for (let i = 0; i < arr.length; i += size) {
+    result.push(arr.slice(i, i + size));
+  }
+  return result;
+}