TypeScript

let username: string = 'admin';
let age: number = 25;
let isActive: boolean = true;

// any — tip xavfsizligini yo'qotadi
let data: any = fetchData();
data.foo.bar(); // kompilyatsiya o'tadi, runtime xato bo'lishi mumkin

// unknown — xavfsiz alternativa
let input: unknown = getUserInput();
if (typeof input === 'string') {
  console.log(input.toUpperCase()); // endi string deb ma'lum
}

function throwError(msg: string): never {
  throw new Error(msg);
}

function logMessage(msg: string): void {
  console.log(msg);
  // return yo'q yoki return; — void
}

// interface — kengaytirish va merge
interface User {
  id: number;
  name: string;
}

interface User {
  email: string; // declaration merging
}

interface Admin extends User {
  role: 'admin';
}

// type — union va murakkab tiplar
type Status = 'pending' | 'active' | 'banned';
type ApiResponse<T> = { data: T; error: null } | { data: null; error: string };

type Point = { x: number; y: number };
type ID = string | number;

// interface implements (Angular service kontrakti)
interface Logger {
  log(message: string): void;
}

class ConsoleLogger implements Logger {
  log(message: string): void {
    console.log(message);
  }
}

type Role = 'user' | 'admin' | 'guest'; // string literal union

function setRole(role: Role) {
  console.log(role);
}
// setRole('superadmin'); // xato — faqat union a'zolari

type Timestamp = number & { readonly __brand: unique symbol }; // nominal type pattern

type Person = { name: string; age: number };
type Employee = { employeeId: string; department: string };
type Staff = Person & Employee; // ikkala to'plam property

const staff: Staff = {
  name: 'Ali',
  age: 30,
  employeeId: 'E001',
  department: 'IT',
};

// Discriminated union
type Result =
  | { status: 'success'; data: User[] }
  | { status: 'error'; message: string };

function handle(result: Result) {
  if (result.status === 'success') {
    console.log(result.data.length); // TS data borligini biladi
  } else {
    console.log(result.message);
  }
}

// Sodda generic
function firstElement<T>(arr: T[]): T | undefined {
  return arr[0];
}
firstElement([1, 2, 3]); // number | undefined
firstElement(['a', 'b']); // string | undefined

// Constraint
interface Identifiable {
  id: number;
}

function findById<T extends Identifiable>(items: T[], id: number): T | undefined {
  return items.find((item) => item.id === id);
}

// Generic class
class ApiStore<T> {
  private items: T[] = [];

  add(item: T): void {
    this.items.push(item);
  }

  getAll(): readonly T[] {
    return this.items;
  }
}

// Utility types
interface Product {
  id: number;
  name: string;
  price: number;
  description: string;
}

type ProductUpdate = Partial<Product>; // barcha optional
type ProductPreview = Pick<Product, 'id' | 'name' | 'price'>;
type ProductWithoutDesc = Omit<Product, 'description'>;
type ProductMap = Record<number, Product>;
type CreateProductFn = () => Product;
type ProductResult = ReturnType<CreateProductFn>; // Product

function formatValue(value: string | number): string {
  if (typeof value === 'number') {
    return value.toFixed(2); // value: number
  }
  return value.toUpperCase(); // value: string
}

class Cat {
  meow() { return 'miyov'; }
}
class Dog {
  bark() { return 'hav'; }
}

function speak(pet: Cat | Dog) {
  if (pet instanceof Cat) {
    return pet.meow();
  }
  return pet.bark();
}

interface Bird { fly(): void; }
interface Fish { swim(): void; }

function move(creature: Bird | Fish) {
  if ('fly' in creature) {
    creature.fly();
  } else {
    creature.swim();
  }
}

// Custom type guard
interface User {
  id: number;
  name: string;
}

function isUser(value: unknown): value is User {
  return (
    typeof value === 'object' &&
    value !== null &&
    'id' in value &&
    'name' in value &&
    typeof (value as User).id === 'number' &&
    typeof (value as User).name === 'string'
  );
}

