// The old way
type Color = 'red' | 'green' | 'blue';
type Palette = Record<string, Color | Color[]>;

const palette: Palette = {
  red: 'red',
  green: ['green', 'blue'],  // tuple-ish, but widened to Color[]
};

// palette.red is Color | Color[]
// TypeScript doesn't know it's specifically 'red' or that green is an array
palette.green.toUpperCase(); // ❌ Error — Color[] doesn't have toUpperCase
palette.red.toUpperCase();   // ❌ Error — Color | Color[] doesn't have toUpperCase

const palette = {
  red: 'red',
  green: ['green', 'blue'],
} satisfies Palette;

// Now TypeScript knows the specific types
palette.red.toUpperCase();   // ✅ red is string, has toUpperCase
palette.green.forEach(...);  // ✅ green is string[], has forEach

// Without const type parameter
function createActions<T extends string[]>(actions: T): T {
  return actions;
}

const actions = createActions(['increment', 'decrement', 'reset']);
// Type: string[] — loses the specific literal types!

// With const type parameter
function createActions<const T extends string[]>(actions: T): T {
  return actions;
}

const actions = createActions(['increment', 'decrement', 'reset']);
// Type: readonly ["increment", "decrement", "reset"] — specific literals preserved!

type Action = typeof actions[number];
// Type: "increment" | "decrement" | "reset"

function defineRoutes<const T extends Record<string, string>>(routes: T): T {
  return routes;
}

const ROUTES = defineRoutes({
  home: '/',
  users: '/users',
  userDetail: '/users/:id',
  settings: '/settings',
} as const);

type RouteName = keyof typeof ROUTES;  // 'home' | 'users' | 'userDetail' | 'settings'

function navigate(route: RouteName) {
  window.location.href = ROUTES[route];
}

navigate('home');       // ✅
navigate('profile');    // ❌ TypeScript error — 'profile' not a valid route

type Middleware<T extends unknown[]> = (...args: T) => Promise<void>;

// Compose middleware with type safety
type WithLogging<T extends unknown[]> = (...args: [...T, { requestId: string }]) => Promise<void>;

function withLogging<T extends unknown[]>(
  fn: Middleware<T>
): WithLogging<T> {
  return async (...args) => {
    const requestId = args[args.length - 1] as { requestId: string };
    console.log(`[${requestId.requestId}] Starting`);
    await fn(...args.slice(0, -1) as T);
    console.log(`[${requestId.requestId}] Done`);
  };
}

type Pipe<T extends unknown[]> = T extends [infer First, ...infer Rest]
  ? Rest extends [infer Second, ...infer _]
    ? First extends (...args: any[]) => infer R
      ? Second extends (arg: R) => any
        ? [...Pipe<[Second, ...Rest]>]
        : never
      : never
    : T
  : never;

function pipe<A, B>(f: (a: A) => B): (a: A) => B;
function pipe<A, B, C>(f: (a: A) => B, g: (b: B) => C): (a: A) => C;
function pipe<A, B, C, D>(f: (a: A) => B, g: (b: B) => C, h: (c: C) => D): (a: A) => D;
// ... overloads for longer pipelines

const process = pipe(
  (s: string) => s.trim(),
  (s: string) => s.toLowerCase(),
  (s: string) => s.split(' ')
);

process("  Hello World  ");  // string[] — fully typed

// Extract the resolved type of a Promise, recursively
type DeepAwaited<T> = T extends Promise<infer U>
  ? DeepAwaited<U>
  : T;

type Test1 = DeepAwaited<Promise<Promise<string>>>;  // string
type Test2 = DeepAwaited<Promise<number[]>>;          // number[]

// Extract function return types more precisely
type AsyncReturnType<T extends (...args: any[]) => Promise<any>> = 
  T extends (...args: any[]) => Promise<infer R> ? R : never;

async function fetchUser(id: string): Promise<{ name: string; email: string }> {
  // ...
}

type User = AsyncReturnType<typeof fetchUser>;  // { name: string; email: string }

// Extract only string-valued keys from an object type
type StringKeys<T> = {
  [K in keyof T]: T[K] extends string ? K : never
}[keyof T];

type Config = {
  host: string;
  port: number;
  debug: boolean;
  name: string;
};

type StringConfigKeys = StringKeys<Config>;  // "host" | "name"

// Before isolatedDeclarations
export function getUser(id: string) {  // Return type inferred
  return db.users.findById(id);
}

// With isolatedDeclarations — explicit annotation required
export function getUser(id: string): Promise<User | null> {  // ✅ Explicit
  return db.users.findById(id);
}

// Also errors:
export const config = {  // ❌ Object type needs explicit annotation
  host: 'localhost',
  port: 5432,
};

export const config: DatabaseConfig = {  // ✅
  host: 'localhost',
  port: 5432,
};

// Without using — easy to forget cleanup
async function processFile(path: string) {
  const file = await openFile(path);
  try {
    const data = await file.read();
    return transform(data);
  } finally {
    await file.close();  // Easy to forget, especially with early returns
  }
}

// With using — cleanup is guaranteed
async function processFile(path: string) {
  await using file = await openFile(path);
  // file.close() is called automatically when the function exits
  const data = await file.read();
  return transform(data);
}

class DatabaseConnection {
  private connection: pg.Client;
  
  constructor(private config: DatabaseConfig) {}
  
  async connect() {
    this.connection = new pg.Client(this.config);
    await this.connection.connect();
    return this;
  }
  
  async query<T>(sql: string, params?: unknown[]): Promise<T[]> {
    const result = await this.connection.query(sql, params);
    return result.rows;
  }
  
  async [Symbol.asyncDispose]() {
    await this.connection.end();
  }
}

// Usage — connection always closed, even if query throws
async function getUsers(): Promise<User[]> {
  await using db = await new DatabaseConnection(config).connect();
  return db.query<User>('SELECT * FROM users WHERE active = true');
}