Interfaces et modèles

// ✓ Un type utilisé uniquement par ce composant → dans le même fichier
interface SortOption {
  value: 'price' | 'rating' | 'name';
  label: string;
}

@Component({ selector: 'app-sort-menu', /* ... */ })
export class SortMenu {
  protected readonly options: SortOption[] = [
    { value: 'price', label: 'Prix' },
    { value: 'rating', label: 'Note' },
  ];
}

// models/product-dto.ts — EXACTEMENT la forme venant du serveur
export interface ProductDto {
  id: number;
  product_name: string;
  price_cents: number;
  stock: number;
  created_at: string;       // ISO string
  discount: number | null;
}

// models/product.ts — ce dont l’UI a besoin
export interface Product {
  id: number;
  name: string;
  price: number;            // unités monétaires, pas des centimes
  inStock: boolean;         // dérivé
  createdAt: Date;
  discount?: number;        // pas de null
}

// models/product-mapper.ts — le seul endroit qui connaît les deux
export function toProduct(dto: ProductDto): Product {
  return {
    id: dto.id,
    name: dto.product_name,
    price: dto.price_cents / 100,
    inStock: dto.stock > 0,
    createdAt: new Date(dto.created_at),
    ...(dto.discount !== null && { discount: dto.discount }),
  };
}

// interface : formes d’objets (extensible, messages d’erreur clairs)
export interface User {
  id: number;
  name: string;
}
export interface Admin extends User {
  permissions: string[];
}

// type : unions, intersections, types dérivés, fonctions
export type Role = 'admin' | 'editor' | 'viewer';
export type Id = number | string;
export type UserPreview = Pick<User, 'id' | 'name'>;
export type UserPatch = Partial<Omit<User, 'id'>>;
export type Comparator<T> = (a: T, b: T) => number;
export type LoadState<T> = { status: 'loading' } | { status: 'ok'; data: T } | { status: 'error'; error: string };

// ✓ Une union de chaînes + un objet `as const` plutôt qu’un enum
export const ORDER_STATUSES = ['pending', 'paid', 'shipped', 'cancelled'] as const;
export type OrderStatus = (typeof ORDER_STATUSES)[number]; // 'pending' | 'paid' | ...

export const ORDER_LABELS: Record<OrderStatus, string> = {
  pending: 'En attente',
  paid: 'Payé',
  shipped: 'Expédié',
  cancelled: 'Annulé',
}; // si vous ajoutez un statut et oubliez son libellé → erreur de compilation

// Dans le template : @for (s of statuses; track s) { ... } — facile à parcourir, sans Object.values(Enum)

// ✓ Des noms clairs, sans préfixes/suffixes inutiles
interface Product {}                 // pas IProduct, pas ProductModel, pas ProductInterface
interface ProductDto {}              // la forme venant de l’API
interface CreateProductRequest {}    // le corps du POST
interface ProductFilters {}          // état de l’UI
type ProductId = number;             // alias sémantique (optionnel)

// ✗ Des interfaces pour les services « parce que »
interface IProductService { list(): Observable<Product[]>; } // n’apporte rien
// Envie de plusieurs implémentations / mocks ? → une classe abstraite comme token (voir « inject() & @Service() »)

// Dérivez les types depuis la source de vérité au lieu de les réécrire
type UserRow = Pick<User, 'id' | 'name' | 'email'>;
type ProductForm = Omit<Product, 'id' | 'createdAt'>;
type Store = InstanceType<typeof ProductsStore>;
type CartItem = ReturnType<CartStore['items']>[number];

// Un schéma de validation = type + validation à l’exécution, une seule source
const UserSchema = z.object({ id: z.number(), name: z.string(), email: z.email() });
type User = z.infer<typeof UserSchema>;

// Types générés depuis OpenAPI (openapi-typescript, orval, ng-openapi-gen)
import type { components } from './generated/api';
type ProductDto = components['schemas']['Product'];