# General Translation Integrations: API de collecte
URL: https://generaltranslation.com/fr/docs/integrations/rrweb/reference/harvest.mdx
Docs index: https://generaltranslation.com/llms.txt
Description: Associez les nœuds de texte enregistrés aux catalogues de paramètres régionaux publiés. Référence d'API pour la collecte gt-rrweb.

Importez les valeurs de collecte depuis `gt-rrweb/harvest`. La plupart des applications configurent la collecte via [`GTRecorder`](/docs/integrations/rrweb/reference/recorder#gt-recorder) ; l&#39;API directe prend en charge les pipelines d&#39;enregistrement personnalisés.

## Aperçu [#overview]

| API                                          | Description                                                                                                                       |
| -------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- |
| [`harvestLocales`](#harvest-locales)         | Construit les overlays pour les paramètres régionaux cibles demandés, à l&#39;exclusion du paramètre régional source sélectionné. |
| [`harvestHash`](#harvest-hash)               | Construit les overlays avec un paramètre régional source et un loader explicites.                                                 |
| [`flattenEntry`](#flatten-entry)             | Aplatit le GTJSON traduit en feuilles affichées.                                                                                  |
| [`collectRecordedText`](#recorded-text)      | Collecte les nœuds de texte enregistrés par id de nœud rrweb.                                                                     |
| [`recordingHasHashes`](#recording-hashes)    | Vérifie si le flux contient des hachages de traduction.                                                                           |
| [`collectHashNodes`](#hash-nodes)            | Collecte les nœuds de traduction hachés et le texte descendant.                                                                   |
| [`overlayFromDict`](#overlay-dict)           | Aligne les nœuds hachés sur un catalogue de traduction.                                                                           |
| [`stringOverlay`](#string-overlay)           | Fait correspondre les chaînes source non encapsulées via le hachage du message.                                                   |
| [`HarvestOptions` et types associés](#types) | Décrivent les loaders, les overlays, les catalogues et les valeurs GTJSON.                                                        |

## `harvestLocales` [#harvest-locales]

```ts
function harvestLocales(
  events: eventWithTime[],
  locales: string[],
  options?: HarvestOptions
): Promise<LocaleTextOverlay>;
```

`locales[0]` correspond au paramètre régional source de secours. La fonction ignore le paramètre régional source sélectionné et charge chaque catalogue cible restant via `options.loadTranslations` ; sans loader, elle renvoie un overlay vide. Lors de la collecte d&#39;un bundle de recorder, la source explicite ou dérivée du cookie doit être égale à `locales[0]`, car le recorder intègre cette première entrée comme source de replay.

| Option             | Description                                                                        | Type                                       | Facultatif | Valeur par défaut                             |
| ------------------ | ---------------------------------------------------------------------------------- | ------------------------------------------ | ---------- | --------------------------------------------- |
| `loadTranslations` | Charge un catalogue publié associant hachages et contenus, par paramètre régional. | `(locale: string) => Promise<unknown>`     | Oui        | —                                             |
| `hashMessage`      | Associe les chaînes sources brutes aux hachages déjà utilisés par le catalogue.    | `(message: string) => string \| undefined` | Oui        | —                                             |
| `sourceLocale`     | Identifie le paramètre régional visible dans l&#39;enregistrement.                 | `string`                                   | Oui        | Cookie de locale configuré, puis `locales[0]` |
| `localeCookieName` | Nomme le cookie utilisé pour détecter le paramètre régional source.                | `string`                                   | Oui        | —                                             |

Les entrées [`<T>`](/docs/react/reference/components/t) sont alignées grâce à l&#39;attribut `data-_gt-hash` émis lorsque [`_tagIds`](/docs/react/reference/config#tag-ids) est activé. Les entrées non traduites, les entrées de branche ou de pluriel dépourvues d&#39;une forme unique, ainsi que les structures dont le nombre de feuilles diffère, restent dans le paramètre régional source.

Le repli sur le cookie ne s&#39;applique que si `localeCookieName` est défini. Le paquet ne présume d&#39;aucun nom de cookie propre à un framework. Lorsque `sourceLocale` et `localeCookieName` sont tous deux omis, il utilise `locales[0]`.

`hashMessage` est un point d&#39;intégration avancé destiné à un appelant qui dispose déjà d&#39;une fonction de hachage de messages publique compatible. `gt-rrweb` n&#39;exporte pas cette fonction de hachage : une configuration ordinaire du recorder doit donc s&#39;appuyer sur les hachages [`<T>`](/docs/react/reference/components/t).

## `harvestHash` [#harvest-hash]

```ts
function harvestHash(
  events: eventWithTime[],
  locales: string[],
  options: {
    source: string;
    loadTranslations: TranslationsLoader;
    hashMessage?: (message: string) => string | undefined;
  }
): Promise<LocaleTextOverlay>;
```

`harvestHash` est la stratégie de hachage de plus bas niveau utilisée par `harvestLocales`. Elle nécessite un paramètre régional source explicite ainsi qu&#39;un loader de catalogue.

## `flattenEntry` [#flatten-entry]

```ts
function flattenEntry(
  entry: GtJsxChildren | null | undefined
): GtLeaf[] | null;
```

`flattenEntry(entry)` renvoie le texte traduit et les feuilles de variables dans l&#39;ordre du document. Les variables et les composants sans enfant qui affichent une valeur deviennent des espaces réservés conservant la valeur enregistrée ; les entrées de type pluriel et branche renvoient `null`, car elles n&#39;identifient pas une forme affichée unique.

## `collectRecordedText` [#recorded-text]

```ts
function collectRecordedText(events: eventWithTime[]): Map<number, string>;
```

`collectRecordedText(events)` renvoie le dernier texte non vide (hors espaces) pour chaque ID de nœud rrweb, à partir des instantanés complets et des mutations. Les textes composés uniquement d&#39;espaces sont ignorés, et une mutation ultérieure contenant du texte non vide remplace le texte précédent associé au même ID.

## `recordingHasHashes` [#recording-hashes]

```ts
function recordingHasHashes(events: eventWithTime[]): boolean;
```

`recordingHasHashes(events)` indique si l&#39;enregistrement contient des hachages de messages GT.

## `collectHashNodes` [#hash-nodes]

```ts
function collectHashNodes(events: eventWithTime[]): Array<{
  hash: string;
  textNodes: Array<{ id: number; text: string }>;
}>;
```

`collectHashNodes(events)` renvoie chaque translation hachage enregistré de plus haut niveau, accompagné des identifiants de ses nœuds de texte descendants et du source text, dans l&#39;ordre du document. Un hachage imbriqué dans un autre nœud haché n&#39;est pas renvoyé séparément.

## `overlayFromDict` [#overlay-dict]

```ts
function overlayFromDict(
  hashNodes: ReturnType<typeof collectHashNodes>,
  dict: TranslationDict
): Record<number, string>;
```

`overlayFromDict(hashNodes, dict)` associe chaque nœud de hachage à un `TranslationDict`. Il ignore les traductions absentes, les pluriels et les branches, ainsi que les incohérences structurelles, plutôt que d&#39;attribuer du texte au mauvais nœud.

## `stringOverlay` [#string-overlay]

```ts
function stringOverlay(
  recorded: Map<number, string>,
  covered: Set<number>,
  dict: TranslationDict,
  hashMessage: (message: string) => string | undefined
): Record<number, string>;
```

`stringOverlay(recorded, covered, dict, hashMessage)` traite le texte brut qui n&#39;est pas déjà couvert par un nœud [`<T>`](/docs/react/reference/components/t) haché. Il applique uniquement les entrées du catalogue dont la valeur est une chaîne de caractères et laisse dans le paramètre régional source les chaînes affichées vides, inchangées, absentes ou interpolées.

## Types [#types]

| Type                 | Définition                                                                                                                                   |
| -------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| `HarvestOptions`     | Loader de catalogue, fonction de hachage des messages, paramètre régional source et nom de cookie facultatifs acceptés par `harvestLocales`. |
| `LocaleTextOverlay`  | `Record<string, Record<number, string>>`                                                                                                     |
| `TranslationsLoader` | `(locale: string) => Promise<unknown>`                                                                                                       |
| `TranslationDict`    | `Record<string, GtJsxChildren \| null>`                                                                                                      |
| `GtJsxChildren`      | Un élément enfant GTJSON ou un tableau d&#39;éléments enfants.                                                                               |
| `GtJsxChild`         | `string \| GtElement \| GtVariable`                                                                                                          |
| `GtLeaf`             | `{ text: string } \| { variable: true }`                                                                                                     |

Les types utilitaires GTJSON décrivent la représentation compacte du catalogue utilisée par les fonctions d&#39;overlay. Ils s&#39;avèrent utiles pour implémenter des outils de collecte personnalisés ; une configuration classique du recorder n&#39;en a pas besoin.

## Sitemap

See the full [sitemap](https://generaltranslation.com/sitemap.md) for all pages.
