TypeScript Strict Mode

Modern TypeScript configuration with strict type checking for maximum safety and developer experience. This guide focuses on TypeScript 5.x best practices for 2025.

Core Expertise

What is Strict Mode?

Type safety: Catch more bugs at compile time
Better IDE experience: Improved autocomplete and refactoring
Maintainability: Self-documenting code with explicit types
Modern defaults: Align with current TypeScript best practices

Key Capabilities

Strict null checking
Strict function types
No implicit any
No unchecked indexed access
Proper module resolution
Modern import/export syntax enforcement

Recommended tsconfig.json (2025)

Minimal Production Setup

{ "compilerOptions": { // Type Checking "strict": true, "noUncheckedIndexedAccess": true, "noImplicitOverride": true, "noPropertyAccessFromIndexSignature": true, "noFallthroughCasesInSwitch": true, "noUnusedLocals": true, "noUnusedParameters": true,

// Modules
"module": "ESNext",
"moduleResolution": "Bundler",
"resolveJsonModule": true,
"allowSyntheticDefaultImports": true,
"esModuleInterop": false,
"verbatimModuleSyntax": true,

// Emit
"target": "ES2022",
"lib": ["ES2023", "DOM", "DOM.Iterable"],
"outDir": "dist",
"declaration": true,
"declarationMap": true,
"sourceMap": true,
"removeComments": false,
"noEmit": false,

// Interop
"isolatedModules": true,
"allowJs": false,
"checkJs": false,
"skipLibCheck": true,
"forceConsistentCasingInFileNames": true

}, "include": ["src/**/*"], "exclude": ["node_modules", "dist", "build"] }

Vite/Bun Project (Bundler)

{ "compilerOptions": { // Type Checking - Maximum strictness "strict": true, "noUncheckedIndexedAccess": true, "noImplicitOverride": true, "noPropertyAccessFromIndexSignature": true, "noFallthroughCasesInSwitch": true, "noUnusedLocals": true, "noUnusedParameters": true, "allowUnreachableCode": false, "allowUnusedLabels": false, "exactOptionalPropertyTypes": true,

// Modules (Bundler for Vite/Bun)
"module": "ESNext",
"moduleResolution": "Bundler",
"resolveJsonModule": true,
"allowSyntheticDefaultImports": true,
"esModuleInterop": false,
"verbatimModuleSyntax": true,

// Emit (Vite handles bundling)
"target": "ES2022",
"lib": ["ES2023", "DOM", "DOM.Iterable"],
"jsx": "preserve", // Vite handles JSX
"noEmit": true, // Vite handles emit

// Interop
"isolatedModules": true,
"skipLibCheck": true,
"forceConsistentCasingInFileNames": true,

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

}, "include": ["src/**/*", "vite.config.ts"], "exclude": ["node_modules", "dist"] }

Node.js Library (NodeNext)

{ "compilerOptions": { // Type Checking "strict": true, "noUncheckedIndexedAccess": true, "noImplicitOverride": true,

// Modules (NodeNext for Node.js)
"module": "NodeNext",
"moduleResolution": "NodeNext",
"resolveJsonModule": true,
"allowSyntheticDefaultImports": false,
"esModuleInterop": true,
"verbatimModuleSyntax": true,

// Emit (Node.js library)
"target": "ES2022",
"lib": ["ES2023"],
"outDir": "dist",
"declaration": true,
"declarationMap": true,
"sourceMap": true,

// Interop
"isolatedModules": true,
"skipLibCheck": true,
"forceConsistentCasingInFileNames": true

}, "include": ["src/**/*"], "exclude": ["node_modules", "dist"] }

Strict Flags Explained

strict: true (Umbrella Flag)

Enables all strict type-checking options:

