ts-extras est une bibliothèque d'utilitaires esssentiels pour les projets TypeScript, offrant des fonctions pour simplifier les opérations courantes et renforcer la sécurité typique. Voici 10 techniques concrètes pour optimiser votre workflow.

1. Accès sécurisé aux éléments d'un tableau

Les méthodes arrayFirst et arrayLast permettent d'obtenir rsepectivement le premier et dernier élément d'un tableau avec un type inféré précis :

import { arrayFirst, arrayLast } from 'ts-extras';

const elements = ['a', 'b', 'c'] as const;
const premier = arrayFirst(elements); // 'a' (type exact)
const dernier = arrayLast(elements);   // 'c' (type exact)

2. Vérification de définition d'une valeur

La fonction assertDefined assure que la valeur n'est pas indéfinie, avec un message d'erreur clair :

import { assertDefined } from 'ts-extras';

function traiterUtilisateur(utilisateur?: Utilisateur) {
  assertDefined(utilisateur, 'Utilisateur requis');
  return utilisateur.nom;
}

3. Vérification de présence d'une propriété

La méthode isPropertyPresent combine vérification de présence et non-nullité :

import { isPropertyPresent } from 'ts-extras';

interface Utilisateur {
  nom?: string;
  age?: number;
}

const utilisateur: Utilisateur = { nom: 'Alice' };

if (isPropertyPresent(utilisateur, 'nom')) {
  console.log(utilisateur.nom.toUpperCase());
}

4. Mappage de valeurs d'objet

objectMapValues permet une transformation typée des propriétés d'un objet :

import { objectMapValues } from 'ts-extras';

const nombres = { x: 1, y: 2, z: 3 };
const doubles = objectMapValues(nombres, v => v * 2);
// { x: 2, y: 4, z: 6 }

5. Conversion sécurisée de types

La fonction safeCastTo offre une alternative plus sûre aux cast explicites :

import { safeCastTo } from 'ts-extras';

function estChaine(valeur: unknown): valeur is string {
  return typeof valeur === 'string';
}

const input: unknown = 'test';
const resultat = safeCastTo(input, estChaine);

6. Vérification d'inclusion dans un tableau

arrayIncludes améliore la précision des vérifications d'inclusion :

import { arrayIncludes } from 'ts-extras';

const fruits = ['pomme', 'banane', 'cerise'] as const;
if (arrayIncludes(fruits, 'pomme')) {
  // Type inféré comme élément du tableau
}

7. Vérification de présence simple

La fonction isPresent simplifie la vérification de nullité/undeifned :

import { isPresent } from 'ts-extras';

const valeur: string | null | undefined = 'valeur';
if (isPresent(valeur)) {
  console.log(valeur.length);
}

8. Mise à jour immuable d'objet

objectUpdate permet de modifier un objet sans altérer la référence originale :

import { objectUpdate } from 'ts-extras';

const utilisateur = { nom: 'Alice', age: 30 };
const nouvelUtilisateur = objectUpdate(utilisateur, 'age', a => a + 1);

9. Inversion logique de prédicat

La fonction not permet d'inverser facilement les résultats de prédicats :

import { not, isEmpty } from 'ts-extras';

const tableau = [1, 2, 3];
if (not(isEmpty)(tableau)) {
  console.log(tableau.length);
}

10. Accès sécurisé aux propriétés d'objet

isPropertyDefined évite les erreurs lors de l'accès à des propriétés potentiellement absentes :

import { isPropertyDefined } from 'ts-extras';

interface Configuration {
  urlApi?: string;
  timeout?: number;
}

const config: Configuration = {};
if (isPropertyDefined(config, 'urlApi')) {
  fetch(config.urlApi);
}

Pour intégrer ces outils, ajoutez d'abord le package :

npm install ts-extras
# ou
yarn add ts-extras

Importez ensuite les fonctions nécessaires :

import { arrayFirst, assertDefined, isPresent } from 'ts-extras';

Consultez les fichiers source pour découvrir toutes les implémentations détaillées.