Tipuri literale în TypeScript

// O variabilă cu un tip literal de șir
let direction: "north" | "south" | "east" | "west";

// Atribuiri valide
direction = "north";
direction = "south";

// Atribuirile invalide ar produce erori
// direction = "northeast"; // Eroare: tipul '"northeast"' nu poate fi atribuit tipului '"north" | "south" | "east" | "west"'
// direction = "up";        // Eroare: tipul '"up"' nu poate fi atribuit tipului '"north" | "south" | "east" | "west"'

// Folosirea tipurilor literale de șir în funcții
function move(direction: "north" | "south" | "east" | "west") {
  console.log(`Deplasare spre ${direction}`);
}

move("east");  // Valid
// move("up");  // Eroare: argumentul de tip '"up"' nu poate fi atribuit parametrului de tip...

// O variabilă cu un tip literal numeric
let diceRoll: 1 | 2 | 3 | 4 | 5 | 6;

// Atribuiri valide
diceRoll = 1;
diceRoll = 6;

// Atribuirile invalide ar produce erori
// diceRoll = 0;      // Eroare: tipul '0' nu poate fi atribuit tipului '1 | 2 | 3 | 4 | 5 | 6'
// diceRoll = 7;      // Eroare: tipul '7' nu poate fi atribuit tipului '1 | 2 | 3 | 4 | 5 | 6'
// diceRoll = 2.5;    // Eroare: tipul '2.5' nu poate fi atribuit tipului '1 | 2 | 3 | 4 | 5 | 6'

// Folosirea tipurilor literale numerice în funcții
function rollDice(): 1 | 2 | 3 | 4 | 5 | 6 {
  return Math.floor(Math.random() * 6) + 1 as 1 | 2 | 3 | 4 | 5 | 6;
}

const result = rollDice();
console.log(`Ai obținut un ${result}`);

// Un tip care poate avea doar valoarea literală 'true'
type YesOnly = true;

// O funcție care trebuie să returneze true
function alwaysSucceed(): true {
  // Returnează întotdeauna valoarea literală 'true'
  return true;
}

// Literal boolean combinat cu alte tipuri
type SuccessFlag = true | "success" | 1;
type FailureFlag = false | "failure" | 0;

function processResult(result: SuccessFlag | FailureFlag) {
  if (result === true || result === "success" || result === 1) {
    console.log("Operațiunea a reușit");
  } else {
    console.log("Operațiunea a eșuat");
  }
}

processResult(true);      // "Operațiunea a reușit"
processResult("success"); // "Operațiunea a reușit"
processResult(1);         // "Operațiunea a reușit"
processResult(false);     // "Operațiunea a eșuat"

// Obiect cu valori literale pentru proprietăți
type HTTPSuccess = {
  status: 200 | 201 | 204;
  statusText: "OK" | "Created" | "No Content";
  data: any;
};

type HTTPError = {
  status: 400 | 401 | 403 | 404 | 500;
  statusText: "Bad Request" | "Unauthorized" | "Forbidden" | "Not Found" | "Internal Server Error";
  error: string;
};

type HTTPResponse = HTTPSuccess | HTTPError;

// Aici este nevoie de o gardă de tip: o simplă verificare de interval numeric nu restrânge uniunea
function isSuccess(response: HTTPResponse): response is HTTPSuccess {
  return response.status >= 200 && response.status < 300;
}

function handleResponse(response: HTTPResponse) {
  if (isSuccess(response)) {
    console.log(`Succes: ${response.statusText}`);
    console.log(response.data);
  } else {
    console.log(`Eroare ${response.status}: ${response.statusText}`);
    console.log(`Mesaj: ${response.error}`);
  }
}

// Exemplu de utilizare
const successResponse: HTTPSuccess = {
  status: 200,
  statusText: "OK",
  data: { username: "john_doe", email: "[email protected]" }
};

const errorResponse: HTTPError = {
  status: 404,
  statusText: "Not Found",
  error: "Utilizatorul nu a fost găsit în baza de date"
};

handleResponse(successResponse);
handleResponse(errorResponse);

// Literali șablon de bază
type Direction = "north" | "south" | "east" | "west";
type Distance = "1km" | "5km" | "10km";

// Folosirea literalilor șablon pentru a le combina
type DirectionAndDistance = `${Direction}-${Distance}`;
// "north-1km" | "north-5km" | "north-10km" | "south-1km" | ...

let route: DirectionAndDistance;
route = "north-5km";   // Valid
route = "west-10km";   // Valid
// route = "north-2km";   // Eroare
// route = "5km-north";   // Eroare

// Manipulare avansată a șirurilor
type EventType = "click" | "hover" | "scroll";
type EventTarget = "button" | "link" | "div";
type EventName = `on${Capitalize<EventType>}${Capitalize<EventTarget>}`;
// "onClickButton" | "onClickLink" | "onClickDiv" | ...

// Acces dinamic la proprietăți
type User = {
  id: number;
  name: string;
  email: string;
  createdAt: Date;
};

type GetterName<T> = `get${Capitalize<string & keyof T>}`;
type UserGetters = {
  [K in keyof User as GetterName<User>]: () => User[K];
};
// { getId: () => number; getName: () => string; ... }

// Potrivirea tiparelor de șiruri
type ExtractRouteParams<T extends string> =
  T extends `${string}:${infer Param}/${infer Rest}`
    ? Param | ExtractRouteParams<Rest>
    : T extends `${string}:${infer Param}`
      ? Param
    : never;

type Params = ExtractRouteParams<"/users/:userId/posts/:postId">;  // "userId" | "postId"

// Unități și valori CSS
type CssUnit = 'px' | 'em' | 'rem' | '%' | 'vh' | 'vw';
type CssValue = `${number}${CssUnit}`;

let width: CssValue = '100px';    // Valid
let height: CssValue = '50%';     // Valid
// let margin: CssValue = '10';   // Eroare
// let padding: CssValue = '2ex'; // Eroare

// Versionarea unui API
type ApiVersion = 'v1' | 'v2' | 'v3';
type Endpoint = 'users' | 'products' | 'orders';
type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE';

type ApiUrl = `https://api.example.com/${ApiVersion}/${Endpoint}`;

// Exemplu complex: constructor dinamic de interogări SQL
type Table = 'users' | 'products' | 'orders';
type Column<T extends Table> =
  T extends 'users' ? 'id' | 'name' | 'email' | 'created_at' :
  T extends 'products' ? 'id' | 'name' | 'price' | 'in_stock' :
  T extends 'orders' ? 'id' | 'user_id' | 'total' | 'status' : never;

type WhereCondition<T extends Table> = {
  [K in Column<T>]?: {
    equals?: any;
    notEquals?: any;
    in?: any[];
  };
};

function query<T extends Table>(
  table: T,
  where?: WhereCondition<T>
): `SELECT * FROM ${T}${string}` {
  // Implementarea ar construi interogarea
  return `SELECT * FROM ${table}` as const;
}

// Utilizare
const userQuery = query('users', {
  name: { equals: 'John' },
  created_at: { in: ['2023-01-01', '2023-12-31'] }
});
// Tip: "SELECT * FROM users WHERE ..."

// Transformăm fișierul în modul, ca tipul local EventTarget să nu intre în conflict cu globala încorporată
export {};