@tsonic/emitter 0.0.1 → 0.0.2

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

@@ -1,67 +0,0 @@
-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

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

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

@@ -1,215 +0,0 @@
-// 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

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

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

@@ -1,29 +0,0 @@
-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

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

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

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

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

@@ -1,133 +0,0 @@
-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

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

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

@@ -1,116 +0,0 @@
-// 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

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

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

@@ -1,87 +0,0 @@
-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

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

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

@@ -1,47 +0,0 @@
-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;
-}