semantic-typescript 0.6.0 → 0.7.0

package/readme.fr.md

@@ -1,204 +1,213 @@
-# Semantic-TypeScript : Une bibliothèque de traitement de flux qui change de paradigme
+# **Semantic-TypeScript**
+**Flux, Indexés.** Vos données, sous contrôle précis.
 
-## Introduction
-Semantic-TypeScript représente une avancée significative dans la technologie de traitement de flux, synthétisant les concepts les plus efficaces des JavaScript GeneratorFunctions, des Java Streams et des paradigmes d'indexation de bases de données. Son principe de conception fondamental est centré sur la construction de pipelines de traitement de données exceptionnellement efficaces grâce à une évaluation paresseuse sophistiquée et une indexation intelligente. La bibliothèque offre une expérience d'opération de streaming rigoureusement type-safe et fonctionnellement pure, spécialement conçue pour le développement TypeScript et JavaScript contemporain.
+---
 
-Contrairement aux architectures de traitement synchrone conventionnelles, Semantic-TypeScript implémente un modèle unifié qui gère avec grâce à la fois les sources de données synchrones (Iterable) et asynchrones (AsyncIterable). Pendant la génération du flux, le flux et la terminaison des données sont précisément contrôlés par des mécanismes de rappel (callback), permettant à la bibliothèque de gérer avec une grâce exceptionnelle :
-- Les flux de données en temps réel (événements DOM, WebSockets, intervalles) avec un contrôle déterministe
-- Les jeux de données à grande échelle grâce à des pipelines paresseux et économes en mémoire
-- Les transformations de données complexes avec une API fluide et déclarative
+### Aperçu
 
-L'approche innovante de la bibliothèque réinvente fondamentalement la façon dont les développeurs interagissent avec les séquences de données, offrant à la fois des caractéristiques de performance sans précédent et une ergonomie pour le développeur dans un ensemble unique et cohérent.
+Semantic-TypeScript marque un bond en avant significatif dans la technologie de traitement des flux, **synthétisant** les concepts les plus efficaces de `GeneratorFunction` JavaScript, Java Streams et de l'indexation de style MySQL. Sa philosophie centrale est à la fois simple et puissante : construire des pipelines de traitement de données exceptionnellement efficaces grâce à une indexation intelligente, et non par itération de force brute.
 
-## Philosophie de base : Séparation de la Définition et de l'Exécution
-Une idée architecturale clé de Semantic-TypeScript est la séparation claire entre la définition d'un flux et son exécution :
-- **`Semantic<E>`** : Un modèle immuable et paresseux d'un pipeline de transformation de données. Il définit quelles opérations (filter, map, etc.) seront effectuées.
-- **`Collectable<E>`** : Une vue exécutable et matérialisée du flux. Elle est obtenue à partir d'un Semantic et fournit toutes les opérations terminales (collect, forEach, etc.) pour exécuter le pipeline et produire un résultat.
+Là où les bibliothèques conventionnelles imposent des boucles synchrones ou des chaînes de promesses maladroites, Semantic-TypeScript offre une expérience **entièrement asynchrone**, fonctionnellement pure et rigoureusement sûre au niveau des types, conçue pour répondre aux exigences du développement front-end moderne.
 
-Cette séparation impose un modèle mental clair et débloque des optimisations puissantes, comme le choix d'un `UnorderedCollectable` pour ignorer les tris inutiles et obtenir une vitesse maximale.
+Dans son modèle élégant, les données n'atteignent le consommateur que lorsque le pipeline en amont invoque explicitement les callbacks `accept` (et optionnellement `interrupt`). Vous avez un contrôle total sur le timing - exactement quand c'est nécessaire.
 
-## Pourquoi choisir Semantic-TypeScript ?
-Choisir la bonne bibliothèque pour le traitement de flux de données implique d'équilibrer performance, sûreté des types (type safety) et expressivité. Semantic-TypeScript est conçu pour exceller dans toutes ces dimensions.
+---
 
