Exclude, Extract і NonNullable: фільтрація об’єднань

type Status = "idle" | "loading" | "success" | "error";

type FinishedStatus = Exclude<Status, "idle" | "loading">;
// "success" | "error"

type Result = Exclude<T, U>;
// залишити елементи T, які не сумісні з U

type Result =
  | { status: "success"; data: string }
  | { status: "error"; message: string }
  | { status: "loading" };

type NonLoadingResult = Exclude<Result, { status: "loading" }>;
// { status: "success"; data: string }
// | { status: "error"; message: string }

type AllRoles = "admin" | "editor" | "author" | "viewer";

type PublicRoles = Exclude<AllRoles, "admin">;
// "editor" | "author" | "viewer"

type Status = "idle" | "loading" | "success" | "error";

type ActiveStatus = Extract<Status, "loading" | "success">;
// "loading" | "success"

type Result = Extract<T, U>;
// залишити елементи T, які сумісні з U

type Permission = "read" | "write" | "delete";

type ReadOrWrite = Extract<Permission, "read" | "write">;
// "read" | "write"

type WithoutReadOrWrite = Exclude<Permission, "read" | "write">;
// "delete"

type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "rectangle"; width: number; height: number }
  | { kind: "square"; size: number };

type Circle = Extract<Shape, { kind: "circle" }>;
// { kind: "circle"; radius: number }

type Rectangle = Extract<Shape, { kind: "rectangle" }>;
// { kind: "rectangle"; width: number; height: number }

function getCircleArea(circle: Circle): number {
  return Math.PI * circle.radius ** 2;
}

const circle: Circle = {
  kind: "circle",
  radius: 10,
};

console.log(getCircleArea(circle));

type MyExclude<T, U> = T extends U ? never : T;
type MyExtract<T, U> = T extends U ? T : never;

T extends U ? TypeIfTrue : TypeIfFalse

type MyExclude<T, U> = T extends U ? never : T;

type Result = MyExclude<"a" | "b" | "c", "b">;
// "a" | never | "c"
// "a" | "c"

type MyExtract<T, U> = T extends U ? T : never;

type Result = MyExtract<"a" | "b" | "c", "b" | "c">;
// never | "b" | "c"
// "b" | "c"

type Value = string | number | null | undefined;

type DefinedValue = NonNullable<Value>;
// string | number

type MyNonNullable<T> = Exclude<T, null | undefined>;

type UserName = string | null | undefined;

function printUserName(name: NonNullable<UserName>): void {
  console.log(name.toUpperCase());
}

printUserName("Olena");
// printUserName(null);      // Помилка типів
// printUserName(undefined); // Помилка типів

type User = {
  id: number;
  email: string | null;
  phone?: string;
};

type RequiredEmail = NonNullable<User["email"]>;
// string

type DefinedPhone = NonNullable<User["phone"]>;
// string

type ApiState =
  | { status: "idle" }
  | { status: "loading" }
  | { status: "success"; data: string[] }
  | { status: "error"; message: string };

type CompletedState = Exclude<
  ApiState,
  { status: "idle" } | { status: "loading" }
>;
// { status: "success"; data: string[] }
// | { status: "error"; message: string }

type SuccessState = Extract<ApiState, { status: "success" }>;
// { status: "success"; data: string[] }

type ErrorState = Extract<ApiState, { status: "error" }>;
// { status: "error"; message: string }

type OptionalData = string[] | null | undefined;
type Data = NonNullable<OptionalData>;
// string[]

function printSuccess(state: SuccessState): void {
  console.log(`Отримано елементів: ${state.data.length}`);
}

function printError(state: ErrorState): void {
  console.error(state.message);
}

const success: SuccessState = {
  status: "success",
  data: ["TypeScript", "JavaScript"],
};

const error: ErrorState = {
  status: "error",
  message: "Не вдалося завантажити дані",
};

printSuccess(success);
printError(error);

type ApiResponse =
  | { status: "success"; data: string[] }
  | { status: "success"; data: null }
  | { status: "error"; message: string }
  | null
  | undefined;

type SuccessResponse = Extract<ApiResponse, { status: "success" }>;
// { status: "success"; data: string[] }
// | { status: "success"; data: null }

type ResponseData = SuccessResponse["data"];
// string[] | null

type DefinedResponseData = NonNullable<ResponseData>;
// string[]

let value: string | null = null;

// value.toUpperCase(); // Помилка: value може бути null

function printValue(value: string | null | undefined): void {
  if (value !== null && value !== undefined) {
    console.log(value.toUpperCase());
  }
}

type Input = string | null | undefined;
type SafeInput = NonNullable<Input>;
// string

type Event =
  | { type: "click"; x: number }
  | { type: "keydown"; key: string };

// Це не вилучає подію "click":
type Wrong = Exclude<Event, { type: string }>;

type WithoutClick = Exclude<Event, { type: "click" }>;
// { type: "keydown"; key: string }

type Role = "admin" | "editor" | "viewer";

type OnlyAdmin = Extract<Role, "admin">;
// "admin"

type WithoutAdmin = Exclude<Role, "admin">;
// "editor" | "viewer"

const value: string | null = Math.random() > 0.5 ? "ok" : null;

// NonNullable не є функцією і не змінює value під час виконання.

type DefinedValue = NonNullable<typeof value>;
// string

if (value !== null) {
  console.log(value.toUpperCase());
}

type Item =
  | { kind: "text"; value: string }
  | { kind: "number"; value: number };

type TextItem = Extract<Item, { kind: "text" }>;
// { kind: "text"; value: string }

type BooleanItem = Extract<Item, { kind: "boolean" }>;
// never