Inferența tipurilor în TypeScript

// TypeScript deduce singur tipurile acestor variabile
let name = "Alice";           // dedus ca string
let age = 30;                 // dedus ca number
let isActive = true;          // dedus ca boolean
let numbers = [1, 2, 3];      // dedus ca number[]
let mixed = [1, "two", true]; // dedus ca (string | number | boolean)[]

// Folosirea tipurilor deduse
name.toUpperCase();  // Funcționează pentru că name este dedus ca string
age.toFixed(2);      // Funcționează pentru că age este dedus ca number
// name.toFixed(2);  // Eroare: Proprietatea 'toFixed' nu există pe tipul 'string'

// Transformăm fișierul în modul, ca variabila locală `name` să nu intre în conflict cu cea globală predefinită
export {};

// Tipul returnat este dedus ca string
function greet(name: string) {
  return `Salut, ${name}!`;
}

// Tipul returnat este dedus ca number
function add(a: number, b: number) {
  return a + b;
}

// Tipul returnat este dedus ca string | number
function getValue(key: string) {
   if (key === "name") {
    return "Alice";
   } else {
    return 42;
   }
}
// Folosirea tipurilor returnate deduse
let greeting = greet("Bob");     // dedus ca string
let sum = add(5, 3);             // dedus ca number
let value = getValue("age");     // dedus ca string | number

// Tipul parametrului din callback este dedus din contextul metodei de tablou
const names = ["Alice", "Bob", "Charlie"];

// Parametrul 'name' este dedus ca string
names.forEach(name => {
  console.log(name.toUpperCase());
});

// Parametrul 'name' este dedus ca string, iar tipul returnat este dedus ca number
const nameLengths = names.map(name => {
  return name.length;
});

// nameLengths este dedus ca number[]

// Tipurile parametrilor din gestionarele de evenimente sunt și ele deduse
// (protejat printr-o verificare, ca fișierul să ruleze și în afara browserului, unde `document` nu există)
if (typeof document !== "undefined") {
  document.addEventListener("click", event => {
    // 'event' este dedus ca MouseEvent
    console.log(event.clientX, event.clientY);
  });
}

// TypeScript deduce tipul acestui obiect
const user = {
  id: 1,
  name: "Alice",
  email: "alice@example.com",
  active: true,
  details: {
    age: 30,
    address: {
      city: "New York",
      country: "USA"
    }
  }
};

// Accesarea proprietăților deduse
console.log(user.name.toUpperCase());
console.log(user.details.age.toFixed(0));
console.log(user.details.address.city.toLowerCase());

// Erorile de tip ar fi depistate
// console.log(user.age);                 // Eroare: Proprietatea 'age' nu există pe tipul '...'
// console.log(user.details.name);        // Eroare: Proprietatea 'name' nu există pe tipul '...'
// console.log(user.details.address.zip); // Eroare: Proprietatea 'zip' nu există pe tipul '...'

// Inferență de tip obișnuită (se lărgește la string)
let name = "Alice";  // tip: string

// Aserțiune const (se restrânge la tipul literal)
const nameConst = "Alice" as const;  // tip: "Alice"

// Cu obiecte
const user = {
  id: 1,
  name: "Alice",
  roles: ["admin", "user"] as const  // tuplu doar-citire
} as const;

// user.name = "Bob";  // Eroare: Nu se poate atribui lui 'name' pentru că este o proprietate doar-citire

// Transformăm fișierul în modul, ca variabila locală `name` să nu intre în conflict cu cea globală predefinită
export {};

function processValue(value: string | number) {
  // În acest bloc tipul este restrâns la string
  if (typeof value === "string") {
    console.log(value.toUpperCase());
  }
  // Aici tipul este restrâns la number
  else {
    console.log(value.toFixed(2));
  }
}

// Uniuni discriminate
interface Circle { kind: "circle"; radius: number; }
interface Square { kind: "square"; size: number; }
type Shape = Circle | Square;

function area(shape: Shape) {
  // Tipul este restrâns pe baza proprietății 'kind'
  switch (shape.kind) {
    case "circle":
      return Math.PI * shape.radius ** 2;
    case "square":
      return shape.size ** 2;
  }
}

// 1. Lasă TypeScript să deducă tipurile simple
let message = "Salut";  // Bine: aici nu este nevoie de un tip explicit

// 2. Scrie tipuri explicite pentru parametrii funcțiilor
function formatName(firstName: string, lastName: string) {
  return `${firstName} ${lastName}`;
}

// 3. Ia în calcul adăugarea tipului returnat pentru funcțiile complexe
function processData(input: string[]): { count: number; items: string[] } {
  return {
    count: input.length,
    items: input.map(item => item.trim())
  };
}

// 4. Folosește tipuri explicite pentru tablourile și obiectele goale
const emptyArray: string[] = [];  // Fără adnotare ar fi dedus ca any[]
const configOptions: Record<string, unknown> = {};  // Fără adnotare ar fi dedus ca {}

// 5. Folosește aserțiuni de tip atunci când TypeScript nu poate deduce corect
// (protejat printr-o verificare, ca fișierul să ruleze și în afara browserului, unde `document` nu există)
if (typeof document !== "undefined") {
  const canvas = document.getElementById("main-canvas") as HTMLCanvasElement;
}