// TypeScript source
function add(a: number, b: number): number {
  return a + b;
}

const result: number = add(2, 3);

// Compiled JavaScript output (types erased)
function add(a, b) {
  return a + b;
}

const result = add(2, 3);

// JavaScript — no annotations, dynamic types
let count = 0;
count = 'oops';  // Valid JS — no error, but probably wrong

function double(n) {
  return n * 2;
}

double('5');   // Returns '55' (string * 2 === NaN? No — JS coerces)
               // Actually: '5' * 2 = 10 because * coerces to number
               // But: '5' + 2 = '52' — surprise!

// TypeScript — explicit contracts
let count: number = 0;
count = 'oops';  // Error: Type 'string' is not assignable to type 'number'

function double(n: number): number {
  return n * 2;
}

double('5');   // Error: Argument of type 'string' is not assignable to parameter of type 'number'

// TypeScript infers the type from the assignment
let name = 'Alice';          // inferred: string
let age = 30;                // inferred: number
let active = true;           // inferred: boolean

// TypeScript infers the return type from the function body
function square(n: number) {
  return n * n;              // inferred return type: number
}

// TypeScript infers array element types
const scores = [95, 87, 92]; // inferred: number[]
scores.push('A');            // Error: Argument of type 'string' is not assignable to type 'number'

interface Product {
  id: number;
  name: string;
  price: number;
}

function displayProduct(product: Product) {
  // Error: Property 'titel' does not exist on type 'Product'.
  // Did you mean 'name'?
  console.log(product.titel);
}

// JavaScript — null is silent
function getUser(id) {
  return database.find(id);  // might return null
}

const user = getUser(42);
console.log(user.name);  // TypeError at runtime if user is null

// TypeScript with strictNullChecks
function getUser(id: number): User | null {
  return database.find(id) ?? null;
}

const user = getUser(42);

// Error: Object is possibly null
console.log(user.name);

// Correct: handle the null case explicitly
if (user !== null) {
  console.log(user.name);  // TypeScript knows user is User here
}

// Or use optional chaining
console.log(user?.name);  // string | undefined — safe

interface Point {
  x: number;
  y: number;
}

// This works even though we didn't say "implements Point"
function printPoint(p: Point) {
  console.log(`(${p.x}, ${p.y})`);
}

// Any object with x and y is compatible
const origin = { x: 0, y: 0 };
const fancy = { x: 10, y: 20, label: 'Home' };  // extra property is fine

printPoint(origin);  // OK
printPoint(fancy);   // OK — structural typing accepts extra properties

// JavaScript pattern — manual enum simulation
const Direction = Object.freeze({
  Up: 'UP',
  Down: 'DOWN',
  Left: 'LEFT',
  Right: 'RIGHT',
});

// No compile-time protection
function move(dir) {
  // dir could be anything
}

// TypeScript enum
enum Direction {
  Up = 'UP',
  Down = 'DOWN',
  Left = 'LEFT',
  Right = 'RIGHT',
}

function move(dir: Direction) {
  console.log(dir);
}

move(Direction.Up);   // OK
move('diagonal');     // Error: Argument of type '"diagonal"' is not assignable to type 'Direction'

// JavaScript — works, but loses type information
function first(array) {
  return array[0];  // always returns 'any' — type is lost
}

const n = first([1, 2, 3]);    // we know it's a number, but JS doesn't
const s = first(['a', 'b']);   // same function, different types — JS can't tell

// TypeScript generic — preserves type information
function first<T>(array: T[]): T | undefined {
  return array[0];
}

const n = first([1, 2, 3]);    // TypeScript knows: n is number | undefined
const s = first(['a', 'b']);   // TypeScript knows: s is string | undefined

n?.toFixed(2);    // OK — number method available
s?.toUpperCase(); // OK — string method available

JavaScript workflow:
  Write .js → Run directly in Node.js or browser

TypeScript workflow:
  Write .ts → tsc / esbuild / SWC → .js → Run in Node.js or browser

# Install types for packages that don't include them
npm install --save-dev @types/node   # Node.js built-in types
npm install --save-dev @types/lodash # Lodash types