# General Translation Integrations: API harvest
URL: https://generaltranslation.com/it/docs/integrations/rrweb/reference/harvest.mdx
Docs index: https://generaltranslation.com/llms.txt
Description: Mappa i nodi di testo registrati sui cataloghi di impostazioni regionali pubblicati. Riferimento API per la raccolta di gt-rrweb.

Importa i valori di raccolta da `gt-rrweb/harvest`. La maggior parte delle applicazioni configura la raccolta tramite [`GTRecorder`](/docs/integrations/rrweb/reference/recorder#gt-recorder); l&#39;API diretta supporta pipeline di registrazione personalizzate.

## Panoramica [#overview]

| API                                         | Descrizione                                                                                                                                   |
| ------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------- |
| [`harvestLocales`](#harvest-locales)        | Costruisce gli overlay per le impostazioni regionali di destinazione richieste, escludendo l&#39;impostazione regionale sorgente selezionata. |
| [`harvestHash`](#harvest-hash)              | Costruisce gli overlay con un&#39;impostazione regionale sorgente e un loader espliciti.                                                      |
| [`flattenEntry`](#flatten-entry)            | Appiattisce il GTJSON tradotto in nodi foglia renderizzati.                                                                                        |
| [`collectRecordedText`](#recorded-text)     | Raccoglie i nodi di testo registrati in base all&#39;id del nodo rrweb.                                                                       |
| [`recordingHasHashes`](#recording-hashes)   | Verifica se lo stream contiene hash di traduzione.                                                                                              |
| [`collectHashNodes`](#hash-nodes)           | Raccoglie i nodi di traduzione con hash e il testo discendente.                                                                               |
| [`overlayFromDict`](#overlay-dict)          | Allinea i nodi con hash a un singolo catalogo di traduzione.                                                                                  |
| [`stringOverlay`](#string-overlay)          | Individua le stringhe sorgente non wrappate tramite l&#39;hash del messaggio.                                                                 |
| [`HarvestOptions` e tipi correlati](#types) | Descrivono loader, overlay, cataloghi e valori GTJSON.                                                                                        |

## `harvestLocales` [#harvest-locales]

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

`locales[0]` è la impostazione regionale sorgente di fallback. La funzione salta la impostazione regionale sorgente selezionata e carica ogni catalogo di destinazione rimanente tramite `options.loadTranslations`; senza un loader restituisce un overlay vuoto. Durante l&#39;harvesting di un bundle del registratore, la sorgente esplicita o derivata dal cookie deve coincidere con `locales[0]`, perché il registratore incorpora quella prima entry come sorgente di Replay.

| Option             | Description                                                                          | Type                                       | Optional | Default                                                              |
| ------------------ | ------------------------------------------------------------------------------------ | ------------------------------------------ | -------- | -------------------------------------------------------------------- |
| `loadTranslations` | Carica un catalogo pubblicato hash-contenuto in base all&#39;impostazione regionale. | `(locale: string) => Promise<unknown>`     | Sì       | —                                                                    |
| `hashMessage`      | Mappa le stringhe sorgente semplici sugli hash già usati dal catalogo.                   | `(message: string) => string \| undefined` | Sì       | —                                                                    |
| `sourceLocale`     | Identifica l&#39;impostazione regionale visibile nella recording.                    | `string`                                   | Sì       | Cookie dell&#39;impostazione regionale configurato, poi `locales[0]` |
| `localeCookieName` | Indica il nome del cookie usato per rilevare la impostazione regionale sorgente.                       | `string`                                   | Sì       | —                                                                    |

Le entries [`<T>`](/docs/react/reference/components/t) vengono allineate tramite l&#39;attribute `data-_gt-hash` emesso quando [`_tagIds`](/docs/react/reference/config#tag-ids) è abilitato. Le entries non tradotte, quelle di branch o Plural prive di una forma singola e le strutture con un numero diverso di nodi foglia restano nella impostazione regionale sorgente.

Il fallback tramite cookie si applica solo quando `localeCookieName` è impostato. Il package non presuppone un nome di cookie framework-specific. Quando sia `sourceLocale` sia `localeCookieName` vengono omessi, viene usato `locales[0]`.

`hashMessage` è un punto di integration avanzato per un chiamante che dispone già di un hasher pubblico di messaggi compatibile. `gt-rrweb` non esporta tale hasher, quindi una configurazione ordinaria del registratore dovrebbe basarsi sugli hash di [`<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` è la strategia di hash di più basso livello utilizzata da `harvestLocales`. Richiede un&#39;impostazione regionale sorgente esplicita e un loader del catalogo.

## `flattenEntry` [#flatten-entry]

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

`flattenEntry(entry)` restituisce il testo tradotto e i nodi foglia di tipo variabile nell&#39;ordine del documento. Le variabili e i componenti senza figli che renderizzano un valore diventano placeholder che conservano il valore registrato; le entry di tipo plural e branch restituiscono `null` perché non identificano un&#39;unica forma renderizzata.

## `collectRecordedText` [#recorded-text]

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

`collectRecordedText(events)` restituisce l&#39;ultimo testo non composto da soli spazi per ogni ID di nodo rrweb, ricavato da snapshot completi e mutazioni. Il testo formato unicamente da spazi viene ignorato e una mutazione successiva con testo non vuoto sostituisce quello precedente associato allo stesso ID.

## `recordingHasHashes` [#recording-hashes]

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

`recordingHasHashes(events)` indica se la recording include gli hash dei messaggi GT.

## `collectHashNodes` [#hash-nodes]

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

`collectHashNodes(events)` restituisce ogni translation hash registrato più esterno, con gli ID dei nodi di testo discendenti e il source text nell&#39;ordine del documento. Un hash annidato in un altro nodo con hash non viene restituito separatamente.

## `overlayFromDict` [#overlay-dict]

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

`overlayFromDict(hashNodes, dict)` associa ogni nodo hash a un `TranslationDict`. Ignora le traduzioni mancanti, i plurals, i branches e le discrepanze strutturali, anziché assegnare il testo al nodo sbagliato.

## `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)` gestisce il testo grezzo non già coperto da un nodo [`<T>`](/docs/react/reference/components/t) con hash. Applica solo le voci del catalogo con valore di tipo stringa e lascia nell&#39;impostazione regionale sorgente le stringhe renderizzate vuote, invariate, assenti o interpolate.

## Tipi [#types]

| Type                 | Definizione                                                                                                                    |
| -------------------- | ------------------------------------------------------------------------------------------------------------------------------ |
| `HarvestOptions`     | Loader del catalogo, funzione di hash dei messaggi, source locale e nome del cookie facoltativi accettati da `harvestLocales`. |
| `LocaleTextOverlay`  | `Record<string, Record<number, string>>`                                                                                       |
| `TranslationsLoader` | `(locale: string) => Promise<unknown>`                                                                                         |
| `TranslationDict`    | `Record<string, GtJsxChildren \| null>`                                                                                        |
| `GtJsxChildren`      | Un elemento figlio GTJSON o un array di elementi figli.                                                                        |
| `GtJsxChild`         | `string \| GtElement \| GtVariable`                                                                                            |
| `GtLeaf`             | `{ text: string } \| { variable: true }`                                                                                       |

I tipi helper di GTJSON descrivono la rappresentazione compatta del catalogo utilizzata dalle funzioni di overlay. Sono utili per implementare strumenti di raccolta personalizzati, mentre non servono per la normale configurazione del registratore.

## Sitemap

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