-### 1. Un paradigme unifié et type-safe pour toutes les séquences de données
-Il fournit une API déclarative cohérente pour traiter n'importe quelle séquence de données – qu'il s'agisse de tableaux statiques, d'événements en temps réel ou de morceaux de données asynchrones – tout en exploitant toute la puissance de TypeScript pour garantir une sûreté des types de bout en bout. Cela élimine toute une classe d'erreurs d'exécution et transforme la manipulation de flux en une activité prévisible et vérifiée par le compilateur.
+### Pourquoi les développeurs le préfèrent
 
-### 2. Performance sans compromis avec une "paresse" intelligente
-À sa base, la bibliothèque est construite sur l'évaluation paresseuse (lazy evaluation). Des opérations comme `filter`, `map`, et `flatMap` se contentent de composer un pipeline de traitement ; aucun travail n'est effectué tant qu'une opération terminale n'est invoquée. Ceci est couplé à des capacités de court-circuit (via `limit`, `anyMatch` ou des rappels `interrupt` personnalisés), ce qui permet d'arrêter le traitement prématurément, améliorant considérablement l'efficacité pour les flux grands ou infinis.
+- **Indexation Zéro-Boilerplate** — chaque élément porte son index naturel ou sur mesure.
+- **Style Purement Fonctionnel** — avec une inférence TypeScript complète.
+- **Flux d'Événements Étanches** — `useWindow`, `useDocument`, `useHTMLElement` et `useWebSocket` sont conçus avec la sécurité à l'esprit. Vous définissez la limite (en utilisant `limit(n)`, `sub(start, end)` ou `takeWhile(predicate)`) et la bibliothèque gère le nettoyage. Aucun écouteur résiduel, aucune fuite de mémoire.
+- **Statistiques Intégrées** — analyses numériques et bigint complètes incluant moyennes, médianes, modes, variance, asymétrie et kurtosis.
+- **Performances Prédictibles** — choisissez entre des collecteurs ordonnés ou non ordonnés selon vos besoins.
+- **Efficacité Mémoire** — les flux sont évalués paresseusement, atténuant les préoccupations de mémoire.
+- **Pas de Comportement Indéfini** — TypeScript garantit la sûreté des types et la nullabilité. Les données d'entrée restent inchangées sauf si elles sont explicitement modifiées dans vos fonctions de callback.
 
-### 3. La puissance du motif `Collector<E, A, R>`
-Inspiré de Java, le motif Collector est le moteur de la flexibilité. Il découple la spécification de la manière d'accumuler les éléments du flux de l'exécution du flux lui-même. La bibliothèque fournit un riche ensemble de collecteurs intégrés (`toArray`, `groupBy`, `summate`, etc.) pour les tâches courantes, tout en facilitant l'implémentation de votre propre logique de réduction complexe et réutilisable. C'est bien plus puissant et composable qu'un ensemble fixe de méthodes terminales.
+---
 
-### 4. Support de première classe pour les données Web modernes et asynchrones
-Semantic-TypeScript est conçu pour le développement contemporain. Il offre des méthodes d'usine natives pour les sources web modernes :
-- `useFrom(iterable)`, `useRange()` pour les données statiques
-- `useInterval()`, `useAnimationFrame()` pour les flux basés sur le temps
-- `useBlob()` pour le traitement de données binaires par morceaux (chunked)
-- `useWebSocket()`, `useDocument()`, `useWindow()` pour les flux d'événements en temps réel
+### Installation
 
-### 5. Au-delà de l'agrégation basique : Analyse statistique intégrée
-Allez au-delà des simples sommes et moyennes. La bibliothèque fournit les interfaces dédiées `NumericStatistics` et `BigIntStatistics`, offrant un accès immédiat à des mesures statistiques avancées directement depuis vos flux – variance, écart-type, médiane, asymétrie (skewness) et aplatissement (kurtosis). Cela transforme l'analyse de données complexes en une simple ligne de code.
-
-### 6. Conçu pour l'ergonomie du développeur
-- **API fluide et chaînable** : Écrivez des pipelines de données complexes sous forme de chaînes séquentielles lisibles.
-- **Suite utilitaire complète** : Gardes essentiels (`isFunction`, `isIterable`), utilitaires (`useCompare`, `useTraverse`) et interfaces fonctionnelles inclus.
-- **Intégration `Optional<T>`** : Modélise en toute sécurité l'absence d'une valeur, éliminant les problèmes de pointeur nul.
-- **Conseils de performance** : Guide clair sur quand utiliser la collection non ordonnée (`unordered`) pour la vitesse contre la collection ordonnée (`ordered`) pour la séquence.
-
-## Installation
 ```bash
 npm install semantic-typescript
 ```
