TypeScript 4 1

// String literal type construction
type World = "world";
type Greeting = `hello ${World}`; // Type: "hello world"

// With unions - creates all combinations
type Color = "red" | "blue" | "green";
type Size = "small" | "large";
type Style = `${Color}-${Size}`;
// Type: "red-small" | "red-large" | "blue-small" | "blue-large" | "green-small" | "green-large"

type Uppercase<S extends string> = /* intrinsic */;
type Lowercase<S extends string> = /* intrinsic */;
type Capitalize<S extends string> = /* intrinsic */;
type Uncapitalize<S extends string> = /* intrinsic */;

// Examples
type Loud = Uppercase<'hello'>; // "HELLO"
type Quiet = Lowercase<'WORLD'>; // "world"
type Title = Capitalize<'typescript'>; // "Typescript"
type Variable = Uncapitalize<'MyVariable'>; // "myVariable"

// Define API endpoints
type HTTPMethod = "get" | "post" | "put" | "delete";
type ResourcePath = "users" | "posts" | "comments";

// Generate type-safe route names
type APIRoute = `${HTTPMethod}_${ResourcePath}`;
// Type: "get_users" | "get_posts" | "get_comments" | "post_users" | ...

// Route handler registry
type RouteHandlers = {
  [K in APIRoute]: (req: Request) => Promise<Response>;
};

const handlers: RouteHandlers = {
  get_users: async (req) => {
    /* ... */
  },
  post_users: async (req) => {
    /* ... */
  },
  get_posts: async (req) => {
    /* ... */
  },
  // TypeScript enforces all combinations must be implemented
};

// CSS property prefixes
type CSSPrefix = "-webkit-" | "-moz-" | "-ms-" | "-o-" | "";
type CSSProperty = "transform" | "transition" | "animation";

// Generate all vendor-prefixed properties
type PrefixedProperty = `${CSSPrefix}${CSSProperty}`;
// Type: "transform" | "-webkit-transform" | "-moz-transform" | ...

// Style object with autocomplete
type StyleObject = {
  [K in PrefixedProperty]?: string;
};

const styles: StyleObject = {
  transform: "rotate(45deg)",
  "-webkit-transform": "rotate(45deg)",
  "-moz-transform": "rotate(45deg)",
  // Full IDE autocomplete for all variants
};

// Event categories and actions
type Entity = "user" | "post" | "comment";
type Action = "created" | "updated" | "deleted";

// Generate event names: "user:created", "post:updated", etc.
type EventName = `${Entity}:${Action}`;

// Event payload mapping
type EventPayload<E extends EventName> = E extends `user:${Action}`
  ? { userId: string; timestamp: Date }
  : E extends `post:${Action}`
    ? { postId: string; authorId: string }
    : E extends `comment:${Action}`
      ? { commentId: string; postId: string }
      : never;

// Type-safe event emitter
class TypedEventEmitter {
  private handlers: Map<EventName, Set<Function>> = new Map();

  on<E extends EventName>(event: E, handler: (payload: EventPayload<E>) => void): void {
    if (!this.handlers.has(event)) {
      this.handlers.set(event, new Set());
    }
    this.handlers.get(event)!.add(handler);
  }

  emit<E extends EventName>(event: E, payload: EventPayload<E>): void {
    const handlers = this.handlers.get(event);
    if (handlers) {
      handlers.forEach((handler) => handler(payload));
    }
  }
}

// Usage with full type safety
const emitter = new TypedEventEmitter();

emitter.on("user:created", (payload) => {
  // payload type: { userId: string; timestamp: Date }
  console.log(`User ${payload.userId} created at ${payload.timestamp}`);
});

emitter.emit("user:created", {
  userId: "user-123",
  timestamp: new Date(),
});

// Before 4.1 - Could only preserve keys
type Getters<T> = {
  [K in keyof T]: () => T[K];
};

// With 4.1 - Can transform keys
type Getters<T> = {
  [K in keyof T as `get${Capitalize<K & string>}`]: () => T[K];
};

// Example
interface Person {
  name: string;
  age: number;
}

type PersonGetters = Getters<Person>;
// Type: { getName: () => string; getAge: () => number; }

// Utility type for case conversion
type SnakeToCamel<S extends string> = S extends `${infer Head}_${infer Tail}`
  ? `${Head}${Capitalize<SnakeToCamel<Tail>>}`
  : S;

// Transform all keys from snake_case to camelCase
type CamelCaseKeys<T> = {
  [K in keyof T as SnakeToCamel<K & string>]: T[K];
};

// API response (snake_case from backend)
interface APIResponse {
  user_id: string;
  first_name: string;
  last_name: string;
  created_at: Date;
  is_active: boolean;
}

