Aller au contenu principal

Démarrage

Tout ce que vous devez savoir sur Pithos en 5 minutes.

Pithos est une bibliothèque utilitaire TypeScript sans aucune dépendance, conçue pour le développement web moderne. Un seul package vous offre la manipulation de données, la validation de schémas et la gestion fonctionnelle des erreurs : le tout tree-shakable et entièrement typé.

Installation​

npm install @pithos/core

C'est tout. Zéro dépendance signifie zéro prise de tête.

Qu'y a-t-il dans la boîte ?​

Pithos est un écosystème utilitaire complet composé de cinq modules :

ModuleCe qu'il fait
ArkheManipulation de données (tableaux, objets, chaînes, fonctions, ...)
KanonValidation de schémas avec support JIT
ZygosGestion fonctionnelle des erreurs (Result, Option, Either, Task)
SphalmaErreurs typées & codes d'erreur intégrés
TaphosGuide de migration et utilitaires dépréciés avec assistance IDE

Comment importer​

Pithos utilise des imports granulaires pour un tree-shaking optimal. Importez chaque fonction directement depuis son chemin de module, et votre bundler n'inclura que le code que vous utilisez réellement :

// Utilitaires de tableaux
import { chunk } from "pithos/arkhe/array/chunk";

// Validation
import { object, string, number, optional } from "pithos/kanon";

// Pattern Result
import { ok, err } from "pithos/zygos/result/result";

Quelques exemples​

Manipulation de données​

Les utilitaires Arkhe suivent un pattern cohérent : ils prennent les données en premier argument (data-first) et retournent une nouvelle valeur sans muter l'original (immutable).

Cela les rend sûrs à utiliser dans n'importe quel contexte, par exemple les mises à jour d'état d'un framework frontend ou le traitement côté serveur :

import { chunk } from "pithos/arkhe/array/chunk";
import { get } from "pithos/arkhe/object/get";

// Découper un tableau en morceaux
chunk([1, 2, 3, 4, 5], 2);
// → [[1, 2], [3, 4], [5]]

// Accès imbriqué sécurisé
const user = { profile: { address: { city: "Paris" } } };
get(user, "profile.address.city", "Unknown");
// → "Paris"

Validation​

Les schémas Kanon se composent ensemble pour décrire des structures de données complexes. La fonction parse retourne une union discriminée, donc TypeScript affine automatiquement le type dans chaque branche. Vous utilisez déjà Zod ? Le wrapper asZod fournit une API compatible, pour migrer progressivement tout en profitant du tree-shaking de Kanon :

import { object, string, number, optional, parse } from "pithos/kanon";
import { asZod } from "pithos/kanon/helpers/as-zod";

const userSchema = object({
  name: string(),
  email: string().email(),
  age: optional(number()),
});

// API Kanon
const result = parse(userSchema, data);
if (result.success) {
  console.log(result.data);
} else {
  console.error(result.error);
}

// API style Zod
const zSchema = asZod(userSchema);
const zodResult = zSchema.safeParse(data);
if (zodResult.success) {
  console.log(zodResult.data);
} else {
  console.error(zodResult.error.issues);
}

Gestion des erreurs​

ResultAsync encapsule les opérations basées sur les Promises dans le pattern Result.

Au lieu de try/catch, vous obtenez une valeur typée qui vous oblige à gérer les deux chemins : succès et échec :

import { ResultAsync } from "pithos/zygos/result/result-async";

const safeFetch = ResultAsync.fromThrowable(
  fetch,
  (error) => `Erreur réseau : ${error}`
);

const result = await safeFetch("/api/users/1");

if (result.isOk()) {
  console.log(result.value);
} else {
  console.error(result.error); // Pas besoin de try/catch
}

Pourquoi les développeurs l'adorent​

Utilitaires TypeScript sans dépendance, tree-shakable et type-safe

Inférence TypeScript complète. Typez une fois, inférez partout. Pas de génériques manuels, pas de fuites any.

Zéro dépendance. Sécurité totale de la chaîne d'approvisionnement. Ce que vous installez est ce que vous obtenez.

Tree-shakable par conception. N'importez que ce que vous utilisez. Votre bundle reste léger.

JavaScript moderne. ES2020+, sans héritage obsolète.

Ce que vos utilisateurs y gagnent​

Avantages de performance : exécution plus rapide, bundles plus petits, fiabilité éprouvée

~7× plus rapide en moyenne. Votre application est plus réactive. Les utilisateurs attendent moins, les interactions sont plus fluides.

~9× plus petit en moyenne. Les pages chargent vite, même sur des connexions lentes ou des appareils bas de gamme.

Fiabilité éprouvée. Ça fonctionne, tout simplement. Pas de crashs surprise ni de bugs de cas limites.

Pas d'erreurs silencieuses. Les bugs sont détectés avant le déploiement, vos utilisateurs ne rencontrent jamais de comportements inexplicables.

Et ensuite ?​

Vous cherchez des cas d'usage ?

Explorez des exemples pratiques et trouvez le bon utilitaire pour vos besoins dans l'Explorateur de cas d'usage.