TypeScript

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

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

function length(p: Point2D): number {
  return Math.sqrt(p.x ** 2 + p.y ** 2);
}

const v: Vector = { x: 3, y: 4 };
length(v); // OK, Vector ma dokładnie kształt Point2D, nazwa nie ma znaczenia

// Excess property check: literał obiektowy jest sprawdzany ściślej niż zmienna
length({ x: 3, y: 4, z: 0 }); // Error: 'z' nie istnieje w Point2D
const withZ = { x: 3, y: 4, z: 0 };
length(withZ); // OK, bo withZ przechodzi przez zmienną (nie fresh object literal)

type Handler = (e: { type: string }) => void;

const onClick: Handler = (e: { type: string; x: number; y: number }) => {
  console.log(e.x, e.y);
};
// Błąd w strict mode: parametr Handler nie gwarantuje pól x/y

function parseConfig(raw: unknown): string {
  if (typeof raw !== 'string') {
    throw new TypeError('config must be a string');
  }
  return raw.toUpperCase(); // OK, raw zawężony do string
}

function unsafeParse(raw: any): string {
  return raw.toUpperCase(); // kompiluje się, ale crashuje w runtime dla raw = 42
}

function assertUnreachable(x: never): never {
  throw new Error(`Unexpected value: ${JSON.stringify(x)}`);
}

function fail(message: string): never {
  throw new Error(message);
}

// zmienna typu never akceptuje tylko wartości typu never
function process(input: string | number) {
  if (typeof input === 'string') return input.length;
  if (typeof input === 'number') return input * 2;
  return assertUnreachable(input); // input tutaj ma typ never, bo obie gałęzie wyczerpane
}

type Input = string | number | Date;

function format(value: Input): string {
  if (typeof value === 'string') return value.trim();
  if (typeof value === 'number') return value.toFixed(2);
  return value.toISOString(); // zostaje tylko Date
}

interface Dog { bark(): void }
interface Cat { meow(): void }

function speak(animal: Dog | Cat) {
  if ('bark' in animal) {
    animal.bark(); // zawężone do Dog
  } else {
    animal.meow(); // zawężone do Cat
  }
}

interface ApiError {
  code: number;
  message: string;
}

function isApiError(value: unknown): value is ApiError {
  return (
    typeof value === 'object' &&
    value !== null &&
    'code' in value &&
    'message' in value
  );
}

async function handle(response: unknown) {
  if (isApiError(response)) {
    console.error(response.code, response.message); // zawężone do ApiError
    return;
  }
  console.log('ok', response);
}

function assertIsDefined<T>(value: T): asserts value is NonNullable<T> {
  if (value === null || value === undefined) {
    throw new Error('Value must be defined');
  }
}

function load(id: string | undefined) {
  assertIsDefined(id);
  return id.toUpperCase(); // id zawężone do string po tej linii
}

type Shape =
  | { kind: 'circle'; radius: number }
  | { kind: 'rectangle'; width: number; height: number }
  | { kind: 'triangle'; base: number; height: number };

function area(shape: Shape): number {
  switch (shape.kind) {
    case 'circle':
      return Math.PI * shape.radius ** 2;
    case 'rectangle':
      return shape.width * shape.height;
    case 'triangle':
      return (shape.base * shape.height) / 2;
    default: {
      const exhaustiveCheck: never = shape;
      throw new Error(`Unhandled shape: ${exhaustiveCheck}`);
    }
  }
}

type Shape2 = Shape | { kind: 'square'; side: number };

function area2(shape: Shape2): number {
  switch (shape.kind) {
    case 'circle': return Math.PI * shape.radius ** 2;
    case 'rectangle': return shape.width * shape.height;
    case 'triangle': return (shape.base * shape.height) / 2;
    default: {
      // Error: Type '{ kind: "square"; side: number }' is not assignable to type 'never'
      const exhaustiveCheck: never = shape;
      throw new Error(String(exhaustiveCheck));
    }
  }
}

function getProperty<T extends object, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}

const user = { id: 'u1', name: 'Ada', age: 30 };
const name = getProperty(user, 'name'); // typ: string
// getProperty(user, 'email'); // Error: 'email' nie jest kluczem user

function tuple<const T extends readonly unknown[]>(...items: T): T {
  return items;
}

const a = tuple('a', 'b', 'c');
// bez 'const': typ [string, string, string] (tuple z widened typami, nie string[])
// z 'const': typ readonly ["a", "b", "c"]

declare function makeConfig<const T>(config: T): T;
const config = makeConfig({ mode: 'production', retries: 3 });
// config.mode: "production" (literal), nie string

function merge<T extends object, U extends object>(a: T, b: U): T & U {
  return { ...a, ...b };
}

const merged = merge({ id: 1 }, { name: 'Ada' });
// typ merged: { id: number } & { name: string }

type ElementType<T> = T extends (infer U)[] ? U : never;
type A = ElementType<string[]>; // string
type B = ElementType<number>;   // never

type MyReturnType<T> = T extends (...args: any[]) => infer R ? R : never;
type C = MyReturnType<() => Promise<number>>; // Promise<number>

type ToArray<T> = T extends unknown ? T[] : never;
type D = ToArray<string | number>; // string[] | number[], nie (string | number)[]

// Zablokowanie dystrybucji: opakowanie T w krotkę wyłącza rozdzielanie po unii
type ToArrayNonDist<T> = [T] extends [unknown] ? T[] : never;
type E = ToArrayNonDist<string | number>; // (string | number)[]

type Getters<T> = {
  [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K];
};

interface Person { name: string; age: number }
type PersonGetters = Getters<Person>;
// { getName: () => string; getAge: () => number }

// Filtrowanie: klucz zmapowany na 'never' znika z wynikowego typu
type OmitByValue<T, V> = {
  [K in keyof T as T[K] extends V ? never : K]: T[K];
};
type WithoutStrings = OmitByValue<{ a: string; b: number; c: boolean }, string>;
// { b: number; c: boolean }

interface User {
  id: string;
  name: string;
  email: string;
  role: 'admin' | 'user';
}

type UserPatch = Partial<Pick<User, 'name' | 'email'>>;
// { name?: string; email?: string }

type PublicUser = Omit<User, 'email'>;
// { id: string; name: string; role: 'admin' | 'user' }

type UsersByRole = Record<User['role'], User[]>;
// { admin: User[]; user: User[] }

async function fetchUser(id: string) {
  return { id, name: 'Ada' };
}

type FetchUserReturn = ReturnType<typeof fetchUser>; // Promise<{ id: string; name: string }>
type FetchUserResult = Awaited<FetchUserReturn>;     // { id: string; name: string }

type Colors = Record<string, string | [number, number, number]>;

// Adnotacja: traci precyzję, 'red' ma typ string | [number,number,number]
const palette1: Colors = { red: [255, 0, 0], green: '#00ff00' };
// palette1.red.toUpperCase(); // Error: 'toUpperCase' nie istnieje na typie [number,number,number], wymaga zawężenia unii

// satisfies: waliduje kształt, ale zachowuje precyzyjny literal type
const palette2 = { red: [255, 0, 0], green: '#00ff00' } satisfies Colors;
// palette2.red ma typ [number, number, number] bez zawężania, dostępne np. palette2.red[0]