# General Translation Integrations: Risoluzione delle importazioni
URL: https://generaltranslation.com/it/docs/integrations/paraglide/guides/resolving-imports.mdx
Docs index: https://generaltranslation.com/llms.txt
Description: Come fare in modo che l'analisi segua gli alias di importazione della tua app fino ai file di Paraglide JS.

Un'importazione viene considerata di Paraglide JS solo se si risolve in un file di Paraglide JS. Un alias sconosciuto all'analisi, come `~/paraglide/messages.js`, nasconde tutti gli utilizzi che passano attraverso di esso. Consulta questa guida quando un'esecuzione segnala importazioni non risolte o rileva meno utilizzi del previsto.

## Verificare da dove provengono gli alias [#alias-sources]

Le importazioni vengono risolte come farebbe il tuo bundler, ma senza eseguirlo. Gli alias provengono dalle seguenti fonti, in quest'ordine:

1. L'opzione [`alias`](/docs/integrations/paraglide/reference/collect-context#alias).
2. Il primo file `vite.config.*`, `webpack.config.*` o `rspack.config.*` trovato nella directory radice o nella radice del progetto.
3. `paths` in `tsconfig.json` e `imports` in `package.json`.

Le config dei bundler vengono lette in modo diverso:

* **Vite:** la config viene risolta dall'installazione di Vite del tuo progetto, quindi funzionano sia gli alias aggiunti dai plugin (come `$lib` di SvelteKit) sia i percorsi relativi alla radice (`/src/a.js`).
* **webpack e rspack:** il file di config viene importato. Funzionano gli alias a corrispondenza esatta (`name$`) e con caratteri jolly (`"@/*"`). Una config in TypeScript richiede una versione di Node.js in grado di eseguire TypeScript.

Le config di Next.js, Nuxt e Astro non vengono lette: i relativi alias vengono ricavati da `tsconfig.json`.

## Dichiarare un alias [#declare-alias]

Aggiungi un alias non dichiarato in alcuna config, oppure sovrascrivine uno esistente. I tuoi alias vengono valutati prima di quelli della config.

<Tabs items={['CLI', 'Libreria']}>
  <Tab value="CLI">
    ```bash
    # Una sostituzione relativa si risolve a partire dalla radice del progetto
    npx paraglide-context --alias ~=./src --alias @ui=./packages/ui/src
    ```
  </Tab>

  <Tab value="Libreria">
    ```ts
    import path from 'node:path';
    import { collectContext } from '@generaltranslation/paraglide-js/compiler';

    await collectContext({
      // Le sostituzioni sono percorsi assoluti
      alias: { '~': path.resolve('src') },
    });
    ```
  </Tab>
</Tabs>

## Correggere le importazioni non risolte [#unresolved]

Quando non è possibile leggere alcuna config del bundler, l&#39;esecuzione termina con un avviso che elenca le importazioni non risolte, perché potrebbero essere alias non dichiarati. Per ciascuna di esse:

1. Dichiarala con `--alias`, oppure aggiungila a `paths` in `tsconfig.json`.
2. Esegui di nuovo `paraglide-context --verbose`. Il riepilogo indica la config da cui sono stati letti gli alias.

Se la config del bundler esiste ma genera errori quando viene caricata al di fuori di una build, ignorala con `--no-bundler-config` e dichiara gli alias manualmente.

## Leggere la config di un altro bundler [#bundler-config]

Aggiungi un [`BundlerConfig`](/docs/integrations/paraglide/reference/extension-api#bundler-configs) per leggere gli alias da una config non gestita dalle impostazioni predefinite. [`webpackLikeConfig`](/docs/integrations/paraglide/reference/extension-api#bundler-configs) ne crea uno per un file nel formato di webpack:

```ts
import {
  collectContext,
  defaultBundlerConfigs,
  webpackLikeConfig,
} from '@generaltranslation/paraglide-js/compiler';

await collectContext({
  bundlerConfigs: [
    ...defaultBundlerConfigs,
    // Legge resolve.alias da webpack.prod.js, .mjs, .ts, …
    webpackLikeConfig('webpack (production)', 'webpack.prod'),
  ],
});
```

Per qualsiasi altro formato, scrivi tu la funzione `read`:

```ts
import { readFile } from 'node:fs/promises';
import {
  collectContext,
  defaultBundlerConfigs,
  type BundlerConfig,
} from '@generaltranslation/paraglide-js/compiler';

const aliasFile: BundlerConfig = {
  name: 'aliases.json',
  files: ['aliases.json'], // cercati nella radice e nella radice del progetto
  async read(file) {
    // { "~": "/app/src" }
    const entries = Object.entries(JSON.parse(await readFile(file, 'utf8')));

    return {
      aliases: entries.map(([find, replacement]) => ({
        find,
        replacement: String(replacement),
      })),
    };
  },
};

await collectContext({ bundlerConfigs: [...defaultBundlerConfigs, aliasFile] });
```

Viene letta solo la prima config trovata. Se un `read` non va a buon fine, viene segnalato con un avviso e la config viene ignorata.

## Usare un altro resolver [#custom-resolver]

Per sostituire del tutto la risoluzione delle importazioni, crea tu il collector e passagli un [`Resolver`](/docs/integrations/paraglide/reference/extension-api#resolvers): una funzione che restituisce il file a cui si risolve un'importazione, oppure niente.

```ts
import {
  createCollector,
  nodeResolver,
} from '@generaltranslation/paraglide-js/compiler';

const fallback = nodeResolver();

const collector = createCollector(
  { include: ['src'] },
  {
    root: process.cwd(),
    logger: console,
    resolver: async (specifier, importer) =>
      specifier === 'virtual:messages'
        ? '/app/src/paraglide/messages.js'
        : fallback(specifier, importer),
  }
);

await collector.scanAll(); // analizza
await collector.write(); // scrive i file di metadati
```

## Cosa usare e quando [#what-to-use]

* **`--alias` o `alias`:** pochi alias non dichiarati in nessuna config.
* **`paths` in `tsconfig.json`:** alias che devono essere noti anche al tuo editor e al type checker.
* **Un `BundlerConfig`:** alias già definiti nel file di configurazione di un altro bundler.
* **Un `Resolver`:** risoluzioni che gli alias non sono in grado di esprimere, come i moduli virtuali.

## Next steps

- /docs/integrations/paraglide/guides/adding-file-formats

## Sitemap

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