# General Translation Integrations: Aggiungere formati di file
URL: https://generaltranslation.com/it/docs/integrations/paraglide/guides/adding-file-formats.mdx
Docs index: https://generaltranslation.com/llms.txt
Description: Come analizzare file di componenti in un formato non supportato dai linguaggi integrati.

I file che non sono JavaScript, TypeScript o JSX vengono convertiti in TypeScript da un linguaggio, ovvero un piccolo adattatore che si appoggia agli strumenti nativi del framework. Aggiungi un linguaggio quando la tua app usa messaggi in un formato che non compare tra i [formati di file supportati](/docs/integrations/paraglide/reference/file-formats).

I linguaggi sono un'opzione della libreria, per questo la guida usa [`collectContext`](/docs/integrations/paraglide/reference/collect-context) anziché la CLI.

## Prima di iniziare [#before-start]

Ti serve un compilatore o un language tool per il formato che restituisca:

* Il file come codice JavaScript o TypeScript.
* Una source map, o mappature Volar, che colleghino quel codice al file originale.

Il codice privo di mappatura non viene mai considerato un utilizzo: sono quindi le mappature a determinare quali utilizzi vengono individuati e dove viene troncato il loro contesto.

## Scrivere il linguaggio [#write-language]

Un [`SourceLanguage`](/docs/integrations/paraglide/reference/extension-api#languages) dichiara le proprie estensioni di file e i pacchetti di cui ha bisogno, e restituisce il modulo generato:

```ts title="riot-language.ts"
import {
  mappingsFromSourceMap,
  type SourceLanguage,
} from '@generaltranslation/paraglide-js/compiler';

export const riotLanguage: SourceLanguage = {
  name: 'riot',
  extensions: ['.riot'],
  requires: ['@riotjs/compiler'], // citato nell'avviso se manca
  async generate(source, file, context) {
    // Caricato dall'app; undefined se non installato.
    const compiler =
      await context.load<typeof import('@riotjs/compiler')>('@riotjs/compiler');
    if (!compiler) return undefined; // ignorato

    const { code, map } = compiler.compile(source, { file });
    const mappings = mappingsFromSourceMap(map, code, source);

    return { code, lang: 'js', mappings };
  },
};
```

1. Carica lo strumento con `context.load`, così che la sua versione corrisponda a quella dell&#39;app. Se non è presente, restituisci `undefined`: il formato viene ignorato con un unico avviso che indica i pacchetti elencati in `requires`.
2. Costruisci `mappings` con `mappingsFromSourceMap` per una source map versione 3, oppure con `mappingsFromVolar` per le mappature di uno strumento basato su Volar.
3. Lancia un&#39;eccezione quando lo strumento rifiuta un file. Quel file viene ignorato con un avviso.

## Registra il linguaggio [#register-language]

Passalo insieme ai valori predefiniti:

```ts
import {
  collectContext,
  defaultLanguages,
} from '@generaltranslation/paraglide-js/compiler';
import { riotLanguage } from './riot-language.js';

await collectContext({ languages: [...defaultLanguages, riotLanguage] });
```

I file con le estensioni del linguaggio vengono ora inclusi nell&#39;analisi. Se un file corrisponde a più linguaggi, viene usato il primo dell&#39;elenco.

## Gestire gli script e le estensioni di script [#scripts]

* **Script separati:** restituisci in `scripts` gli script che costituiscono moduli a sé stanti, come gli script client di una pagina Astro, ciascuno nella forma `{ code, lang, mappings }`. Non condividono alcun nome né tra loro né con il `code` principale.
* **Estensioni di script:** per rivendicare i file con un&#39;estensione di script, come fanno i componenti Angular con `.ts`, aggiungi `detect(source, file)` e restituisci `true` solo per i file nel tuo formato.

## Next steps

- /docs/integrations/paraglide/guides/resolving-imports

## Sitemap

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