Tipuri de baza

// Tipuri primitive
let name: string = "Ion";
let age: number = 30;
let isActive: boolean = true;
let nothing: null = null;
let notDefined: undefined = undefined;
let bigNumber: bigint = 9007199254740991n;
let uniqueKey: symbol = Symbol("key");

// TypeScript poate INFERI tipurile (type inference)
let city = "Bucuresti";     // TypeScript infereaza: string
let count = 42;             // TypeScript infereaza: number
let done = false;           // TypeScript infereaza: boolean
// NU e nevoie sa scrieti tipul cand e evident din valoare!

// Arrays - doua sintaxe echivalente
let numbers: number[] = [1, 2, 3, 4, 5];
let names: Array<string> = ["Ana", "Ion", "Maria"];

// Array readonly
const colors: readonly string[] = ["red", "green", "blue"];
// colors.push("yellow"); // Error: Property 'push' does not exist

// Tuples - array cu lungime si tipuri fixe
let coordinates: [number, number] = [44.4268, 26.1025];
let record: [string, number, boolean] = ["Ion", 30, true];

// Named tuples (descriptive)
type UserTuple = [name: string, age: number, active: boolean];
let user: UserTuple = ["Ana", 25, true];

// Destructurare tuple
const [lat, lng] = coordinates;

// Tip obiect inline
let product: { name: string; price: number; inStock: boolean } = {
name: "Laptop",
price: 4999.99,
inStock: true
};

// Proprietati optionale
let config: { host: string; port: number; debug?: boolean } = {
host: "localhost",
port: 3000
// debug este optional, poate lipsi
};

// Readonly properties
let point: { readonly x: number; readonly y: number } = { x: 10, y: 20 };
// point.x = 30; // Error: Cannot assign to 'x' because it is a read-only property

// any - EVITATI! Dezactiveaza verificarea tipurilor
let dangerous: any = "string";
dangerous = 42;
dangerous = true;
dangerous.nonExistentMethod(); // No error! (dar crapa la runtime)

// unknown - alternativa sigura la any
let safe: unknown = "string";
safe = 42;
// safe.toFixed(); // Error! Nu puteti folosi fara verificare

// Trebuie sa verificati tipul inainte de utilizare
if (typeof safe === "number") {
safe.toFixed(2); // OK - TypeScript stie ca e number
}

// never - tip imposibil (functii care nu returneaza)
function throwError(message: string): never {
throw new Error(message);
}

function infiniteLoop(): never {
while (true) { /* ... */ }
}

// void - functii fara return
function logMessage(msg: string): void {
console.log(msg);
}

// Assertion cu 'as' (recomandat)
const input = document.getElementById("email") as HTMLInputElement;
input.value = "test@goai.ro";

// Assertion cu angle brackets (nu merge in JSX)
const element = <HTMLInputElement>document.getElementById("email");

// Non-null assertion (!) - promiti ca nu e null/undefined
const canvas = document.getElementById("canvas")!;
// Folositi cu grija - daca elementul nu exista, crapa la runtime!

// 'satisfies' - verifica tipul FARA a-l schimba
type ColorMap = Record<string, [number, number, number] | string>;

const palette = {
red: [255, 0, 0],
green: "#00ff00",
blue: [0, 0, 255]
} satisfies ColorMap;

// palette.red este tot [number, number, number], nu ColorMap value
palette.red.map(v => v * 2); // OK! Tipul exact e pastrat