function processInput(input: unknown) {
  if (isUser(input)) {
    console.log(input.name); // User deb ma'lum
  }
}

type IsString<T> = T extends string ? true : false;

type A = IsString<string>;  // true
type B = IsString<number>;  // false

// Distributive — union bo'ylab tarqaladi
type ToArray<T> = T extends any ? T[] : never;
type C = ToArray<string | number>; // string[] | number[]

// infer — return tipini olish
type MyReturnType<T> = T extends (...args: any[]) => infer R ? R : never;

function getUser() {
  return { id: 1, name: 'Ali' };
}

type UserReturn = MyReturnType<typeof getUser>;
// { id: number; name: string }

// Amaliy: null ni olib tashlash
type NonNullable<T> = T extends null | undefined ? never : T;

type Safe = NonNullable<string | null>; // string

interface Todo {
  title: string;
  completed: boolean;
  dueDate: Date;
}

// Barcha property optional
type PartialTodo = {
  [K in keyof Todo]?: Todo[K];
};

// Barcha property readonly
type ReadonlyTodo = {
  readonly [K in keyof Todo]: Todo[K];
};

// Modifier olib tashlash
type MutableTodo = {
  -readonly [K in keyof ReadonlyTodo]: ReadonlyTodo[K];
};

// Property nomini o'zgartirish pattern
type Getters<T> = {
  [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K];
};

type TodoGetters = Getters<Todo>;
// { getTitle: () => string; getCompleted: () => boolean; getDueDate: () => Date }

// Faqat string property'lar
type StringKeys<T> = {
  [K in keyof T as T[K] extends string ? K : never]: T[K];
};

type TodoStrings = StringKeys<Todo>; // { title: string }

type EventName = 'click' | 'focus' | 'blur';
type HandlerName = `on${Capitalize<EventName>}`;
// 'onClick' | 'onFocus' | 'onBlur'

type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE';
type ApiRoute = `/api/${string}`;

type UserRoutes =
  | '/api/users'
  | '/api/users/:id'
  | '/api/users/:id/posts';

type MethodRoute = `${HttpMethod} ${UserRoutes}`;
// 'GET /api/users' | 'POST /api/users' | ...

// CSS unit pattern
type CssValue = `${number}px` | `${number}rem` | `${number}%`;

function setWidth(value: CssValue) {
  document.body.style.width = value;
}

setWidth('100px');  // OK
// setWidth('100'); // xato

// String manipulation utility'lar
type Join<K, V> = K extends string ? `${K}:${V & string}` : never;
type Pair = Join<'name', string>; // 'name:string'

// Method decorator — chaqiruvni log qilish
function Log(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const original = descriptor.value;

  descriptor.value = function (...args: unknown[]) {
    console.log(`Chaqirildi: ${propertyKey}`, args);
    return original.apply(this, args);
  };

  return descriptor;
}

// Property decorator factory
function Required(message: string) {
  return function (target: object, propertyKey: string) {
    let value: unknown;
    Object.defineProperty(target, propertyKey, {
      get: () => value,
      set: (newVal) => {
        if (newVal === undefined || newVal === null) {
          throw new Error(message);
        }
        value = newVal;
      },
    });
  };
}

class UserService {
  @Required('name bo\'sh bo\'lmasin')
  name!: string;

  @Log
  greet(name: string): string {
    return `Salom, ${name}!`;
  }
}

// Angular misoli (konseptual)
// @Component({ selector: 'app-user', template: '<p>{{ name }}</p>' })
// @Injectable({ providedIn: 'root' })
// @Input() userId!: number;

// strictNullChecks yoqilganda:
let name: string = null; // xato — string | null kerak
let nameOrNull: string | null = null; // OK

function findUser(id: number): User | undefined {
  return users.find((u) => u.id === id);
}

const user = findUser(1);
// console.log(user.name); // xato — user undefined bo'lishi mumkin
console.log(user?.name); // OK

// noImplicitAny:
function parse(data) { // xato — parametr tipi yo'q
  return JSON.parse(data);
}

function parseSafe(data: string): unknown {
  return JSON.parse(data);
}