// "strict": true is equivalent to setting all of these:
{
  "compilerOptions": {
    "strictNullChecks":           true,
    "strictFunctionTypes":        true,
    "strictBindCallApply":        true,
    "strictPropertyInitialization": true,
    "noImplicitAny":              true,
    "noImplicitThis":             true,
    "useUnknownInCatchVariables": true,
    "alwaysStrict":               true
  }
}

// --- WITHOUT strict mode ---

function getUsername(user) {          // 'user' implicitly any — no error
  return user.profile.name;           // crashes at runtime if user is null
}

class Service {
  private url: string;                // not initialized — no error!
  // constructor omitted

  fetch() {
    return fetch(this.url);           // this.url is undefined at runtime
  }
}

getUsername(null);                    // no error, but crashes at runtime

// --- WITH strict mode ---

// ❌ Error: Parameter 'user' implicitly has an 'any' type.
function getUsername(user) { ... }

// ✅ Fix: explicit type with null handling
interface User { profile: { name: string } | null }

function getUsername(user: User | null): string {
  if (!user || !user.profile) return 'Anonymous';
  return user.profile.name;
}

// ❌ Error: Property 'url' has no initializer and is not definitely assigned.
class Service {
  private url: string;   // must initialize or mark as 'url!: string'
}

// Without strictNullChecks — these all compile silently
const x: string = null;             // allowed!
const y: number = undefined;        // allowed!

function greet(name: string) {
  console.log(name.toUpperCase());  // crashes if null is passed
}
greet(null); // no error!

// With strictNullChecks — the compiler forces you to handle nullability

// ❌ Error: Type 'null' is not assignable to type 'string'.
const x: string = null;

// ✅ Use a union type to explicitly allow null
const x: string | null = null;

// DOM APIs return null — you must handle it
const button = document.getElementById('submit');
// button is: HTMLElement | null

// ❌ Error: Object is possibly null
button.addEventListener('click', handler);

// ✅ Options:
button?.addEventListener('click', handler);  // optional chaining
if (button) button.addEventListener('click', handler);
button!.addEventListener('click', handler);  // non-null assertion (use sparingly)

// Without noImplicitAny
function transform(data) {     // data: any — silently passes through unchecked
  return data.map(x => x * 2); // crashes at runtime if data is not an array
}

// With noImplicitAny
// ❌ Error: Parameter 'data' implicitly has an 'any' type.
function transform(data) { ... }

// ✅ Fix: annotate the parameter
function transform(data: number[]): number[] {
  return data.map(x => x * 2);
}

// ✅ Also acceptable when intent is genuinely unknown:
function transform(data: unknown): unknown { ... }

// Object destructuring also triggers it:
// ❌ Error: Binding element 'id' implicitly has an 'any' type.
function processUser({ id, name }) { ... }

// ✅ Fix:
function processUser({ id, name }: { id: number; name: string }) { ... }

interface Animal { name: string }
interface Dog extends Animal { bark(): void }

// A function that handles any Animal
type AnimalHandler = (a: Animal) => void;
// A function that handles only Dogs
type DogHandler = (d: Dog) => void;

// Without strictFunctionTypes — this unsound assignment compiles:
let animalHandler: AnimalHandler = (a: Animal) => console.log(a.name);
let dogHandler: DogHandler = animalHandler; // ❌ unsound but allowed!

// At runtime, dogHandler could receive a non-Dog animal:
dogHandler({ name: 'Cat' }); // no bark() method — would crash!

// With strictFunctionTypes:
// ❌ Error: Type 'AnimalHandler' is not assignable to type 'DogHandler'.
// 'Animal' is not assignable to parameter type 'Dog' (contravariance).

function greet(greeting: string, name: string): string {
  return `${greeting}, ${name}!`;
}

// Without strictBindCallApply — wrong types compile silently
greet.call(null, 42, true);   // no error, but wrong types

// With strictBindCallApply:
// ❌ Error: Argument of type 'number' is not assignable to parameter of type 'string'
greet.call(null, 42, true);