+ou
+```bash
+yarn add semantic-typescript
+```
+
+---
 
-## Concepts de base en pratique
+### Démarrage Rapide
 
-### 1. Création de flux (Semantic)
-Les flux peuvent être créés à partir de diverses sources en utilisant des fonctions d'usine.
 ```typescript
-import { useFrom, useInterval, useDocument } from 'semantic-typescript';
+import { useOf, useFrom, useRange, useWindow, useHTMLElement, useWebSocket, useText, useStringify } from "semantic-typescript";
+
+// Statistiques numériques
+let summate: number = useOf(10, 20, 30, 40)
+  .map((n: number): number => n * 2)
+  .toNumericStatistics()  // Requis avant l'opération terminale
+  .summate();             // 200
+
+// Statistiques BigInt
+let summate: bigint = useOf(10n, 20n, 30n, 40n)
+  .map((n: bigint): bigint => n * 2)
+  .toBigIntStatistics()   // Requis avant l'opération terminale
+  .summate();             // 200n
+
+// Inverser un flux par index
+useFrom([1, 2, 3, 4, 5])
+  .redirect((element: E, index: bigint): bigint => -index) // Index négatif pour inversion
+  .toOrdered() // Appeler toOrdered() pour préserver l'ordre des index
+  .toArray(); // [5, 4, 3, 2, 1]
+
+// Mélanger un flux
+useFrom([1, 2, 3, 4, 5])
+  .shuffle()
+  .toOrdered()
+  .toArray(); // ex. [2, 5, 1, 4, 3]
+
+// Translater des éléments dans un flux
+useFrom([1, 2, 3, 4, 5])
+  .translate(2)  // Décaler les éléments de 2 positions vers la droite
+  .toOrdered()
+  .toArray(); // [4, 5, 1, 2, 3]
+
+useFrom([1, 2, 3, 4, 5])
+  .translate(-2) // Décaler les éléments de 2 positions vers la gauche
+  .toOrdered()
+  .toArray(); // [3, 4, 5, 1, 2]
+
+// Plage infinie avec terminaison anticipée
+useRange(0n, 1_000_000n)
+  .filter(n => n % 17n === 0n)
+  .limit(10n)          // S'arrêter après 10 éléments
+  .toUnordered()
+  .toArray();
 
-// Depuis un tableau statique
-const staticStream = useFrom([1, 2, 3, 4, 5]);
+// Redimensionnement de fenêtre en temps réel (s'arrête automatiquement après 5 événements)
+useWindow("resize")
+  .limit(5n)          // Crucial pour les flux d'événements
+  .toUnordered()
+  .forEach((ev, idx) => console.log(`Redimensionnement #${idx}`));
 
-// Depuis un générateur asynchrone
-const asyncStream = useFrom(async function*() {
-  yield 1;
-  yield 2;
-});
+// Écouter un élément HTML
+// <input id="input" type="text"/>
+useHTMLElement("#input", "change")
+  .limit(1)
+  .toUnordered()
+  .forEach((event: Event) => submit(event));
 
-// Un flux basé sur le temps
-const tickStream = useInterval(1000); // émet toutes les secondes
+// Écouter plusieurs éléments et événements
+useHTMLElement("input", ["change", "keyup"])
+  .takeWhile((event: Event): boolean => validate(event))
+  .toUnordered()
+  .forEach((event: Event) => submit(event));
 
