Utility types & advanced.
The vocabulary of type programming.

interface User {
id: string;
name: string;
email: string;
password: string;
age?: number;
}

// ─── Partial: all properties optional ────────
type PartialUser = Partial;
// { id?: string; name?: string; email?: string; password?: string; age?: number }
const patch: PartialUser = { name: 'Alice' }; // ✅ partial update

// ─── Required: all properties required ───────
type FullUser = Required;
// age is now required (number, not number | undefined)

// ─── Pick: keep only these keys ──────────────
type UserPreview = Pick'id' | 'name'>;
// { id: string; name: string }
const preview: UserPreview = { id: '1', name: 'Alice' };

// ─── Omit: remove these keys ─────────────────
type SafeUser = Omit'password'>;
// { id, name, email, age } — everything except password

// ─── Record: dictionary with typed keys ──────
type Role = 'admin' | 'user' | 'guest';
type Permissions = Recordstring[]>;
const perms: Permissions = {
admin: ['read', 'write', 'delete'],
user: ['read', 'write'],
guest: ['read']
// ❌ Missing 'guest' key = compile error (Record enforces all keys)
};

// ─── Readonly: mark all properties readonly ──
type FrozenUser = Readonly;
const fu: FrozenUser = { id: '1', name: 'A', email: 'a@x', password: 'x' };
// fu.name = 'B'; // ❌ Cannot assign to 'name' (read-only)

console.log(patch, preview, perms);

// ─── ReturnType: extract the return type ────
function createUser(name: string, email: string) {
return {
id: crypto.randomUUID(),
name,
email,
createdAt: new Date()
};
}

type User = ReturnType<typeof createUser>;
// { id: string; name: string; email: string; createdAt: Date }
// No duplication — the function defines the shape, ReturnType pulls it out.

const u: User = createUser('Alice', 'a@x.com');

// ─── Parameters: extract param types ─────────
type CreateUserArgs = Parameters<typeof createUser>;
// [string, string]

const args: CreateUserArgs = ['Bob', 'b@x.com'];
// const bad: CreateUserArgs = ['x']; // ❌ needs 2 elements

// ─── Works with function types too ───────────
type Handler = (event: MouseEvent, x: number) => boolean;
type HandlerReturn = ReturnType; // boolean
type HandlerArgs = Parameters; // [MouseEvent, number]

// ─── Awaited: unwrap promises ────────────────
async function fetchUser(id: string): Promise {
return { id, name: 'x', email: 'x', createdAt: new Date() };
}

type FetchedUser = Awaited<ReturnType<typeof fetchUser>>;
// User — unwraps the Promise

// ─── NonNullable: remove null/undefined ──────
type MaybeUser = User | null | undefined;
type SafeUser = NonNullable;
// User

// ─── The pattern: sync types by extraction ───
// Bad: function f() { return { a: 1 }; } type R = { a: number }; // duplicate
// Good: function f() { return { a: 1 }; } type R = ReturnType; // synced

console.log(u.name, args, perms);

interface User {
id: string;
name: string;
email: string;
age: number;
}

// ─── keyof: union of property names ──────────
type UserKey = keyof User;
// 'id' | 'name' | 'email' | 'age'

const k: UserKey = 'name'; // ✅
// const bad: UserKey = 'foo'; // ❌ 'foo' not a key of User

// ─── The get pattern ─────────────────────────
function getextends keyof T>(obj: T, key: K): T[K] {
return obj[key];
}

const user: User = { id: '1', name: 'Alice', email: 'a@x', age: 28 };
const name = get(user, 'name'); // string
const age = get(user, 'age'); // number
// get(user, 'foo'); // ❌ 'foo' is not a key of User

// ─── typeof: value → type ───────────────────
const config = {
host: 'localhost',
port: 3000,
debug: true
};

type Config = typeof config;
// { host: string; port: number; debug: boolean }

function start(c: Config): string {
return ``${c.host}:{c.debug ? ' (debug)' : ''}`;
}

// ─── typeof on functions ─────────────────────
function greet(name: string): string {
return Hi, ${name}`;
}

type GreetFn = typeof greet;
// (name: string) => string

// ─── keyof typeof: keys from a value ─────────
type ConfigKey = keyof typeof config;
// 'host' | 'port' | 'debug'

console.log(name, age, k, start(config));

interface User {
id: string;
name: string;
age: number;
}

// ─── These are how utilities are actually built ───
type MyPartial = { [K in keyof T]?: T[K] };
type MyRequired = { [K in keyof T]-?: T[K] };
type MyReadonly = { readonly [K in keyof T]: T[K] };

// MyPartial = { id?: string; name?: string; age?: number }

// ─── Modifiers: + and - ─────────────────────
// ? adds optional
// -? removes optional (Required)
// readonly adds readonly
// -readonly removes readonly

type Mutable = { -readonly [K in keyof T]: T[K] };
// Removes readonly from every field (the inverse of Readonly)

// ─── Change value types via mapped type ──────
type Stringify = { [K in keyof T]: string };
// { id: string; name: string; age: string }

type Nullable = { [K in keyof T]: T[K] | null };
// { id: string | null; name: string | null; age: number | null }

// ─── Map over a subset of keys ───────────────
type PickByValue = {
[K in keyof T as T[K] extends V ? K : never]: T[K]
};
// Keeps only keys whose values extend V
type StringKeys = PickByValuestring>;
// { id: string; name: string } — age filtered out

// ─── Conditional value mapping ───────────────
type DeepReadonly = {
readonly [K in keyof T]: T[K] extends object ? DeepReadonly : T[K]
};

const p: MyPartial = { name: 'Alice' };
const sk: StringKeys = { id: '1', name: 'A' };

console.log(p, sk);

// ─── Basic template literal type ─────────────
type Greeting = Hello, ${string}`;

const g1: Greeting = 'Hello, Alice'; // ✅
const g2: Greeting = 'Hello, world'; // ✅
// const bad: Greeting = 'Hi, Alice'; // ❌ must start with 'Hello, '

// ─── Event names ─────────────────────────────
type Event = 'click' | 'focus' | 'blur';
type Handler = on${Capitalize}`;
// 'onClick' | 'onFocus' | 'onBlur'

const h: Handler = 'onClick'; // ✅
// const bad: Handler = 'onScroll'; // ❌ not a known event

// ─── Route patterns ──────────────────────────
type Route = /users/${string}/posts/${string};

const r1: Route = '/users/123'; // ✅
const r2: Route = '/posts/abc'; // ✅
// const bad: Route = '/comments/1'; // ❌ not in the union

// ─── Dot-path keys ───────────────────────────
interface Config {
host: string;
port: number;
}
type Dotted = {
[K in keyof T as ${K & string}.` extends infer P ? never : K]: T[K]
};

// ─── Template literal as a transform ─────────
type AddPrefixextends string> = {
[K in keyof T as ``${P}${K & string}]: T[K]
};

interface Fields {
name: string;
age: number;
}
type FormFields = AddPrefix'form'>;
// { formname: string; formage: number }

// ─── Real-world: typed API paths ─────────────
type Entity = 'user' | 'post' | 'comment';
type ApiPath = /api/${Entity}/api/{string}`;
// '/api/user' | '/api/user/123' | '/api/post' | '/api/post/abc' | ...

const path: ApiPath = '/api/user/42';

console.log(g1, h, r1, path);