// Frontend model (camelCase)
type User = CamelCaseKeys<APIResponse>;
// Type: {
//   userId: string;
//   firstName: string;
//   lastName: string;
//   createdAt: Date;
//   isActive: boolean;
// }

// Transformation function
function transformResponse(response: APIResponse): User {
  return {
    userId: response.user_id,
    firstName: response.first_name,
    lastName: response.last_name,
    createdAt: response.created_at,
    isActive: response.is_active,
  };
}

// Filter out private properties (starting with _)
type PublicKeys<T> = {
  [K in keyof T as K extends `_${string}` ? never : K]: T[K];
};

// Example class
interface InternalState {
  _id: string;
  _version: number;
  name: string;
  value: number;
  _metadata: Record<string, unknown>;
}

type PublicState = PublicKeys<InternalState>;
// Type: { name: string; value: number; }
// Private fields (_id, _version, _metadata) removed

// Model definition
interface UserModel {
  id: string;
  name: string;
  email: string;
}

// Generate create, read, update, delete methods
type CRUDMethods<T> = {
  [K in keyof T as `set${Capitalize<K & string>}`]: (value: T[K]) => void;
} & {
  [K in keyof T as `get${Capitalize<K & string>}`]: () => T[K];
};

type UserCRUD = CRUDMethods<UserModel>;
// Type: {
//   setId: (value: string) => void;
//   getId: () => string;
//   setName: (value: string) => void;
//   getName: () => string;
//   setEmail: (value: string) => void;
//   getEmail: () => string;
// }

// Implementation
class User implements UserCRUD {
  private data: UserModel = { id: "", name: "", email: "" };

  setId(value: string) {
    this.data.id = value;
  }
  getId() {
    return this.data.id;
  }
  setName(value: string) {
    this.data.name = value;
  }
  getName() {
    return this.data.name;
  }
  setEmail(value: string) {
    this.data.email = value;
  }
  getEmail() {
    return this.data.email;
  }
}

// Flatten nested arrays recursively
type Flatten<T> = T extends Array<infer U> ? Flatten<U> : T;

// Examples
type Nested = [1, [2, [3, [4]]]];
type Flat = Flatten<Nested>; // Type: 1 | 2 | 3 | 4

type DeepArray = string[][][];
type Element = Flatten<DeepArray>; // Type: string

// Get value type at deep path
type DeepValue<T, P extends string> = P extends `${infer Key}.${infer Rest}`
  ? Key extends keyof T
    ? DeepValue<T[Key], Rest>
    : never
  : P extends keyof T
    ? T[P]
    : never;

// Example object
interface Config {
  database: {
    connection: {
      host: string;
      port: number;
    };
    pool: {
      min: number;
      max: number;
    };
  };
  cache: {
    enabled: boolean;
  };
}

// Usage
type HostType = DeepValue<Config, "database.connection.host">; // string
type MaxPoolType = DeepValue<Config, "database.pool.max">; // number
type CacheType = DeepValue<Config, "cache.enabled">; // boolean

// Type-safe getter function
function getDeepValue<T, P extends string>(obj: T, path: P): DeepValue<T, P> {
  const keys = path.split(".");
  let result: any = obj;
  for (const key of keys) {
    result = result[key];
  }
  return result;
}

// Usage with type safety
const config: Config = {
  /* ... */
};
const host = getDeepValue(config, "database.connection.host"); // Type: string
const port = getDeepValue(config, "database.connection.port"); // Type: number

const users: Record<string, User> = {};
const user = users["nonexistent"]; // Type: User (unsafe!)
console.log(user.name); // Runtime error - user is undefined

const users: Record<string, User> = {};
const user = users["nonexistent"]; // Type: User | undefined (safe!)

// Forced to check
if (user) {
  console.log(user.name); // ✅ Safe
}

// tsconfig.json
{
  "compilerOptions": {
    "baseUrl": ".", // ❌ Required even if not using baseUrl features
    "paths": {
      "@app/*": ["src/app/*"],
      "@lib/*": ["src/lib/*"]
    }
  }
}

// tsconfig.json
{
  "compilerOptions": {
    "paths": {
      "@app/*": ["src/app/*"],
      "@lib/*": ["src/lib/*"]
    }
    // ✅ No baseUrl needed
  }
}

npm install -D typescript@4.1

// Before
type Route = "api/users" | "api/posts";

// After
type Resource = "users" | "posts";
type Route = `api/${Resource}`;

// Refactor getter generation
type Getters<T> = {
  [K in keyof T as `get${Capitalize<K & string>}`]: () => T[K];
};