Strict Mode no TypeScript: Como Ativar

// SEM strictNullChecks (perigoso)
function buscarUsuario(id: string): User {
  // Pode retornar undefined, mas o tipo diz User
  return database.find(u => u.id === id);
}

const user = buscarUsuario('123');
console.log(user.name); // Runtime error: Cannot read property 'name' of undefined

// COM strictNullChecks (seguro)
function buscarUsuario(id: string): User | undefined {
  return database.find(u => u.id === id);
}

const user = buscarUsuario('123');
// console.log(user.name); // Erro de compilação!

// Jeito correto:
if (user) {
  console.log(user.name); // OK - TypeScript sabe que não é undefined
}

// Ou com optional chaining:
console.log(user?.name ?? 'Usuário não encontrado');

// SEM noImplicitAny (o TypeScript aceita calado)
function processar(dados) {
  // 'dados' é implicitamente 'any'
  // Qualquer operação passa sem checagem
  return dados.map(item => item.valor * 2);
}

// COM noImplicitAny (TypeScript exige tipo)
function processar(dados) {
  // Erro: Parameter 'dados' implicitly has an 'any' type
}

// Jeito correto:
interface Item {
  valor: number;
}

function processar(dados: Item[]): number[] {
  return dados.map(item => item.valor * 2);
}

// Agora se alguém passa um array de strings, o compilador barra
// processar(['a', 'b']); // Erro de compilação

// strictFunctionTypes verifica compatibilidade de callbacks

interface Animal {
  nome: string;
}

interface Cachorro extends Animal {
  raca: string;
}

// SEM strictFunctionTypes (deixa passar)
type Handler = (animal: Animal) => void;

const handleCachorro: Handler = (cachorro: Cachorro) => {
  console.log(cachorro.raca); // Perigoso! Nem todo Animal tem raca
};

// COM strictFunctionTypes (barra)
const handleCachorro: Handler = (cachorro: Cachorro) => {
  // Erro: Type '(cachorro: Cachorro) => void' is not assignable
  // to type 'Handler'
  console.log(cachorro.raca);
};

// Jeito correto: use Animal e verifique
const handleAnimal: Handler = (animal: Animal) => {
  if ('raca' in animal) {
    console.log((animal as Cachorro).raca);
  }
};

// SEM strictPropertyInitialization
class UserService {
  private db: Database; // Sem erro, mas db pode ser undefined

  getUsers() {
    return this.db.query('SELECT * FROM users');
    // Runtime error se db não foi inicializado!
  }
}

// COM strictPropertyInitialization
class UserService {
  private db: Database;
  // Erro: Property 'db' has no initializer and is not
  // definitely assigned in the constructor

  // Opção 1: Inicializar no constructor
  constructor(db: Database) {
    this.db = db;
  }

  // Opção 2: Valor padrão
  private retries: number = 3;

  // Opção 3: Definite assignment assertion (quando você tem certeza)
  private config!: Config; // O ! diz "confie em mim"
}

// SEM useUnknownInCatchVariables
try {
  JSON.parse(texto);
} catch (error) {
  // error é 'any' - aceita qualquer coisa
  console.log(error.message); // Funciona, mas sem segurança
}

// COM useUnknownInCatchVariables
try {
  JSON.parse(texto);
} catch (error) {
  // error é 'unknown' - precisa verificar
  // console.log(error.message); // Erro!

  if (error instanceof Error) {
    console.log(error.message); // Agora sim, seguro
  } else {
    console.log('Erro desconhecido:', String(error));
  }
}

// Por que isso importa? Nem todo throw lança Error:
// throw "string de erro";
// throw 42;
// throw { custom: true };
// O catch precisa estar preparado pra qualquer coisa

// tsconfig.json - Adoção incremental
{
  "compilerOptions": {
    // Fase 1: Comece com essas
    "strictNullChecks": true,
    "noImplicitAny": true,

    // Fase 2: Adicione depois
    "strictFunctionTypes": true,
    "strictBindCallApply": true,

    // Fase 3: Finalize
    "strictPropertyInitialization": true,
    "noImplicitThis": true,
    "useUnknownInCatchVariables": true,
    "alwaysStrict": true

    // Fase 4: Substitua tudo por
    // "strict": true
  }
}

// Dica: use @ts-expect-error pra erros que vai corrigir depois
function legacyFunction(data: any) {
  // @ts-expect-error - TODO: tipar corretamente na sprint 15
  return data.process();
}

// Impacto documentado:
//
// Benefícios observados na prática (não são estatística auditada):
// - Menos crashes de null/undefined com strictNullChecks
// - Bugs de tipo aparecem no editor, não só em produção
// - Refatoração mais segura porque o compilador pega regressões
//
// Antes do strict mode:
function getConfig() {
  return config; // Pode ser undefined, ninguém sabe
}
const port = getConfig().port; // Bomba em produção

// Depois do strict mode:
function getConfig(): Config | undefined {
  return config;
}
const port = getConfig()?.port ?? 3000; // Seguro, com fallback

// O strict mode não te impede de nada.
// Ele te obriga a ser explícito sobre as decisões.
// "Esse valor pode ser null? Trate antes de usar."
// "Esse parâmetro aceita qualquer tipo? Defina qual."