// ✅ Correct usage
greet.call(null, 'Hello', 'Alice');    // "Hello, Alice!"
greet.apply(null, ['Hi', 'Bob']);      // "Hi, Bob!"

const boundGreet = greet.bind(null, 'Hey'); // (name: string) => string
boundGreet('Charlie');                 // "Hey, Charlie!"

// Without strictPropertyInitialization
class UserService {
  private apiUrl: string;   // no initializer — undefined at runtime
  private timeout: number;  // same

  fetchUser(id: string) {
    return fetch(this.apiUrl + id, { signal: AbortSignal.timeout(this.timeout) });
    // this.apiUrl is undefined — runtime TypeError!
  }
}

// With strictPropertyInitialization:
// ❌ Error: Property 'apiUrl' has no initializer and is not
//          definitely assigned in the constructor.

// ✅ Option 1: Initialize in constructor
class UserService {
  private apiUrl: string;
  private timeout: number;

  constructor(config: { apiUrl: string; timeout: number }) {
    this.apiUrl = config.apiUrl;
    this.timeout = config.timeout;
  }
}

// ✅ Option 2: Initialize at declaration
class UserService {
  private apiUrl = 'https://api.example.com/';
  private timeout = 5000;
}

// ✅ Option 3: Definite assignment assertion (use only when you KNOW it's set)
class UserService {
  private apiUrl!: string;  // '!' = "trust me, this gets set before use"

  init(url: string) {
    this.apiUrl = url;
  }
}

// Without noImplicitThis — this.name is any, no errors
function logName() {
  console.log(this.name); // this: any — silently compiles
}

// With noImplicitThis:
// ❌ Error: 'this' implicitly has type 'any' because it does not have a type annotation.

// ✅ Fix: add a 'this' parameter (it's erased at compile time, not a real parameter)
function logName(this: { name: string }) {
  console.log(this.name); // this: { name: string }
}

// ✅ Arrow functions inherit 'this' from lexical scope — no annotation needed
class Timer {
  seconds = 0;

  start() {
    setInterval(() => {
      this.seconds++; // 'this' is Timer — correctly inferred
    }, 1000);
  }
}

// Before useUnknownInCatchVariables (or TS < 4.4)
try {
  riskyOperation();
} catch (err) {
  // err: any — you can access any property without errors
  console.log(err.message); // compiles, but crashes if err is not an Error
}

// With useUnknownInCatchVariables: true
try {
  riskyOperation();
} catch (err) {
  // err: unknown — must narrow before use

  // ❌ Error: 'err' is of type 'unknown'
  console.log(err.message);

  // ✅ Narrow first
  if (err instanceof Error) {
    console.log(err.message); // string
  } else if (typeof err === 'string') {
    console.log(err);
  } else {
    console.log('Unknown error:', String(err));
  }
}

// ✅ Reusable type guard
function isError(value: unknown): value is Error {
  return value instanceof Error;
}

try {
  riskyOperation();
} catch (err) {
  if (isError(err)) console.error(err.message);
}

// tsconfig.json — phased migration approach
{
  "compilerOptions": {
    // Phase 1 — start here
    "noImplicitAny": true,

    // Phase 2 — most impactful
    "strictNullChecks": true,

    // Phase 3 — class safety
    "strictPropertyInitialization": true,

    // Phase 4+ — the rest
    "strictFunctionTypes": true,
    "strictBindCallApply": true,
    "noImplicitThis": true,
    "useUnknownInCatchVariables": true,
    "alwaysStrict": true,

    // Once all phases pass, replace everything above with:
    // "strict": true,
  }
}

// Recommended tsconfig for new projects
{
  "compilerOptions": {
    "strict": true,
    "noUncheckedIndexedAccess":           true,
    "exactOptionalPropertyTypes":          true,
    "noImplicitOverride":                  true,
    "noFallthroughCasesInSwitch":          true,
    "noUnusedLocals":                      true,
    "noUnusedParameters":                  true
  }
}