// tsconfig.json
{
  "compilerOptions": {
    "target": "ES2024",  // Yeni!
    "lib": ["ES2024", "DOM"]
  }
}

interface User {
  name: string
  role: 'admin' | 'user' | 'guest'
  department: string
}

const users: User[] = [
  { name: 'Ali', role: 'admin', department: 'IT' },
  { name: 'Ayşe', role: 'user', department: 'HR' },
  { name: 'Mehmet', role: 'admin', department: 'IT' },
]

// ES2024 groupBy - TypeScript 5.7 ile full support
const byRole = Object.groupBy(users, user => user.role)
/*
{
  admin: [{ name: 'Ali', ... }, { name: 'Mehmet', ... }],
  user: [{ name: 'Ayşe', ... }]
}
*/

// Map.groupBy - memory-efficient alternative
const byDepartment = Map.groupBy(users, user => user.department)
// Map { 'IT' => [...], 'HR' => [...] }

// TypeScript correctly infers types!
type ByRole = typeof byRole
// { admin?: User[], user?: User[], guest?: User[] }

// Before
import { helper } from './utils.ts'  // Error: Cannot find module

// After (with --rewriteRelativeImportExtensions)
import { helper } from './utils.ts'
// Compiles to: import { helper } from './utils.js'

// tsconfig.json
{
  "compilerOptions": {
    "rewriteRelativeImportExtensions": true
  }
}

function processData() {
  let result: number

  if (Math.random() > 0.5) {
    result = 42
  }

  // TypeScript 5.7 Error:
  // Variable 'result' is used before being assigned
  console.log(result)
}

// Fix: Initialize or ensure all paths assign
function processData() {
  let result: number = 0  // ✅ Initialize

  if (Math.random() > 0.5) {
    result = 42
  } else {
    result = 0  // ✅ All paths covered
  }

  console.log(result)
}

// tsconfig.json
{
  "compilerOptions": {
    "baseUrl": ".",
    "paths": {
      "@/*": ["src/*"],
      "@components/*": ["src/components/*"],
      "@utils/*": ["src/utils/*"]
    }
  }
}

// Artık daha iyi resolution
import { Button } from '@components/Button'
import { formatDate } from '@utils/date'

// TypeScript 5.7 correctly resolves even complex path patterns

// math.ts
export function add(a: number, b: number): number {
  return a + b
}

export interface Calculator {
  add: (a: number, b: number) => number
  subtract: (a: number, b: number) => number
}

const result = add(5, 3)
console.log(result)

# Compile et
tsc math.ts

# Sonra çalıştır
node math.js

# Direkt çalıştır, compile yok!
node --experimental-strip-types math.ts

// ✅ Erasable - --erasableSyntaxOnly ile çalışır
interface User {
  name: string
  age: number
}

function greet(user: User): string {
  return `Hello, ${user.name}!`
}

type Status = 'active' | 'inactive'

// ❌ Non-erasable - hata verir
enum Role {  // Error: Enums are not allowed
  Admin,
  User
}

namespace Utils {  // Error: Namespaces are not allowed
  export function helper() {}
}

class Person {
  constructor(public name: string) {}  // Error: Parameter properties
}

# No build step - instant feedback
node --experimental-strip-types prototype.ts

// deploy.ts
import { exec } from 'child_process'

async function deploy(env: 'staging' | 'production') {
  console.log(`Deploying to ${env}...`)
  // Deployment logic
}

deploy('production')

# Direkt çalıştır
node --experimental-strip-types deploy.ts

// Vercel/Netlify functions direkt TypeScript
export default async function handler(req: Request): Promise<Response> {
  return new Response('Hello from TS!')
}

# Traditional workflow
tsc -> takes 2-5 seconds
node output.js

# Direct execution
node --experimental-strip-types app.ts -> instant!

// Eski yöntem - verbose
let resolve: (value: number) => void
let reject: (reason?: any) => void

const promise = new Promise<number>((res, rej) => {
  resolve = res
  reject = rej
})

// ES2024 - clean
const { promise, resolve, reject } = Promise.withResolvers<number>()

// TypeScript correctly infers types
setTimeout(() => resolve(42), 1000)

// ArrayBuffer transfer
const buffer = new ArrayBuffer(1024)
const transferred = buffer.transfer(2048)  // Yeni boyut

// Typed array methods
const uint8 = new Uint8Array([1, 2, 3, 4, 5])

// New methods with proper typing
const reversed = uint8.toReversed()  // Immutable
const sorted = uint8.toSorted()      // Immutable
const sliced = uint8.with(2, 99)     // [1, 2, 99, 4, 5]