-// Un flux d'événements DOM (voir note cruciale ci-dessous)
-const clickStream = useDocument('click');
-```
+// Écouter un WebSocket
+let webSocket = new WebSocket("ws://localhost:8080");
+webSocket.addEventListener("close", (): void => {
+  webSocket.close();  // Gérer le cycle de vie du WebSocket manuellement
+});
+useWebSocket(webSocket, "message")
+  .limit(1)
+  .toUnordered()
+  .forEach((message: MessageEvent) => console.log(message.data));
 
-### 2. Transformation de flux (Opérations intermédiaires)
-Les opérations sont enchaînées de manière paresseuse pour définir le pipeline.
-```typescript
-const processedStream = staticStream
-  .filter(x => x % 2 === 0) // Ne garde que les nombres pairs
-  .map(x => x * 10)         // Multiplie par 10
-  .flatMap(x => [x, x + 1]) // Transforme chaque élément en deux
-  .distinct();              // Supprime les doublons
-// Rien n'a été exécuté pour l'instant
+// Itérer sur une chaîne par point de code
+useText("My emotion now is: 😊, and semantic is 👍")
+  .toUnordered()
+  .log(); // Affiche la chaîne
+
+// Sérialiser en toute sécurité un objet avec références circulaires
+let o = {
+  a: 1,
+  b: "text",
+  c: [o.a, o.b, o.c] // Référence circulaire
+};
+// let text: string = JSON.stringify(o); // Lance une erreur
+let text: string = useStringify(o); // Produit en toute sécurité `{a: 1, b: "text", c: []}`
 ```
 
-### 3. Exécution de flux (Opérations terminales)
-Pour obtenir un résultat, vous devez obtenir un `Collectable` et invoquer une opération terminale.
-```typescript
-// Obtenir un collectable non ordonné pour la performance
-const resultArray = await processedStream.toUnordered().toArray();
-console.log(resultArray); // ex: [20, 21, 40, 41]
-
-// Utiliser un collecteur intégré
-const sum = await processedStream.toUnordered().collect(useSummate());
-console.log(sum);
-
-// Ou utiliser la méthode générique collect
-const customResult = await processedStream.toOrdered().collect(
-  () => new Map<number, number>(),
-  (map, element, index) => map.set(index, element),
-  map => map
-);
-```
+---
 
-### 4. Crucial : Travailler avec les flux d'événements
-Les flux d'événements (`useDocument`, `useWindow`, `useHTMLElement`, `useWebSocket`) sont par nature infinis. Vous devez utiliser des opérations comme `sub`, `takeWhile`, ou `limit` pour définir quand arrêter de collecter les événements et terminer le flux. Sinon, l'opération terminale attendra indéfiniment.
-```typescript
-import { useDocument } from 'semantic-typescript';
+### Concepts Fondamentaux
 
-// Collecter uniquement les 5 premiers clics
-const first5Clicks = await useDocument('click')
-  .limit(5) // <- Essentiel : limite le flux à 5 événements
-  .toUnordered()
-  .toArray();
+| Concept | Objectif | Quand l'utiliser |
+| :--- | :--- | :--- |
+| `AsynchronousSemantic` | Constructeur principal pour les flux asynchrones, événements et pipelines paresseux. | Événements temps réel, WebSockets, écouteurs DOM, flux de longue durée ou infinis. |
+| `SynchronousSemantic` | Constructeur pour les flux synchrones, en mémoire ou basés sur des boucles. | Données statiques, plages, itération immédiate. |
+| `toUnordered()` | Collecteur terminal le plus rapide (indexation basée sur Map). | Chemins critiques en performance (temps et espace O(n), pas de tri). |
+| `toOrdered()` | Collecteur trié, stable en index. | Lorsqu'un ordre stable ou un accès indexé est requis. |
+| `toNumericStatistics()` | Analyse statistique numérique riche (moyenne, médiane, variance, asymétrie, kurtosis, etc.). | Analyse de données et calculs statistiques. |
+| `toBigIntStatistics()` | Analyse statistique bigint riche. | Analyse de données et calculs statistiques pour grands entiers. |
+| `toWindow()` | Prise en charge des fenêtres glissantes et fixes. | Traitement de séries temporelles, traitement par lots et opérations avec fenêtres. |
 
