Configuration and Compiler Options

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "ESNext",
    "lib": ["ES2022", "DOM"],
    "outDir": "./dist",
    "rootDir": "./src",
    "strict": true
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules", "dist"]
}

// Multi-project setup with extends
// tsconfig.base.json
{
  "compilerOptions": {
    "target": "ES2022",
    "module": "ESNext",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true
  }
}

// tsconfig.json
{
  "extends": "./tsconfig.base.json",
  "compilerOptions": {
    "outDir": "./dist",
    "rootDir": "./src"
  },
  "include": ["src/**/*"]
}

// Node.js project configuration
{
  "compilerOptions": {
    "target": "ES2022",
    "module": "Node16",
    "moduleResolution": "Node16",
    "outDir": "./dist",
    "rootDir": "./src",
    "strict": true,
    "esModuleInterop": true,
    "resolveJsonModule": true
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules"]
}

// Recommended strict configuration
{
  "compilerOptions": {
    // Enable all strict checks
    "strict": true,
    
    // Additional recommended checks not in strict
    "noUnusedLocals": true,
    "noUnusedParameters": true,
    "noImplicitReturns": true,
    "noFallthroughCasesInSwitch": true,
    "noUncheckedIndexedAccess": true,
    "noImplicitOverride": true,
    "noPropertyAccessFromIndexSignature": true,
    "exactOptionalPropertyTypes": true,
    
    // Disallow unreachable code
    "allowUnusedLabels": false,
    "allowUnreachableCode": false
  }
}

// Impact of strictNullChecks
// With strictNullChecks: false
let name: string = null; // OK
let age: number = undefined; // OK

// With strictNullChecks: true
let name: string = null; // Error
let age: number = undefined; // Error
let name2: string | null = null; // OK
let age2: number | undefined = undefined; // OK

// Impact of noUncheckedIndexedAccess
interface Users {
  [id: string]: { name: string; }
}
const users: Users = {};

// With noUncheckedIndexedAccess: false
const user = users["123"]; // Type: { name: string; }
console.log(user.name); // No error, but could crash

// With noUncheckedIndexedAccess: true
const user2 = users["123"]; // Type: { name: string; } | undefined
console.log(user2.name); // Error: Object is possibly undefined
if (user2) {
  console.log(user2.name); // OK
}

// tsconfig.json
{
  "compilerOptions": {
    "baseUrl": "./src",
    "paths": {
      // Map @ to src root
      "@/*": ["*"],
      
      // Map specific directories
      "@components/*": ["components/*"],
      "@utils/*": ["utils/*"],
      "@services/*": ["services/*"],
      "@types/*": ["types/*"],
      
      // Map to specific files
      "@config": ["config/index.ts"],
      
      // Multiple fallback locations
      "@shared/*": [
        "shared/*",
        "../shared/*",
        "../../packages/shared/*"
      ]
    },
    "typeRoots": [
      "./node_modules/@types",
      "./types"
    ]
  }
}

// Usage with path mapping
// Before: Relative imports
import { Button } from '../../../components/Button';
import { formatDate } from '../../../utils/date';
import config from '../../../config';

// After: Path mapping
import { Button } from '@components/Button';
import { formatDate } from '@utils/date';
import config from '@config';

// Using rootDirs for virtual directory structure
{
  "compilerOptions": {
    "rootDirs": [
      "src",
      "generated"
    ]
  }
}

// File structure:
// src/index.ts
// generated/api-types.ts

// In src/index.ts, can import as if in same directory
import { ApiTypes } from './api-types'; // Resolves to generated/api-types.ts

// Monorepo path mapping
{
  "compilerOptions": {
    "baseUrl": ".",
    "paths": {
      "@myorg/core": ["packages/core/src"],
      "@myorg/utils": ["packages/utils/src"],
      "@myorg/ui": ["packages/ui/src"]
    }
  }
}

// JSON module resolution
{
  "compilerOptions": {
    "resolveJsonModule": true,
    "esModuleInterop": true
  }
}

import packageJson from './package.json';
console.log(packageJson.version); // Fully typed

// Basic include/exclude patterns
{
  "include": [
    "src/**/*"  // All files in src directory recursively
  ],
  "exclude": [
    "node_modules",  // All node_modules
    "dist",           // Output directory
    "**/*.spec.ts",  // All test files
    "**/*.test.ts"   // All test files
  ]
}

// Multiple source directories
{
  "include": [
    "src/**/*",
    "lib/**/*",
    "types/**/*.d.ts"
  ],
  "exclude": [
    "src/**/*.test.ts",
    "lib/legacy/**/*"
  ]
}

// Explicit files list (overrides include/exclude)
{
  "files": [
    "src/main.ts",
    "src/types.d.ts",
    "src/global.d.ts"
  ]
  // No include/exclude needed when using files
}

// Complex pattern combinations
{
  "include": [
    "src/**/*.ts",
    "src/**/*.tsx",
    "!src/**/*.test.ts",  // Negation pattern
    "!src/**/*.spec.ts"
  ],
  "exclude": [
    "**/*.d.ts",           // Exclude all declaration files
    "node_modules",
    "build",
    "dist",
    "coverage",
    ".vscode",
    ".git"
  ]
}

// Including specific files from node_modules
{
  "include": [
    "src/**/*",
    "node_modules/my-custom-types/**/*"  // Override default exclude
  ],
  "exclude": [
    "node_modules/my-custom-types/test/**/*"
  ]
}

// Monorepo file selection
{
  "include": [
    "packages/*/src/**/*.ts",
    "packages/*/src/**/*.tsx"
  ],
  "exclude": [
    "packages/*/node_modules",
    "packages/*/dist",
    "packages/*/**/*.test.ts"
  ]
}

// Test-specific configuration
// tsconfig.test.json
{
  "extends": "./tsconfig.json",
  "include": [
    "src/**/*.test.ts",
    "src/**/*.spec.ts",
    "test/**/*"
  ],
  "exclude": []  // Override parent exclude
}

// Build vs Dev configurations
// tsconfig.build.json
{
  "extends": "./tsconfig.json",
  "exclude": [
    "**/*.test.ts",
    "**/*.spec.ts",
    "**/__tests__/**",
    "**/__mocks__/**"
  ]
}

// Monorepo structure
// /packages/core/tsconfig.json
{
  "compilerOptions": {
    "composite": true,
    "declaration": true,
    "declarationMap": true,
    "outDir": "./dist",
    "rootDir": "./src",
    "tsBuildInfoFile": "./dist/.tsbuildinfo"
  },
  "include": ["src/**/*"]
}

// /packages/utils/tsconfig.json
{
  "compilerOptions": {
    "composite": true,
    "declaration": true,
    "declarationMap": true,
    "outDir": "./dist",
    "rootDir": "./src"
  },
  "references": [
    { "path": "../core" }  // Depends on core
  ],
  "include": ["src/**/*"]
}

// /packages/ui/tsconfig.json
{
  "compilerOptions": {
    "composite": true,
    "declaration": true,
    "declarationMap": true,
    "outDir": "./dist",
    "rootDir": "./src",
    "jsx": "react-jsx"
  },
  "references": [
    { "path": "../core" },
    { "path": "../utils" }
  ],
  "include": ["src/**/*"]
}

// Root tsconfig.json (solution file)
{
  "files": [],
  "references": [
    { "path": "./packages/core" },
    { "path": "./packages/utils" },
    { "path": "./packages/ui" }
  ]
}

// Build commands
// Build all projects
tsc -b

// Build specific project and dependencies
tsc -b packages/ui

// Clean build artifacts
tsc -b --clean

// Force rebuild
tsc -b --force

// Watch mode for all projects
tsc -b --watch

// Verbose output
tsc -b --verbose

// Dry run
tsc -b --dry

// Using project references in code
// In packages/ui/src/Button.tsx
import { CoreService } from '@myorg/core';  // Reference from core
import { formatDate } from '@myorg/utils';  // Reference from utils

// Benefits of composite projects
// 1. Faster builds - only rebuild changed projects
// 2. Better IDE performance - jump to source instead of .d.ts
// 3. Enforce architectural boundaries
// 4. Parallel builds
// 5. Better error messages

// Build vs Solution configuration
// tsconfig.json (for IDE)
{
  "extends": "./tsconfig.base.json",
  "references": [
    { "path": "./packages/core" },
    { "path": "./packages/utils" }
  ]
}

// tsconfig.build.json (for production builds)
{
  "extends": "./tsconfig.base.json",
  "references": [
    { "path": "./packages/core" },
    { "path": "./packages/utils" }
  ],
  "compilerOptions": {
    "sourceMap": false,
    "declaration": true
  }
}

// Enable incremental compilation
{
  "compilerOptions": {
    "incremental": true,
    "tsBuildInfoFile": "./dist/.tsbuildinfo",
    "outDir": "./dist"
  }
}

// Watch mode configuration
{
  "compilerOptions": {
    "incremental": true
  },
  "watchOptions": {
    // File watching strategies
    "watchFile": "useFsEvents",  // or "fixedPollingInterval", "dynamicPriorityPolling"
    "watchDirectory": "useFsEvents",  // or "fixedPollingInterval", "dynamicPriorityPolling"
    
    // Fallback polling for file systems that don't support events
    "fallbackPolling": "dynamicPriority",
    
    // Debounce settings
    "synchronousWatchDirectory": true,
    
    // Exclude directories from watching
    "excludeDirectories": [
      "**/node_modules",
      "**/.git",
      "**/dist"
    ],
    
    // Exclude files from watching
    "excludeFiles": [
      "**/.tsbuildinfo",
      "**/package-lock.json"
    ]
  }
}

// Build mode commands for project references
// Build all referenced projects
tsc -b

// Build with dependency tracking
tsc -b packages/app packages/lib

// Watch mode for project references
tsc -b --watch

// Clean build outputs
tsc -b --clean

// Force rebuild all
tsc -b --force

// Verbose build output
tsc -b --verbose

// Dry run (show what would be built)
tsc -b --dry

// Combined flags
tsc -b --clean --verbose
tsc -b --force --watch

// Optimize for large codebases
{
  "compilerOptions": {
    "incremental": true,
    "tsBuildInfoFile": "./.tsbuildinfo",
    
    // Speed optimizations
    "skipLibCheck": true,  // Skip type checking of .d.ts files
    "skipDefaultLibCheck": true,
    
    // For project references
    "assumeChangesOnlyAffectDirectDependencies": true
  }
}

// Parallel builds with project references
// package.json scripts
{
  "scripts": {
    "build": "tsc -b",
    "build:clean": "tsc -b --clean",
    "build:force": "tsc -b --force",
    "build:watch": "tsc -b --watch",
    "build:verbose": "tsc -b --verbose"
  }
}

// CI/CD optimized build
{
  "compilerOptions": {
    "incremental": false,  // Disable for clean CI builds
    "noEmitOnError": true,
    "skipLibCheck": true
  }
}

// Development vs Production configurations
// tsconfig.dev.json
{
  "extends": "./tsconfig.json",
  "compilerOptions": {
    "incremental": true,
    "sourceMap": true,
    "declaration": false
  },
  "watchOptions": {
    "watchFile": "useFsEvents",
    "excludeDirectories": ["node_modules", "dist"]
  }
}

// tsconfig.prod.json
{
  "extends": "./tsconfig.json",
  "compilerOptions": {
    "incremental": false,
    "sourceMap": false,
    "declaration": true,
    "removeComments": true
  }
}

// Build performance monitoring
// Use --diagnostics flag
tsc --diagnostics

// Output includes:
// Files:            350
// Lines:            45000
// Nodes:            250000
// Identifiers:      80000
// Symbols:          90000
// Types:            30000
// Memory used:      250MB
// I/O Read time:    0.5s
// Parse time:       2.3s
// Bind time:        1.1s
// Check time:       5.8s
// Emit time:        1.2s
// Total time:       10.9s