# General Translation Integrations: Resolución de importaciones
URL: https://generaltranslation.com/es/docs/integrations/paraglide/guides/resolving-imports.mdx
Docs index: https://generaltranslation.com/llms.txt
Description: Cómo hacer que el análisis siga los alias de importación de tu aplicación hasta sus archivos de Paraglide JS.

Una importación solo cuenta como Paraglide JS cuando se resuelve en un archivo de Paraglide JS. Un alias que el análisis no conoce, como `~/paraglide/messages.js`, oculta todos los usos que dependen de él. Usa esta guía cuando una ejecución muestre advertencias sobre importaciones no resueltas o detecte menos usos de los esperados.

## Comprobar de dónde provienen los alias [#alias-sources]

Las importaciones se resuelven igual que lo haría tu empaquetador, pero sin ejecutarlo. Los alias se obtienen de estas fuentes, en este orden:

1. La opción [`alias`](/docs/integrations/paraglide/reference/collect-context#alias).
2. El primer `vite.config.*`, `webpack.config.*` o `rspack.config.*` que se encuentre en el directorio raíz o en la raíz del proyecto.
3. `paths` en `tsconfig.json` e `imports` en `package.json`.

Las configuraciones de los empaquetadores se leen de forma distinta:

* **Vite:** la configuración la resuelve el propio Vite de tu proyecto, así que funcionan tanto los alias que añaden los plugins (`$lib` de SvelteKit) como las rutas raíz (`/src/a.js`).
* **webpack y rspack:** se importa el archivo de configuración. Funcionan los alias de coincidencia exacta (`name$`) y con comodines (`"@/*"`). Una configuración en TypeScript requiere una versión de Node.js capaz de ejecutar TypeScript.

Las configuraciones de Next.js, Nuxt y Astro no se leen. Sus alias se obtienen de `tsconfig.json`.

## Declarar un alias [#declare-alias]

Agrega un alias que ninguna configuración declare o reemplaza uno existente. Tus propios alias tienen prioridad sobre los de la configuración al hacer la coincidencia.

<Tabs items={['CLI', 'Library']}>
  <Tab value="CLI">
    ```bash
    # Un reemplazo relativo se resuelve desde la raíz del proyecto
    npx paraglide-context --alias ~=./src --alias @ui=./packages/ui/src
    ```
  </Tab>

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

    await collectContext({
      // Los reemplazos son rutas absolutas
      alias: { '~': path.resolve('src') },
    });
    ```
  </Tab>
</Tabs>

## Corregir importaciones no resueltas [#unresolved]

Si no se puede leer ninguna configuración del empaquetador, la ejecución termina con una advertencia que enumera las importaciones que no se pudieron resolver, ya que podrían ser alias no declarados. Para cada una:

1. Decláralo con `--alias` o agrégalo a `paths` en `tsconfig.json`.
2. Vuelve a ejecutar `paraglide-context --verbose`. El resumen indica de qué configuración se leyeron los alias.

Si existe una configuración del empaquetador, pero falla al cargarse fuera de una compilación, omítela con `--no-bundler-config` y declara los alias manualmente.

## Leer la configuración de otro empaquetador [#bundler-config]

Agrega un [`BundlerConfig`](/docs/integrations/paraglide/reference/extension-api#bundler-configs) para leer los alias de una configuración que no cubren los valores predeterminados. [`webpackLikeConfig`](/docs/integrations/paraglide/reference/extension-api#bundler-configs) crea uno para un archivo con el formato de webpack:

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

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

Para cualquier otro formato, escribe tú mismo la función `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'], // se busca en la raíz y en la raíz del proyecto
  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] });
```

Solo se lee la primera configuración que se encuentra. Si una operación `read` falla, se emite una advertencia y la configuración se omite.

## Usar otro resolvedor [#custom-resolver]

Para sustituir por completo la resolución de importaciones, crea tú mismo el recolector y pásale un [`Resolver`](/docs/integrations/paraglide/reference/extension-api#resolvers): una función que devuelve el archivo al que se resuelve una importación, o nada.

```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(); // analizar
await collector.write(); // escribir los archivos de metadatos
```

## Qué usar y cuándo [#what-to-use]

* **`--alias` o `alias`:** unos pocos alias que no declara ninguna configuración.
* **`paths` de `tsconfig.json`:** alias que también deben conocer tu editor y tu verificador de tipos.
* **Un `BundlerConfig`:** alias que ya están definidos en el archivo de configuración de otro empaquetador.
* **Un `Resolver`:** resolución que no se puede expresar con alias, como los módulos virtuales.

## Next steps

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

## Sitemap

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