{ "strict": true // Equivalent to: // "noImplicitAny": true, // "strictNullChecks": true, // "strictFunctionTypes": true, // "strictBindCallApply": true, // "strictPropertyInitialization": true, // "noImplicitThis": true, // "alwaysStrict": true }

Always enable strict: true for new projects.

noImplicitAny

Disallows variables with implicit any type.

// ❌ Error with noImplicitAny function add(a, b) { // ^ Error: Parameter 'a' implicitly has an 'any' type return a + b; }

// ✅ Correct function add(a: number, b: number): number { return a + b; }

strictNullChecks

null and undefined are distinct from other types.

// ❌ Error with strictNullChecks const name: string = null; // ^^^^ Error: Type 'null' is not assignable to type 'string'

// ✅ Correct const name: string | null = null;

// ✅ Correct (handle null explicitly) function greet(name: string | null): string { if (name === null) { return 'Hello, stranger!'; } return Hello, ${name}!; }

strictFunctionTypes

Function parameter types are checked contravariantly.

type Logger = (msg: string | number) => void;

// ❌ Error with strictFunctionTypes const log: Logger = (msg: string) => console.log(msg); // ^^^^^^^^^^^^^ Error: Type '(msg: string) => void' is not assignable

// ✅ Correct const log: Logger = (msg: string | number) => console.log(msg);

strictBindCallApply

Check that bind , call , and apply are invoked correctly.

function greet(name: string, age: number) { console.log(${name} is ${age} years old); }

// ❌ Error with strictBindCallApply greet.call(undefined, 'John', '25'); // ^^^^ Error: Argument of type 'string' is not assignable to 'number'

// ✅ Correct greet.call(undefined, 'John', 25);

strictPropertyInitialization

Class properties must be initialized.

class User { // ❌ Error with strictPropertyInitialization name: string; // ^^^^^^ Error: Property 'name' has no initializer

// ✅ Correct (initialize in constructor) name: string; constructor(name: string) { this.name = name; }

// ✅ Correct (default value) age: number = 0;

// ✅ Correct (definitely assigned assertion) id!: number; }

noImplicitThis

Disallow this with implicit any type.

// ❌ Error with noImplicitThis function logName() { console.log(this.name); // ^^^^ Error: 'this' implicitly has type 'any' }

// ✅ Correct (explicit this parameter) function logName(this: { name: string }) { console.log(this.name); }

Additional Strict Flags (Recommended for 2025)

noUncheckedIndexedAccess (Essential)

Index signatures return T | undefined instead of T .

// Without noUncheckedIndexedAccess const users: Record<string, User> = {}; const user = users['john']; // Type: User (wrong - might be undefined)

// ✅ With noUncheckedIndexedAccess const users: Record<string, User> = {}; const user = users['john']; // Type: User | undefined (correct)

if (user) { console.log(user.name); // Type narrowed to User }

Always enable this flag to prevent runtime errors.

noImplicitOverride

Require override keyword for overridden methods.

class Base { greet() { console.log('Hello'); } }

class Derived extends Base { // ❌ Error with noImplicitOverride greet() { // ^^^^^ Error: This member must have an 'override' modifier console.log('Hi'); }

// ✅ Correct override greet() { console.log('Hi'); } }

noPropertyAccessFromIndexSignature

Force bracket notation for index signatures.

type User = { name: string; [key: string]: string; };

const user: User = { name: 'John', email: 'john@example.com' };

// ❌ Error with noPropertyAccessFromIndexSignature console.log(user.email); // ^^^^^ Error: Property 'email' comes from index signature, use bracket notation

// ✅ Correct console.log(user['email']);

// ✅ Also correct (explicit property) console.log(user.name);

noFallthroughCasesInSwitch

Prevent fallthrough in switch statements.

function getDiscount(role: string): number { switch (role) { case 'admin': return 0.5; // ❌ Error with noFallthroughCasesInSwitch case 'user': // ^^^^ Error: Fallthrough case in switch console.log('User discount'); case 'guest': return 0.1; } }

// ✅ Correct function getDiscount(role: string): number { switch (role) { case 'admin': return 0.5; case 'user': console.log('User discount'); return 0.2; // Explicit return case 'guest': return 0.1; default: return 0; } }

exactOptionalPropertyTypes

Optional properties cannot be set to undefined explicitly.

type User = { name: string; age?: number; // Type: number | undefined (implicit) };

// ❌ Error with exactOptionalPropertyTypes const user: User = { name: 'John', age: undefined }; // ^^^^^^^^^ Error: Type 'undefined' is not assignable

// ✅ Correct (omit property) const user: User = { name: 'John' };

// ✅ Correct (assign a value) const user2: User = { name: 'Jane', age: 25 };

Module Resolution

moduleResolution: "Bundler" (Vite/Bun)

Use for projects with bundlers (Vite, Webpack, Bun).

{ "compilerOptions": { "module": "ESNext", "moduleResolution": "Bundler" } }

Features:

✅ No file extensions required in imports
✅ JSON imports without assertions
✅ Package.json exports field support
✅ Optimized for bundlers

// ✅ Works with Bundler import config from './config.json'; import { add } from './utils'; // No .ts extension

moduleResolution: "NodeNext" (Node.js)

Use for Node.js libraries and servers.

{ "compilerOptions": { "module": "NodeNext", "moduleResolution": "NodeNext" } }

Features:

✅ Respects package.json type: "module"
✅ Requires explicit .js extensions (even for .ts files)
✅ Supports conditional exports
✅ Aligned with Node.js ESM behavior

// ✅ Works with NodeNext (note .js extension) import { add } from './utils.js'; import config from './config.json' assert { type: 'json' };

package.json:

{ "type": "module", "exports": { ".": { "import": "./dist/index.js", "types": "./dist/index.d.ts" } } }

verbatimModuleSyntax (Recommended for 2025)

Prevents TypeScript from rewriting imports/exports.

{ "compilerOptions": { "verbatimModuleSyntax": true } }

Benefits:

✅ Explicit type imports required
✅ Prevents unintended side effects
✅ Better tree-shaking
✅ Aligns with future JavaScript standards

// ❌ Error with verbatimModuleSyntax import { User } from './types'; // ^^^^^^ Error: 'User' is a type and must be imported with 'import type'

// ✅ Correct import type { User } from './types';

// ✅ Correct (value import) import { fetchUser } from './api';

// ✅ Correct (mixed import) import { fetchUser, type User } from './api';

Replaces:

importsNotUsedAsValues (deprecated)
preserveValueImports (deprecated)

Path Mapping

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

Usage:

// Path aliases keep imports clean import { Button } from '@components/Button';

Vite/Bun configuration:

// vite.config.ts import { defineConfig } from 'vite'; import path from 'path';

export default defineConfig({ resolve: { alias: { '@': path.resolve(__dirname, './src'), '@components': path.resolve(__dirname, './src/components'), }, }, });

Migrating to Strict Mode

Step 1: Enable Gradually

{ "compilerOptions": { // Start with these "noImplicitAny": true, "strictNullChecks": false, // Enable later "strictFunctionTypes": true, "strictBindCallApply": true, "strictPropertyInitialization": false, // Enable later "noImplicitThis": true, "alwaysStrict": true } }

Step 2: Fix Errors Incrementally

Check errors without emitting

bunx tsc --noEmit

Fix files one at a time

bunx tsc --noEmit src/utils.ts

Step 3: Enable Remaining Flags

{ "compilerOptions": { "strict": true, // Enable all at once "noUncheckedIndexedAccess": true } }

Step 4: Optional Strict Flags

{ "compilerOptions": { "strict": true, "noUncheckedIndexedAccess": true, "noImplicitOverride": true, "noPropertyAccessFromIndexSignature": true, "exactOptionalPropertyTypes": true } }

Common Patterns

Handling Null/Undefined

// Non-null assertion (use sparingly) const element = document.getElementById('app')!;

// Optional chaining const name = user?.profile?.name;

// Nullish coalescing const displayName = user?.name ?? 'Anonymous';

// Type guard function isUser(value: unknown): value is User { return typeof value === 'object' && value !== null && 'name' in value; }

Index Signature Safety

// ❌ Unsafe const value = obj[key]; // Type: T (wrong)

// ✅ Safe with noUncheckedIndexedAccess const value = obj[key]; // Type: T | undefined

if (value !== undefined) { // Type: T console.log(value); }

// ✅ Safe with assertion const value = obj[key]; if (value === undefined) throw new Error('Key not found'); // Type: T (narrowed)

Troubleshooting

Too Many Errors

Enable flags gradually

Start with noImplicitAny, then add others

Use @ts-expect-error for temporary fixes

// @ts-expect-error - TODO: Fix this type const value: string = null;

Library Types Missing

Install type definitions

bun add --dev @types/node @types/react

Skip type checking for libraries

{ "compilerOptions": { "skipLibCheck": true } }

Module Resolution Errors

// Bundler: No extension needed import { add } from './utils';

// NodeNext: Requires .js extension import { add } from './utils.js';

// Check moduleResolution setting bunx tsc --showConfig | grep moduleResolution

References

TypeScript Handbook: https://www.typescriptlang.org/docs/handbook/intro.html
TSConfig Reference: https://www.typescriptlang.org/tsconfig
Strict Mode Guide: https://www.typescriptlang.org/tsconfig#strict
Module Resolution: https://www.typescriptlang.org/docs/handbook/module-resolution.html
Best Practices: https://www.typescriptlang.org/docs/handbook/declaration-files/do-s-and-don-ts.html

typescript strict mode

Safety Notice

Copy this and send it to your AI assistant to learn

Check errors without emitting

Fix files one at a time

Enable flags gradually

Start with noImplicitAny, then add others

Use @ts-expect-error for temporary fixes

Install type definitions

Skip type checking for libraries

Source Transparency

Related Skills

python-code-quality

python-development

python-testing