// TypeScript 5.8 - Smart return type inference
function getData(useCache: boolean) {
  if (useCache) {
    return getCachedData()  // Returns Promise<Data>
  } else {
    return getDataSync()    // Returns Data
  }
}

// Inferred type correctly: Promise<Data> | Data
type Result = ReturnType<typeof getData>

// Daha complex örnek
function process<T>(
  data: T,
  async: boolean
): async extends true ? Promise<T> : T {
  if (async) {
    return Promise.resolve(data) as any
  }
  return data as any
}

const syncResult = process({ id: 1 }, false)  // { id: number }
const asyncResult = process({ id: 1 }, true)  // Promise<{ id: number }>

type EventName = 'click' | 'focus' | 'blur'
type ElementType = 'button' | 'input'

// TypeScript 5.7 - Better template literal inference
type Handler<E extends EventName, T extends ElementType> =
  `on${Capitalize<E>}${Capitalize<T>}`

type ClickHandlers = Handler<'click', 'button' | 'input'>
// 'onClickButton' | 'onClickInput'

// Real-world example
type APIEndpoint = `/api/${'users' | 'posts'}/${'list' | 'detail'}`
// '/api/users/list' | '/api/users/detail' | '/api/posts/list' | ...

const endpoint: APIEndpoint = '/api/users/list'  // ✅
const invalid: APIEndpoint = '/api/comments/list'  // ❌ Error

function processValue(value: string | number | null | undefined) {
  // TypeScript 5.8 - Smarter narrowing
  if (value) {
    // Type: string | number (null and undefined eliminated)
    console.log(value.toString())
  }

  if (typeof value === 'string' && value) {
    // Type: string (empty string also eliminated)
    console.log(value.toUpperCase())
  }
}

# TypeScript 5.6
tsc --build  # ~8.5 seconds

# TypeScript 5.8
tsc --build  # ~6.2 seconds (27% faster)

// Büyük union types artık daha az memory kullanıyor
type LargeUnion =
  | 'option1' | 'option2' | 'option3'
  | 'option4' | 'option5' | 'option6'
  // ... 100+ options

// TypeScript 5.8 bu tür union'ları çok daha efficiently handle ediyor

// Artık hata veriyor
const keys = Object.keys({ a: 1, b: 2 })
keys.forEach(key => {
  console.log(obj[key])  // Error: obj'de key yok
})

// Fix: Proper typing
const obj = { a: 1, b: 2 }
const keys = Object.keys(obj) as Array<keyof typeof obj>
keys.forEach(key => {
  console.log(obj[key])  // ✅
})

// Removed: prepend/append on lib paths
// Use references instead

// Before
"files": ["./typings/custom.d.ts"]

// After
/// <reference path="./typings/custom.d.ts" />

// TypeScript 5.8 Error
const a: number = 5
const b: string = "5"

if (a === b) {}  // Error: Bu comparison her zaman false

# Check Node version
node --version  # Must be >= 22.0.0

# Update if needed
nvm install 22
nvm use 22

# 1. Update TypeScript
npm install -D typescript@latest

# 2. Update @types packages
npm install -D @types/node@latest

# 3. Run type checks
tsc --noEmit

# 4. Fix errors iteratively
# 5. Update tsconfig target
{
  "compilerOptions": {
    "target": "ES2024",
    "module": "NodeNext"
  }
}

{
  "compilerOptions": {
    // Modern target
    "target": "ES2024",
    "lib": ["ES2024", "DOM"],

    // Module resolution
    "module": "NodeNext",
    "moduleResolution": "NodeNext",

    // Type checking (strict!)
    "strict": true,
    "noUncheckedIndexedAccess": true,
    "noUnusedLocals": true,
    "noUnusedParameters": true,
    "noFallthroughCasesInSwitch": true,

    // Emit
    "declaration": true,
    "sourceMap": true,
    "removeComments": true,

    // Path mapping
    "baseUrl": ".",
    "paths": {
      "@/*": ["src/*"]
    },

    // TypeScript 5.7+ features
    "rewriteRelativeImportExtensions": true
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules", "dist"]
}

// package.json
{
  "scripts": {
    "dev": "node --experimental-strip-types --watch src/index.ts",
    "build": "tsc",
    "type-check": "tsc --noEmit",
    "test": "node --experimental-strip-types --test src/**/*.test.ts"
  }
}

# .github/workflows/ci.yml
name: CI
on: [push, pull_request]

jobs:
  type-check:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '23'
      - run: npm install
      - run: npm run type-check
      - run: npm run build
      - run: npm test