ucn 3.0.0

package/test/fixtures/typescript/main.ts

@@ -0,0 +1,154 @@
+/**
+ * Main TypeScript test fixtures.
+ * Tests interfaces, generics, enums, and type annotations.
+ */
+
+import { Repository, DataService } from './repository';
+import { Config, Logger, LogLevel } from './types';
+
+// Enum definition
+enum Status {
+  Pending = 'pending',
+  Active = 'active',
+  Completed = 'completed',
+  Failed = 'failed'
+}
+
+// Interface
+interface Task {
+  id: string;
+  name: string;
+  status: Status;
+  priority: number;
+  metadata?: Record<string, unknown>;
+}
+
+// Type alias
+type TaskFilter = (task: Task) => boolean;
+type TaskTransformer<T> = (task: Task) => T;
+
+// Generic function
+function filterTasks<T extends Task>(tasks: T[], predicate: TaskFilter): T[] {
+  return tasks.filter(predicate);
+}
+
+// Generic class
+class TaskManager<T extends Task> {
+  private tasks: T[] = [];
+  private repository: Repository<T>;
+  private logger: Logger;
+
+  constructor(config: Config) {
+    this.repository = new Repository<T>(config);
+    this.logger = new Logger(config.logLevel || LogLevel.Info);
+  }
+
+  async addTask(task: T): Promise<void> {
+    this.logger.info(`Adding task: ${task.name}`);
+    this.tasks.push(task);
+    await this.repository.save(task);
+  }
+
+  async getTasks(filter?: TaskFilter): Promise<T[]> {
+    const allTasks = await this.repository.findAll();
+    if (filter) {
+      return filterTasks(allTasks, filter);
+    }
+    return allTasks;
+  }
+
+  async updateTask(id: string, updates: Partial<T>): Promise<T | null> {
+    const task = await this.repository.findById(id);
+    if (!task) {
+      this.logger.warn(`Task not found: ${id}`);
+      return null;
+    }
+    const updated = { ...task, ...updates };
+    await this.repository.save(updated);
+    return updated;
+  }
+
+  async deleteTask(id: string): Promise<boolean> {
+    this.logger.info(`Deleting task: ${id}`);
+    return this.repository.delete(id);
+  }
+
+  transformTasks<R>(transformer: TaskTransformer<R>): R[] {
+    return this.tasks.map(transformer);
+  }
+}
+
+// Async generator
+async function* taskGenerator(manager: TaskManager<Task>): AsyncGenerator<Task> {
+  const tasks = await manager.getTasks();
+  for (const task of tasks) {
+    yield task;
+  }
+}
+
+// Utility functions
+function createTask(name: string, priority: number = 1): Task {
+  return {
+    id: generateId(),
+    name,
+    status: Status.Pending,
+    priority
+  };
+}
+
+function generateId(): string {
+  return Math.random().toString(36).substring(2, 15);
+}
+
+// Higher-order function with generics
+function withRetry<T>(
+  fn: () => Promise<T>,
+  retries: number = 3
+): () => Promise<T> {
+  return async () => {
+    let lastError: Error | null = null;
+    for (let i = 0; i < retries; i++) {
+      try {
+        return await fn();
+      } catch (err) {
+        lastError = err as Error;
+      }
+    }
+    throw lastError;
+  };
+}
+
+// Overloaded function
+function processTask(task: Task): string;
+function processTask(tasks: Task[]): string[];
+function processTask(input: Task | Task[]): string | string[] {
+  if (Array.isArray(input)) {
+    return input.map(t => t.name);
+  }
+  return input.name;
+}
+
+// Decorator-style function (for class methods)
+function logged(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
+  const original = descriptor.value;
+  descriptor.value = function(...args: any[]) {
+    console.log(`Calling ${propertyKey}`);
+    return original.apply(this, args);
+  };
+  return descriptor;
+}
+
+export {
+  Status,
+  Task,
+  TaskFilter,
+  TaskTransformer,
+  TaskManager,
+  filterTasks,
+  taskGenerator,
+  createTask,
+  generateId,
+  withRetry,
+  processTask,
+  logged
+};

package/test/fixtures/typescript/package.json

@@ -0,0 +1 @@
+{"name": "typescript-fixtures", "version": "1.0.0"}

package/test/fixtures/typescript/repository.ts

