How to use Record.
Typed dictionaries, done right.

// ─── Role permissions ────────────────────────
type Role = 'admin' | 'user' | 'guest';
type Permissions = Recordstring[]>;

const perms: Permissions = {
admin: ['read', 'write', 'delete'],
user: ['read', 'write'],
guest: ['read']
// ❌ Missing 'guest' → compile error (Record enforces all keys)
};

// ─── Autocomplete + typo protection ─────────
perms.admin; // ✅ string[] — autocomplete
perms.admim; // ❌ Property 'admim' does not exist

// ─── i18n message dictionary ─────────────────
type Locale = 'en' | 'fr' | 'es';
type MessageKey = 'greeting' | 'farewell';
type Translations = RecordRecordstring>>;

const messages: Translations = {
en: { greeting: 'Hello', farewell: 'Goodbye' },
fr: { greeting: 'Bonjour', farewell: 'Au revoir' },
es: { greeting: 'Hola', farewell: 'Adiós' }
};

function t(locale: Locale, key: MessageKey): string {
return messages[locale][key]; // both indexed by literal unions
}

// ─── Status → label map ──────────────────────
type Status = 'idle' | 'loading' | 'success' | 'error';

const statusLabels: Recordstring> = {
idle: 'Ready',
loading: 'Loading…',
success: 'Done',
error: 'Failed'
};

// Type-safe access:
function label(s: Status): string {
return statusLabels[s];
}

// ─── Record with generic type ────────────────
interface User { id: string; name: string }

function indexById(users: User[]): Record<string, User> {
const index: Record<string, User> = {};
for (const u of users) {
index[u.id] = u;
}
return index;
}

const users = indexById([
{ id: '1', name: 'Alice' },
{ id: '2', name: 'Bob' }
]);

// ─── Why Record beats an index signature here
//
// Index sig: { [key: string]: User }
// ❌ No autocomplete — any key allowed
// ❌ No typo protection
// ❌ No "must have all keys" enforcement
//
// Record:
// ✅ Autocomplete on keys
// ✅ Typos are compile errors
// ✅ Missing keys are compile errors
// ✅ Exact key list is enforced

console.log(perms.admin, t('fr', 'greeting'));
console.log(label('success'), users['1']);

// ─── Record vs index signature ────
// These two are equivalent:
type A = Record<string, number>;
interface B {
[key: string]: number;
}

// Prefer Record — it reads as "a dictionary",
// it composes with utility types, and it's the
// modern idiom. Index signatures are legacy syntax.

// ─── When keys are truly open ────────────────
function parseCounts(json: string): Record<string, number> {
const raw: unknown = JSON.parse(json);

// Validate before casting
if (typeof raw !== 'object' || raw === null) {
throw new Error('Expected an object');
}

const result: Record<string, number> = {};
for (const [k, v] of Object.entries(raw)) {
if (typeof v !== 'number') throw new Error(Non-number value for ${k}`);
result[k] = v;
}
return result;
}

// ─── Record with any key type ────────────────
type NumberDict = Record<number, string>;

const scoreByName: NumberDict = {
[1]: 'Alice',
[2]: 'Bob'
};
// Note: JS coerces number keys to strings at runtime.
// For true numeric keys, use Map.

// ─── Combining Record with Partial ───────────
// Allow some keys to be missing (partial dictionary):
type PartialConfig = Partial<Record<'host' | 'port' | 'debug', string>>;

const cfg: PartialConfig = { host: 'localhost' }; // ✅ only host
// const bad: Record<'host'|'port', string> = { host: 'x' };
// ❌ missing 'port' — Record is strict by default

// ─── Combining Record with Pick/Omit ─────────
interface Settings {
theme: 'light' | 'dark';
fontSize: number;
language: string;
}

// A Record of specific settings:
type ThemeSettings = Pick'theme' | 'fontSize'>;

// Or a Record of user IDs to their settings:
type UserSettings = Record<string, Settings>;

console.log(parseCounts('{"a":1,"b":2}'));
console.log(scoreByName, cfg);

// ─── Pattern 1: Index an array by ID ─────────
interface User { id: string; name: string }

function indexByIdextends { id: string }>(items: T[]): Record<string, T> {
return Object.fromEntries(items.map(i => [i.id, i]));
}

const byId = indexById([
{ id: '1', name: 'Alice' },
{ id: '2', name: 'Bob' }
] as User[]);

// ─── Pattern 2: Group by a key ───────────────
function groupByextends string>(items: T[], keyFn: (item: T) => K): Record {
const out: Record = {} as Record;
for (const item of items) {
const k = keyFn(item);
(out[k] ??= []).push(item);
}
return out;
}

interface Task { id: string; status: 'todo' | 'done' }

const tasks: Task[] = [
{ id: '1', status: 'todo' },
{ id: '2', status: 'done' },
{ id: '3', status: 'todo' }
];

const byStatus = groupBy(tasks, t => t.status);
// { todo: Task[], done: Task[] }

// ─── Pattern 3: Config map ────────────────────
type Env = 'development' | 'staging' | 'production';
type EnvConfig = { apiUrl: string; debug: boolean };

const config: Record = {
development: { apiUrl: 'http://localhost:3000', debug: true },
staging: { apiUrl: 'https://staging.api.com', debug: true },
production: { apiUrl: 'https://api.example.com', debug: false }
};

function getConfig(env: Env): EnvConfig {
return config[env]; // typed by Env
}

// ─── Pattern 4: Handler dispatch table ────────
type EventName = 'click' | 'focus' | 'blur';
type Handler = (e: Event) => void;

const handlers: Record = {
click: (e) => console.log('click', e),
focus: (e) => console.log('focus', e),
blur: (e) => console.log('blur', e)
};

function handle(name: EventName, event: Event): void {
handlersname; // dispatch — no lookup errors
}

// ─── Pattern 5: Assertion maps ────────────────
type Format = 'json' | 'xml' | 'csv';

const contentTypes: Recordstring> = {
json: 'application/json',
xml: 'application/xml',
csv: 'text/csv'
};

// ─── Pattern 6: Exhaustiveness helper ────────
function describe(status: 'idle' | 'loading' | 'done'): string {
const descriptions: Record<typeof status, string> = {
idle: 'Ready',
loading: 'Loading…',
done: 'Complete'
};
return descriptions[status];
}

console.log(byId, byStatus);
console.log(getConfig('production'));
console.log(contentTypes.json, describe('done'));