{
  "compilerOptions": {
    // Compiler behavior settings go here
  },
  "include": [
    "src/**/*"
  ],
  "exclude": [
    "node_modules",
    "dist"
  ],
  "files": [
    // Explicit list of files (rarely needed)
  ],
  "extends": "./tsconfig.base.json",
  "references": [
    // Project references for monorepos
    { "path": "../shared" }
  ]
}

{
  "compilerOptions": {
    "strict": true,
    // Shorthand that enables all of the following:
    // strictNullChecks, noImplicitAny, strictFunctionTypes,
    // strictBindCallApply, strictPropertyInitialization,
    // noImplicitThis, useUnknownInCatchVariables,
    // alwaysStrict (adds 'use strict' to emitted files)

    // Individual type-checking flags:
    "strictNullChecks": true,
    "noImplicitAny": true,
    "strictFunctionTypes": true,
    "strictBindCallApply": true,
    "strictPropertyInitialization": true,
    "noImplicitThis": true,
    "useUnknownInCatchVariables": true,
    "alwaysStrict": true,

    // Additional strict-style checks (not in 'strict'):
    "noUnusedLocals": true,
    "noUnusedParameters": true,
    "exactOptionalPropertyTypes": true,
    "noImplicitReturns": true,
    "noFallthroughCasesInSwitch": true,
    "noUncheckedIndexedAccess": true,
    "noPropertyAccessFromIndexSignature": true
  }
}

// Without strictNullChecks:
let name: string = null;    // OK (null is assignable to anything)
let age: number = undefined; // OK

// With strictNullChecks:
let name: string = null;    // Error: null not assignable to string
let age: number = undefined; // Error: undefined not assignable to number

// Fix: use union types to allow null/undefined explicitly
let name: string | null = null;
let age: number | undefined = undefined;

// Optional chaining and nullish coalescing become essential
const upper = name?.toUpperCase() ?? 'anonymous';

// Without noUncheckedIndexedAccess:
const arr: string[] = ['a', 'b', 'c'];
const first: string = arr[0]; // OK (but arr[10] would also type as string)

// With noUncheckedIndexedAccess:
const first: string | undefined = arr[0]; // index access adds | undefined
const safe = arr[0]?.toUpperCase(); // must handle undefined

// Also affects Record types
const dict: Record<string, number> = { a: 1 };
const val: number | undefined = dict['b']; // undefined is possible

{
  "compilerOptions": {
    // What module format to emit
    "module": "NodeNext",      // Options: CommonJS, ESNext, NodeNext, Node16, Preserve

    // How to resolve modules from import paths
    "moduleResolution": "NodeNext", // Options: Node10, Node16, NodeNext, Bundler

    // Base directory for non-relative imports
    "baseUrl": "./src",

    // Path aliases
    "paths": {
      "@components/*": ["components/*"],
      "@utils/*": ["utils/*"],
      "@types/*": ["types/*"]
    },

    // Root directory of source files (for output mirroring)
    "rootDir": "./src",

    // Whether to allow importing .ts extension explicitly
    "allowImportingTsExtensions": true,

    // Resolve JSON files as modules
    "resolveJsonModule": true
  }
}

{
  "compilerOptions": {
    "baseUrl": "./src",
    "paths": {
      // Single path alias
      "@config": ["config/index.ts"],

      // Wildcard alias (maps any @utils/* to src/utils/*)
      "@utils/*": ["utils/*"],

      // Multiple fallback paths
      "@shared/*": ["../shared/src/*", "shared/*"]
    }
  }
}

// With the above config, you can write:
import { AppConfig } from '@config';
import { formatDate } from '@utils/date';
// Instead of:
import { AppConfig } from '../../config';
import { formatDate } from '../../../utils/date';

{
  "compilerOptions": {
    // ECMAScript version to compile down to
    "target": "ES2020",   // Options: ES3, ES5, ES2015...ES2023, ESNext

    // Output directory for compiled files
    "outDir": "./dist",

    // Don't emit any output files (type-check only)
    "noEmit": true,

    // Generate .d.ts declaration files
    "declaration": true,

    // Output directory for declaration files (if different from outDir)
    "declarationDir": "./types",

    // Generate .d.ts.map files (source maps for declarations)
    "declarationMap": true,

    // Generate .js.map source maps
    "sourceMap": true,

    // Inline source map as data URL in the .js file
    "inlineSourceMap": false,

    // Remove all comments from emitted files
    "removeComments": false,

    // Don't emit on compilation errors
    "noEmitOnError": true,

    // Preserve const enums as their literal values
    "preserveConstEnums": false,

    // Emit helpers inline instead of importing from tslib
    "importHelpers": true,

    // Only emit declaration files (no JS)
    "emitDeclarationOnly": false
  }
}