@@ -0,0 +1,149 @@
+/**
+ * Repository pattern implementation with generics.
+ */
+
+import { Config, Logger, LogLevel } from './types';
+
+// Generic interface for entities
+interface Entity {
+  id: string;
+}
+
+// Repository interface
+interface IRepository<T extends Entity> {
+  save(entity: T): Promise<void>;
+  findById(id: string): Promise<T | null>;
+  findAll(): Promise<T[]>;
+  delete(id: string): Promise<boolean>;
+}
+
+// Abstract base class
+abstract class BaseRepository<T extends Entity> implements IRepository<T> {
+  protected logger: Logger;
+
+  constructor(protected config: Config) {
+    this.logger = new Logger(config.logLevel || LogLevel.Info);
+  }
+
+  abstract save(entity: T): Promise<void>;
+  abstract findById(id: string): Promise<T | null>;
+  abstract findAll(): Promise<T[]>;
+  abstract delete(id: string): Promise<boolean>;
+
+  protected logOperation(operation: string, entity?: T): void {
+    this.logger.debug(`${operation}: ${entity?.id || 'unknown'}`);
+  }
+}
+
+// Concrete repository implementation
+class Repository<T extends Entity> extends BaseRepository<T> {
+  private storage: Map<string, T> = new Map();
+
+  constructor(config: Config) {
+    super(config);
+  }
+
+  async save(entity: T): Promise<void> {
+    this.logOperation('save', entity);
+    this.storage.set(entity.id, entity);
+  }
+
+  async findById(id: string): Promise<T | null> {
+    this.logOperation('findById');
+    return this.storage.get(id) || null;
+  }
+
+  async findAll(): Promise<T[]> {
+    this.logOperation('findAll');
+    return Array.from(this.storage.values());
+  }
+
+  async delete(id: string): Promise<boolean> {
+    this.logOperation('delete');
+    return this.storage.delete(id);
+  }
+
+  async findWhere(predicate: (entity: T) => boolean): Promise<T[]> {
+    const all = await this.findAll();
+    return all.filter(predicate);
+  }
+
+  clear(): void {
+    this.storage.clear();
+  }
+}
+
+// Data service that uses repository
+class DataService<T extends Entity> {
+  private repository: Repository<T>;
+
+  constructor(config: Config) {
+    this.repository = new Repository<T>(config);
+  }
+
+  async create(entity: T): Promise<T> {
+    await this.repository.save(entity);
+    return entity;
+  }
+
+  async get(id: string): Promise<T | null> {
+    return this.repository.findById(id);
+  }
+
+  async list(): Promise<T[]> {
+    return this.repository.findAll();
+  }
+
+  async remove(id: string): Promise<boolean> {
+    return this.repository.delete(id);
+  }
+
+  async query(predicate: (entity: T) => boolean): Promise<T[]> {
+    return this.repository.findWhere(predicate);
+  }
+}
+
+// Caching repository decorator
+class CachedRepository<T extends Entity> implements IRepository<T> {
+  private cache: Map<string, T> = new Map();
+
+  constructor(private wrapped: IRepository<T>) {}
+
+  async save(entity: T): Promise<void> {
+    this.cache.set(entity.id, entity);
+    await this.wrapped.save(entity);
+  }
+
+  async findById(id: string): Promise<T | null> {
+    if (this.cache.has(id)) {
+      return this.cache.get(id)!;
+    }
+    const entity = await this.wrapped.findById(id);
+    if (entity) {
+      this.cache.set(id, entity);
+    }
+    return entity;
+  }
+
+  async findAll(): Promise<T[]> {
+    return this.wrapped.findAll();
+  }
+
+  async delete(id: string): Promise<boolean> {
+    this.cache.delete(id);
+    return this.wrapped.delete(id);
+  }
+
+  clearCache(): void {
+    this.cache.clear();
+  }
+}
+
+export {
+  Entity,
+  IRepository,
+  BaseRepository,
+  Repository,
+  DataService,
+  CachedRepository
+};

package/test/fixtures/typescript/types.ts

@@ -0,0 +1,114 @@
+/**
+ * Type definitions and utility types.
+ */
+
+// Log levels enum
+export enum LogLevel {
+  Debug = 0,
+  Info = 1,
+  Warn = 2,
+  Error = 3
+}
+
+// Configuration interface
+export interface Config {
+  apiUrl?: string;
+  timeout?: number;
+  logLevel?: LogLevel;
+  debug?: boolean;
+  retries?: number;
+}
+
+// Utility types
+export type Nullable<T> = T | null;
+export type Optional<T> = T | undefined;
+export type DeepPartial<T> = {
+  [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+
+// Result type for error handling
+export type Result<T, E = Error> =
+  | { success: true; value: T }
+  | { success: false; error: E };
+
+// Event types
+export interface Event<T = unknown> {
+  type: string;
+  payload: T;
+  timestamp: number;
+}
+
+export type EventHandler<T = unknown> = (event: Event<T>) => void | Promise<void>;
+
+// Logger class
+export class Logger {
+  private level: LogLevel;
+
+  constructor(level: LogLevel = LogLevel.Info) {
+    this.level = level;
+  }
+
+  private log(level: LogLevel, message: string, ...args: unknown[]): void {
+    if (level >= this.level) {
+      const prefix = LogLevel[level].toUpperCase();
+      console.log(`[${prefix}] ${message}`, ...args);
+    }
+  }
+
+  debug(message: string, ...args: unknown[]): void {
+    this.log(LogLevel.Debug, message, ...args);
+  }
+
+  info(message: string, ...args: unknown[]): void {
+    this.log(LogLevel.Info, message, ...args);
+  }
+
+  warn(message: string, ...args: unknown[]): void {
+    this.log(LogLevel.Warn, message, ...args);
+  }
+
+  error(message: string, ...args: unknown[]): void {
+    this.log(LogLevel.Error, message, ...args);
+  }
+
+  setLevel(level: LogLevel): void {
+    this.level = level;
+  }
+}
+
+// Type guards
+export function isError(value: unknown): value is Error {
+  return value instanceof Error;
+}
+
+export function isResult<T>(value: unknown): value is Result<T> {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'success' in value
+  );
+}
+
+// Factory function
+export function createConfig(overrides?: Partial<Config>): Config {
+  return {
+    apiUrl: 'https://api.example.com',
+    timeout: 5000,
+    logLevel: LogLevel.Info,
+    debug: false,
+    retries: 3,
+    ...overrides
+  };
+}
+
+// Utility function with generics
+export function unwrapResult<T>(result: Result<T>): T {
+  if (result.success) {
+    return result.value;
+  }
+  throw result.error;
+}
+
+// Mapped type example
+export type ReadonlyConfig = Readonly<Config>;
+export type ConfigKeys = keyof Config;