-// Collecter les clics pendant une fenêtre de 10 secondes
-const clicksIn10s = await useDocument('click')
-  .takeWhile((_, index, startTime = Date.now()) => Date.now() - startTime < 10000)
-  .toUnordered()
-  .toArray();
+---
 
-// Collecter les clics de l'index 2 à 5 (base 0)
-const specificClicks = await useDocument('click')
-  .sub(2n, 6n) // <- Prend les éléments avec les index 2, 3, 4, 5
-  .toUnordered()
-  .toArray();
-```
-**Idée clé** : L'événement (par exemple, un `MouseEvent`) et son index d'émission séquentiel (sous forme de `bigint`) sont passés ensemble à travers le pipeline via le rappel `accept(event, index)`.
+**Règles d'Utilisation Importantes**
 
-### 5. Tirer parti des statistiques
-```typescript
-const numericStream = useFrom([10, 20, 30, 40, 50]).toNumeric();
-const average = await numericStream.average();
-const median = await numericStream.median();
-const standardDeviation = await numericStream.standardDeviation();
-const skewness = await numericStream.skewness();
-console.log(`Moyenne: ${average}, Médiane: ${median}, Écart-type: ${standardDeviation}`);
-```
+1.  **Flux d'événements** (`useWindow`, `useDocument`, `useHTMLElement`, `useWebSocket`, …) renvoient un `AsynchronousSemantic`.
+    → Vous **devez** appeler `.limit(n)`, `.sub(start, end)` ou `.takeWhile()` pour cesser l'écoute. Sinon, l'écouteur reste actif.
 
-## Fonctionnalités principales
-- **Deux types de flux** : Support complet à la fois de `SynchronousSemantic` (pour `Iterable`) et d'`AsynchronousSemantic` (pour `AsyncIterable` et les événements)
-- **Ensemble d'opérations riche** : `filter`, `map`, `flatMap`, `concat`, `distinct`, `sorted`, `limit`, `skip`, `peek`, `reverse`, `shuffle`
-- **Opérations terminales flexibles** : `collect` (avec collecteurs personnalisés), `toArray`, `toSet`, `toMap`, `forEach`, `reduce`, `findFirst`, `anyMatch`, `allMatch`, `count`
-- **Collecteurs avancés** : Collecteurs intégrés pour `joining`, `groupingBy`, `partitioningBy`, `summing`, `averaging`, `maxBy`, `minBy`
-- **Module statistique** : Méthodes prêtes à l'emploi pour `mean`, `median`, `mode`, `variance`, `standardDeviation`, `range`, `quantiles`, `skewness`, `kurtosis` sur les flux numériques/bigint
-- **Fonctions utilitaires** : Gardes de type (`isPromise`, `isAsyncIterable`), comparateurs (`useCompare`), traversée (`useTraverse`) et crochets de conversion
-- **`Optional<T>`** : Un conteneur monadique pour les valeurs nullables, intégré aux opérations de recherche
-
-## Aperçu de l'API
-
-### Classes et Interfaces de base
-- `Semantic<E>` / `AsynchronousSemantic<E>` : La définition abstraite du flux
-- `Collectable<E>` / `AsynchronousCollectable<E>` : Le flux exécutable avec les opérations terminales
-- `OrderedCollectable<E>` / `UnorderedCollectable<E>` : Versions matérialisées optimisées pour les opérations respectant l'ordre (`order-sensitive`) ou non (`order-insensitive`)
-- `Collector<E, A, R>` : L'abstraction pour les opérations de réduction mutables
-
-### Fonctions d'usine (`use*`)
-- **Depuis des sources** : `useFrom`, `useRange`, `useFill`, `useEmpty`
-- **Depuis le temps** : `useInterval`, `useAnimationFrame`
-- **Depuis les APIs Web** : `useBlob`, `useDocument`, `useWindow`, `useHTMLElement`, `useWebSocket`
-- **Collecteurs** : `useToArray`, `useGroupBy`, `useSummate`, `useJoin`, etc.
-
-## Notes sur la performance
-- **Évaluation paresseuse (Lazy Evaluation)** : Les pipelines sont composés sans exécution jusqu'à ce qu'une opération terminale soit appelée.
-- **Court-circuit (Short-Circuiting)** : Des opérations comme `limit`, `anyMatch` et `findFirst` arrêteront de traiter les éléments dès que le résultat est déterminé.
-- **Ordonné vs Non ordonné** :
-    - Utilisez `.toUnordered()` pour les opérations terminales lorsque l'ordre des éléments source n'a pas d'importance pour votre résultat (ex: pour `sum`, `max`, ou `toSet`). Cela peut permettre des optimisations internes qui sautent des étapes de tri coûteuses.
-    - Utilisez `.toOrdered()` lorsque la séquence est importante (ex: pour `toArray` où l'ordre doit être préservé).
-
-## Exemple pour commencer
-```typescript
-import { useFrom, useSummate, useGroupBy } from 'semantic-typescript';
-
-interface Transaction {
-  id: number;
-  amount: number;
-  category: string;
-}
-
-const transactions: Transaction[] = [
-  { id: 1, amount: 100, category: 'Food' },
-  { id: 2, amount: 200, category: 'Electronics' },
-  { id: 3, amount: 50, category: 'Food' },
-  { id: 4, amount: 300, category: 'Electronics' },
-];
-
-// Calculer le montant total par catégorie
-const totalsByCategory = await useFrom(transactions)
-  .toUnordered()
-  .collect(
-    useGroupBy(
-      t => t.category,
-      t => t.amount,
-      useSummate() // Collecteur pour les valeurs
-    )
-  );
-
-console.log(totalsByCategory); // Map { 'Food' => 150, 'Electronics' => 500 }
-```
+2.  **Opérations terminales** (`.toArray()`, `.count()`, `.average()`, `.reduce()`, `.findFirst()`, etc.) sont **uniquement disponibles après** conversion en collecteur :
+    ```typescript
+    .toUnordered()   // Temps et espace O(n), pas de tri
+    // ou
+    .toOrdered()     // Trié, maintient l'ordre
+    ```
+
+---
+
+### Caractéristiques de Performance
+
+| Collecteur | Complexité Temporelle | Complexité Spatiale | Trié ? | Le meilleur pour |
+| :--- | :--- | :--- | :--- | :--- |
+| `toUnordered()` | O(n) | O(n) | Non | Vitesse brute, ordre non requis. |
+| `toOrdered()` | O(2n) | O(n) | Oui | Ordre stable, accès indexé, analyses. |
+| `toNumericStatistics()` | O(2n) | O(n) | Oui | Opérations statistiques nécessitant des données triées. |
+| `toBigIntStatistics()` | O(2n) | O(n) | Oui | Opérations statistiques pour bigint. |
+| `toWindow()` | O(2n) | O(n) | Oui | Opérations de fenêtrage basées sur le temps. |
+
+Optez pour `toUnordered()` lorsque la vitesse est primordiale. Utilisez `toOrdered()` uniquement lorsque vous avez besoin d'un ordre stable ou de méthodes statistiques dépendant de données triées.
+
+---
+
+**Comparaison avec d'autres Processeurs de Flux Front-End**
+
+| Fonctionnalité | Semantic-TypeScript | RxJS | Itérateurs/Générateurs Async Natifs | Most.js |
+| :--- | :--- | :--- | :--- | :--- |
+| **Intégration TypeScript** | De première classe, fortement typé avec conscience native de l'index. | Excellente, mais implique des génériques complexes. | Bonne, nécessite un typage manuel. | Style fonctionnel fort. |
+| **Analyse Statistique Intégrée** | Prise en charge native complète pour `number` et `bigint`. | Non disponible nativement (nécessite des opérateurs personnalisés). | Aucune. | Aucune. |
+| **Indexation et Conscience de Position** | Indexation bigint native et puissante sur chaque élément. | Nécessite des opérateurs personnalisés (`scan`, `withLatestFrom`). | Compteur manuel requis. | Basique, pas d'index intégré. |
+| **Gestion des Flux d'Événements** | Usines dédiées et sûres au niveau des types avec contrôle explicite d'arrêt anticipé. | Puissante mais nécessite une gestion manuelle des abonnements. | Écouteur d'événements manuel + annulation. | Bonne `fromEvent`, léger. |
+| **Performance et Efficacité Mémoire** | Exceptionnelle – collecteurs optimisés `toUnordered()` et `toOrdered()`. | Très bonne, mais les chaînes d'opérateurs ajoutent de la surcharge. | Excellente (surcharge nulle). | Excellente. |
+| **Taille du Bundle** | Très léger. | Grand (même avec tree-shaking). | Zéro (natif). | Petit. |
+| **Philosophie de Conception d'API** | Modèle de collecteur fonctionnel avec indexation explicite. | Modèle Observable Réactif. | Modèle Itérateur / Générateur. | Fonctionnel, point-free. |
+| **Terminaison Anticipée et Contrôle** | Explicite (`interrupt`, `.limit()`, `.takeWhile()`, `.sub()`). | Bon (`take`, `takeUntil`, `first`). | Manuel (`break` dans `for await…of`). | Bon (`take`, `until`). |
+| **Support Synchrone et Asynchrone** | API unifiée – support de première classe pour les deux. | Principalement asynchrone. | Les deux, mais manuel. | Principalement asynchrone. |
+| **Courbe d'Apprentissage** | Douce pour les développeurs familiarisés avec les pipelines fonctionnels et indexés. | Plus raide (nombreux opérateurs, observables chauds/froids). | Faible. | Modérée. |
+
+**Avantages Clés de Semantic-TypeScript**
+
+*   Capacités statistiques et d'indexation intégrées uniques, éliminant le besoin d'un `reduce` manuel ou de bibliothèques externes.
+*   Contrôle explicite des flux d'événements prévient les fuites de mémoire courantes avec RxJS.
+*   Une conception synchrone/asynchrone unifiée fournit une API unique et cohérente pour divers cas d'usage.
+
+Cette comparaison illustre pourquoi Semantic-TypeScript est particulièrement bien adapté aux applications front-end TypeScript modernes qui exigent performance, sûreté des types et analyses riches sans le cérémonial des bibliothèques réactives traditionnelles.
+
+---
+
+### Prêt à Explorer ?
+
+Semantic-TypeScript transforme les flux de données complexes en pipelines lisibles, composables et haute performance. Que vous manipuliez des événements UI en temps réel, traitiez de grands ensembles de données ou construisiez des tableaux de bord analytiques, il fournit la puissance de l'indexation de niveau base de données avec l'élégance de la programmation fonctionnelle.
+
+**Prochaines Étapes :**
+
+*   Parcourez l'API entièrement typée dans votre IDE (toutes les exportations proviennent du package principal).
+*   Rejoignez la communauté grandissante de développeurs qui ont remplacé des itérateurs async alambiqués par des pipelines Semantic propres.
+
+**Semantic-TypeScript** — où les flux rencontrent la structure.
 
-Semantic-TypeScript est conçue pour les développeurs qui recherchent une bibliothèque de traitement de flux rigoureusement conçue, type-safe et haute performance. Elle apporte la puissance des modèles de transformation de données de niveau entreprise à l'écosystème TypeScript, parfaitement adaptée aux applications front-end gourmandes en données, au traitement de données Node.js, et à tout scénario où une manipulation élégante et efficace des séquences est requise.
+Commencez à construire dès aujourd'hui et expérimentez la différence qu'apporte une indexation bien pensée.
 
-[![GitHub](./GitHub.png)](https://github.com/eloyhere/semantic-typescript)  [![NPM](./NPM.png)](https://www.npmjs.com/package/semantic-typescript)
+**Construisez avec clarté, agissez avec confiance, et transformez les données avec intention.**