// ❌ BEFORE: Inferred return type — requires full type check to generate .d.ts
export function createUser(name: string, role: string) {
  return { id: crypto.randomUUID(), name, role, createdAt: new Date() }
}

// ✅ AFTER: Explicit return type — .d.ts can be generated without type inference
export function createUser(name: string, role: string): {
  id: string
  name: string
  role: string
  createdAt: Date
} {
  return { id: crypto.randomUUID(), name, role, createdAt: new Date() }
}

// Or with a named type (preferred for readability)
export interface User {
  id: string
  name: string
  role: string
  createdAt: Date
}

export function createUser(name: string, role: string): User {
  return { id: crypto.randomUUID(), name, role, createdAt: new Date() }
}

// TypeScript 5.x: Had to annotate this explicitly
const transform = <T, R>(items: T[], fn: (item: T) => R): R[] => {
  return items.map(fn)
}
// Usage required annotation:
const result = transform<string, number>(["1", "2", "3"], Number)

// TypeScript 6.0: Inference works bi-directionally
const transform = <T, R>(items: T[], fn: (item: T) => R): R[] => {
  return items.map(fn)
}
// No annotation needed — R is inferred from fn's return type:
const result = transform(["1", "2", "3"], Number) // result: number[]

type ExtractPromise<T> = T extends Promise<infer U> ? U : T

// TypeScript 6.0 handles nested conditional inference much better:
type DeepUnwrap<T> = T extends Promise<infer U>
  ? DeepUnwrap<U>
  : T extends Array<infer E>
  ? DeepUnwrap<E>[]
  : T

// Now works correctly with complex nested types
type Result = DeepUnwrap<Promise<Promise<string[]>>>
// Previously: string | string[] (incorrect)
// Now:       string[] (correct)

// ❌ Old way: manual dynamic imports with loading states
let heavyModule: typeof import('./heavy-computation') | null = null

async function compute(data: number[]) {
  if (!heavyModule) {
    heavyModule = await import('./heavy-computation')
  }
  return heavyModule.process(data)
}

// ✅ New way: import defer
import defer * as heavyModule from './heavy-computation'

function compute(data: number[]) {
  // Module is only loaded when first accessed
  return heavyModule.process(data)
}

// Heavy parsers / formatters
import defer * as yaml from 'js-yaml'
import defer * as csv from 'papaparse'

function parseFile(content: string, format: 'yaml' | 'csv') {
  if (format === 'yaml') return yaml.load(content)        // yaml loaded here
  if (format === 'csv') return csv.parse(content).data    // csv loaded here
}

// Feature flags with optional heavy dependencies
import defer * as analytics from './analytics'
import defer * as monitoring from './monitoring'

function initApp(features: AppFeatures) {
  if (features.analytics) analytics.init()    // Only if needed
  if (features.monitoring) monitoring.init()  // Only if needed
}

// TypeScript 6.0: using with class decorators
class DatabaseConnection {
  constructor(private url: string) {
    console.log(`Connected to ${url}`)
  }
  
  query(sql: string) { /* ... */ }
  
  [Symbol.dispose]() {
    console.log(`Disconnected from ${this.url}`)
  }
}

async function processOrders() {
  using db = new DatabaseConnection(process.env.DATABASE_URL!)
  using cache = await RedisClient.connect(process.env.REDIS_URL!)
  
  const orders = await db.query('SELECT * FROM orders WHERE status = ?', ['pending'])
  const cachedResult = await cache.get('order-summary')
  
  // db.dispose() and cache.dispose() called automatically
  // even if an exception is thrown
  return orders
}

// TypeScript 6.0 also handles nested using correctly:
async function* streamProcessor() {
  await using stream = createReadStream('large-file.csv')
  
  for await (const chunk of stream) {
    yield processChunk(chunk)
  }
  // stream.close() called automatically after generator completes
}

type ApiResponse<T> = 
  | { status: 'success'; data: T; timestamp: number }
  | { status: 'error'; code: number; message: string }
  | { status: 'pending'; progress: number }

// TypeScript 6.0: Narrowing now works with computed property access
function handleResponse<T>(response: ApiResponse<T>, key: 'status') {
  const s = response[key]  // Previously: string, Now: 'success' | 'error' | 'pending'
  
  if (s === 'success') {
    response.data  // ✅ TypeScript knows this exists
  }
}

// Also improved: narrowing in switch with fallthrough
function processStatus(response: ApiResponse<unknown>) {
  switch (response.status) {
    case 'success':
    case 'pending':
      // TypeScript 6.0 correctly unions these two cases:
      // response: { status: 'success', data: unknown, timestamp: number }
      //         | { status: 'pending', progress: number }
      console.log('Non-error state')
      break
    case 'error':
      console.error(response.message)  // ✅ correctly narrowed
      break
  }
}