{
  "compilerOptions": {
    // Type definition libraries to include
    "lib": ["ES2020", "DOM", "DOM.Iterable"],
    // Common combinations:
    // Node.js: ["ES2020"] (no DOM) + install @types/node
    // Browser: ["ES2020", "DOM", "DOM.Iterable"]
    // Web Workers: ["ES2020", "WebWorker"]

    // JSX transformation mode
    "jsx": "react-jsx",
    // Options:
    // "preserve"     — output .jsx, no transformation
    // "react"        — React.createElement calls (React 16)
    // "react-jsx"    — import { jsx } from 'react/jsx-runtime' (React 17+)
    // "react-jsxdev" — same as react-jsx but development build
    // "react-native" — preserve JSX for React Native bundler

    // Enable legacy decorators (before Stage 3)
    "experimentalDecorators": false,

    // Enable metadata for decorators (used by reflection-based DI)
    "emitDecoratorMetadata": false,

    // Use define semantics for class fields
    "useDefineForClassFields": true
  }
}

{
  "compilerOptions": {
    // Allow importing .js files
    "allowJs": true,

    // Type-check .js files (respects JSDoc annotations)
    "checkJs": true,

    // Max errors to report (0 = unlimited)
    "maxNodeModuleJsDepth": 0
  }
}

// With allowJs and checkJs, TypeScript understands JSDoc:
// In a .js file:

/**
 * @param {string} name
 * @param {number} age
 * @returns {string}
 */
function greet(name, age) {
  return `${name} is ${age} years old`;
}

// TypeScript will check that callers pass (string, number) -> string

{
  "compilerOptions": {
    // Enables interop between CommonJS and ES modules
    // Allows: import React from 'react' (default import for CJS module)
    "esModuleInterop": true,

    // Allows default imports from modules with no default export
    // (implied when esModuleInterop is true)
    "allowSyntheticDefaultImports": true,

    // Force consistent file name casing in imports
    "forceConsistentCasingInFileNames": true,

    // Isolate each file as its own module (required by Babel/esbuild/SWC)
    "isolatedModules": true
  }
}

// Without esModuleInterop:
import * as React from 'react'; // required
import * as path from 'path';

// With esModuleInterop: true:
import React from 'react'; // default import works
import path from 'path';   // default import works

{
  "compilerOptions": {
    // Enable incremental compilation (stores build info)
    "incremental": true,

    // Where to store the incremental build info file
    "tsBuildInfoFile": "./.tsbuildinfo",

    // Enable project references (for monorepos and large projects)
    "composite": true,

    // Skip type checking of all declaration files (.d.ts)
    "skipLibCheck": true,

    // Skip type checking of default lib declaration files only
    "skipDefaultLibCheck": false
  }
}

// Root tsconfig.json in a monorepo
{
  "files": [],
  "references": [
    { "path": "./packages/shared" },
    { "path": "./packages/api" },
    { "path": "./packages/web" }
  ]
}

// packages/api/tsconfig.json
{
  "compilerOptions": {
    "composite": true,
    "outDir": "./dist",
    "rootDir": "./src"
  },
  "references": [
    { "path": "../shared" }  // depends on shared
  ]
}

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "lib": ["ES2022"],
    "outDir": "./dist",
    "rootDir": "./src",
    "strict": true,
    "noUnusedLocals": true,
    "noUnusedParameters": true,
    "noImplicitReturns": true,
    "declaration": true,
    "declarationMap": true,
    "sourceMap": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules", "dist"]
}

{
  "compilerOptions": {
    "target": "ES2020",
    "module": "ESNext",
    "moduleResolution": "Bundler",
    "lib": ["ES2020", "DOM", "DOM.Iterable"],
    "jsx": "react-jsx",
    "strict": true,
    "noUnusedLocals": true,
    "noUnusedParameters": true,
    "noFallthroughCasesInSwitch": true,
    "allowImportingTsExtensions": true,
    "resolveJsonModule": true,
    "isolatedModules": true,
    "noEmit": true,
    "baseUrl": ".",
    "paths": {
      "@/*": ["./src/*"]
    }
  },
  "include": ["src"],
  "references": [{ "path": "./tsconfig.node.json" }]
}

{
  "compilerOptions": {
    "target": "ES2017",
    "lib": ["dom", "dom.iterable", "esnext"],
    "allowJs": true,
    "skipLibCheck": true,
    "strict": true,
    "noEmit": true,
    "esModuleInterop": true,
    "module": "esnext",
    "moduleResolution": "bundler",
    "resolveJsonModule": true,
    "isolatedModules": true,
    "jsx": "preserve",
    "incremental": true,
    "plugins": [{ "name": "next" }],
    "paths": {
      "@/*": ["./src/*"]
    }
  },
  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
  "exclude": ["node_modules"]
}