@intlayer/docs 8.12.5-canary.0 → 9.0.0-canary.10

package/docs/es/packages/svelte-intlayer/exports.md

@@ -14,6 +14,9 @@ slugs:
   - svelte-intlayer
   - exports
 history:
+  - version: 10.0.0
+    date: 2026-06-23
+    changes: "Añadir utilidad usePathname"
   - version: 8.0.0
     date: 2026-01-21
     changes: "Documentación unificada para todas las exportaciones"
@@ -71,6 +74,7 @@ import "svelte-intlayer";
 | `useDictionaryAsync`   | Igual que `useDictionary`, pero maneja diccionarios asíncronos.                                                                                  | -                                                                                                                        |
 | `useDictionaryDynamic` | Igual que `useDictionary`, pero maneja diccionarios dinámicos.                                                                                   | -                                                                                                                        |
 | `useLocale`            | Devuelve la locale actual y una función para establecerla.                                                                                       | -                                                                                                                        |
+| `usePathname`          | Devuelve el pathname actual como un store `Readable<string>` con el segmento de la locale eliminado. Reactivo a `popstate`.                      | [usePathname](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/packages/svelte-intlayer/usePathname.md)     |
 | `useRewriteURL`        | Función del lado del cliente para gestionar reescrituras de URL. Actualiza automáticamente la URL si existe una regla de reescritura localizada. | [useRewriteURL](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/packages/svelte-intlayer/useRewriteURL.md) |
 | `useIntl`              | Devuelve el objeto Intl para la locale actual.                                                                                                   | -                                                                                                                        |
 

package/docs/es/packages/svelte-intlayer/usePathname.md

@@ -0,0 +1,103 @@
+---
+createdAt: 2026-06-22
+updatedAt: 2026-06-22
+title: Documentación de la función usePathname | svelte-intlayer
+description: Ve cómo usar la función usePathname del paquete svelte-intlayer
+keywords:
+  - usePathname
+  - pathname
+  - locale
+  - Intlayer
+  - Internacionalización
+  - Documentación
+  - Svelte
+  - JavaScript
+slugs:
+  - doc
+  - packages
+  - svelte-intlayer
+  - usePathname
+history:
+  - version: 10.0.0
+    date: 2026-06-23
+    changes: "Añadir utilidad usePathname"
+  - version: 8.2.0
+    date: 2026-06-22
+    changes: "Inicializar historial"
+author: aymericzip
+---
+
+# Integración con Svelte: Documentación de `usePathname`
+
+La función `usePathname` devuelve el pathname actual del navegador sin el segmento de la locale, como un store `Readable<string>` de Svelte. Es útil para construir navegación con reconocimiento de la locale — por ejemplo, para determinar qué elemento de navegación está activo — sin tener que eliminar manualmente el prefijo de la locale.
+
+## Importar `usePathname` en Svelte
+
+```typescript
+import { usePathname } from "svelte-intlayer";
+```
+
+## Descripción general
+
+`usePathname` crea un store legible de Svelte que lee `window.location.pathname`, elimina el prefijo de la locale a través de `getPathWithoutLocale`, y emite un nuevo valor cada vez que el navegador dispara un evento `popstate` (navegación atrás/adelante). Suscríbete con la sintaxis de store `$` en los componentes.
+
+## Uso
+
+```svelte fileName="src/components/NavItem.svelte"
+<script lang="ts">
+  import { usePathname } from "svelte-intlayer";
+
+  export let href: string;
+  export let label: string;
+
+  const pathname = usePathname();
+</script>
+
+<a {href} aria-current={$pathname === href ? "page" : undefined}>
+  {label}
+</a>
+```
+
+## Valor de retorno
+
+| Tipo               | Descripción                                                                          |
+| ------------------ | ------------------------------------------------------------------------------------ |
+| `Readable<string>` | Store legible de Svelte que contiene el pathname actual sin el prefijo de la locale. |
+
+## Comportamiento
+
+- **Eliminación de la locale**: Elimina el segmento inicial de la locale (ej. `/es/dashboard` → `/dashboard`).
+- **Reactividad**: Emite un nuevo valor en cada evento `popstate` (navegación atrás / adelante del navegador).
+- **Seguro para SSR**: Devuelve `""` cuando `window` no está disponible.
+- **Limpieza**: El escuchador `popstate` se elimina automáticamente cuando se da de baja el último suscriptor.
+
+## Ejemplo
+
+```svelte fileName="src/components/Sidebar.svelte"
+<script lang="ts">
+  import { usePathname } from "svelte-intlayer";
+
+  const links = [
+    { href: "/dashboard", label: "Panel de control" },
+    { href: "/settings", label: "Configuración" },
+  ];
+
+  const pathname = usePathname();
+</script>
+
+<nav>
+  {#each links as link}
+    <a
+      href={link.href}
+      style:font-weight={$pathname === link.href ? "bold" : "normal"}
+    >
+      {link.label}
+    </a>
+  {/each}
+</nav>
+```
+
+## Relacionado
+
+- [`useLocale`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/packages/svelte-intlayer/useLocale.md) — locale actual + selector de locale
+- [`getPathWithoutLocale`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/packages/intlayer/getPathWithoutLocale.md) — la utilidad subyacente utilizada por este hook

package/docs/es/packages/vite-intlayer/intlayerCompiler.md

@@ -0,0 +1,120 @@
+---
+createdAt: 2026-06-25
+updatedAt: 2026-06-25
+title: Documentación del plugin Vite intlayerCompiler | vite-intlayer
+description: Plugin de Vite que extrae declaraciones de contenido de Intlayer en línea de los archivos de componentes y las escribe en archivos JSON de diccionario en el momento de la compilación/transformación.
+keywords:
+  - intlayerCompiler
+  - vite
+  - plugin
+  - compilador
+  - contenido
+  - diccionario
+  - internacionalización
+  - i18n
+slugs:
+  - doc
+  - packages
+  - vite-intlayer
+  - intlayerCompiler
+history:
+  - version: 9.0.0
+    date: 2026-06-25
+    changes: "Integrado en intlayer(); inicialización de doc"
+author: aymericzip
+---
+
+# intlayerCompiler
+
+`intlayerCompiler` es un plugin de Vite que escanea los archivos de código fuente de los componentes en busca de **declaraciones de contenido inline de Intlayer** — contenido definido directamente dentro de un componente en lugar de en un archivo `.content.ts` separado — y las escribe en archivos JSON de diccionario durante la fase de transformación.
+
+> **Desde Intlayer v9**, `intlayerCompiler` se incluye automáticamente dentro del plugin principal [`intlayer()`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/packages/vite-intlayer/intlayer.md) cuando tanto `compiler.enabled` es `true` como `compiler.output` están configurados en su configuración de Intlayer. Solo necesita registrarlo por separado cuando desee tener un control total sobre la configuración específica del compilador.
+
+## Uso
+
+### Como parte de `intlayer()` (recomendado, v9+)
+
+Habilite el compilador a través de su configuración de Intlayer:
+
+```ts
+// intlayer.config.ts
+import { defineConfig } from "intlayer";
+
+export default defineConfig({
+  compiler: {
+    enabled: true,
+    output: "./src/dictionaries", // donde se escriben los diccionarios extraídos
+  },
+});
+```
+
+Luego use el plugin estándar sin registro adicional:
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayer } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [intlayer()],
+});
+```
+
+### Autónomo (cuando sea necesario)
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayerCompiler } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [intlayerCompiler()],
+});
+```
+
+## Opciones
+
+```ts
+import type { IntlayerCompilerOptions } from "vite-intlayer";
+```
+
+| Opción           | Tipo                      | Descripción                                                                                                             |
+| ---------------- | ------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
+| `configOptions`  | `GetConfigurationOptions` | Anulaciones de configuración de Intlayer reenviadas a `getConfiguration()`.                                             |
+| `compilerConfig` | `Partial<CompilerConfig>` | Anulaciones para la sección de configuración específica del compilador (por ejemplo, `enabled`, `output`, `filesList`). |
+
+### Ejemplo
+
+```ts
+intlayerCompiler({
+  configOptions: { configFile: "./config/intlayer.config.ts" },
+  compilerConfig: { enabled: true, output: "./src/dictionaries" },
+});
+```
+
+## Cómo funciona
+
+### Fase de transformación
+
+Para cada archivo fuente que coincida con `compiler.filesList`, el plugin del compilador:
+
+1. Pasa el contenido del archivo a través de `extractContent` de `@intlayer/babel`.
+2. Llama a `onExtract` para cada declaración encontrada, lo que escribe el JSON del diccionario resultante en `compiler.output`.
+3. Devuelve el código fuente transformado con las declaraciones en línea reemplazadas por llamadas estándar `useIntlayer('key')` / `getIntlayer('key')`.
+
+Tipos de archivos admitidos: `.ts`, `.tsx`, `.js`, `.jsx`, `.vue`, `.svelte`, `.astro`.
+
+### HMR (Hot Module Replacement)
+
+Cuando se guarda un archivo de componente en modo de desarrollo, el compilador:
+
+1. Detecta el cambio de archivo a través del hook `handleHotUpdate` de Vite.
+2. Vuelve a extraer el contenido del archivo actualizado.
+3. Escribe el JSON del diccionario actualizado.
+4. Activa una recarga completa de la página (`server.ws.send({ type: 'full-reload' })`).
+
+Un retraso (debounce) de 500 ms evita que la propia escritura del diccionario (que también activa un evento de cambio de archivo) cause un bucle de re-extracción infinito.
+
+### Deduplicación
+
+`intlayerCompiler` utiliza el mismo mecanismo de deduplicación `createPrimaryInstanceGuard` que los otros plugins incluidos. Cuando están presentes tanto `intlayer()` (que incluye el compilador) como una llamada manual a `intlayerCompiler()`, solo se ejecuta la primera instancia registrada; no se escribe ningún diccionario dos veces.

package/docs/es/packages/vite-intlayer/intlayerMinify.md

@@ -0,0 +1,92 @@
+---
+createdAt: 2026-06-25
+updatedAt: 2026-06-25
+title: Documentación del plugin Vite intlayerMinify | vite-intlayer
+description: Plugin de Vite que minifica los archivos JSON de diccionarios Intlayer compilados y, opcionalmente, ofusca los nombres de los campos de contenido para reducir el tamaño del bundle.
+keywords:
+  - intlayerMinify
+  - vite
+  - plugin
+  - minificar
+  - tamaño del bundle
+  - diccionario
+  - internacionalización
+  - i18n
+slugs:
+  - doc
+  - packages
+  - vite-intlayer
+  - intlayerMinify
+history:
+  - version: 9.0.0
+    date: 2026-06-25
+    changes: "Inicialización de doc"
+author: aymericzip
+---
+
+# intlayerMinify
+
+`intlayerMinify` es un plugin de Vite que minifica archivos JSON de diccionarios compilados durante una compilación de producción. Elimina todos los espacios en blanco innecesarios y, cuando se combina con `intlayerPrune`, opcionalmente renombra los nombres de los campos de contenido a alias alfabéticos cortos (`a`, `b`, `c`, ...) para reducir aún más el tamaño del bundle.
+
+> El plugin ya está incluido y configurado automáticamente cuando utiliza [`intlayer()`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/packages/vite-intlayer/intlayer.md). Solo necesita registrarlo manualmente si está componiendo la pila de plugins usted mismo.
+
+## Uso
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayerMinify, intlayerPrune } from "vite-intlayer";
+import { createPruneContext } from "@intlayer/babel";
+
+const pruneContext = createPruneContext();
+
+export default defineConfig({
+  plugins: [
+    intlayerPrune(intlayerConfig, pruneContext),
+    intlayerMinify(intlayerConfig, pruneContext),
+  ],
+});
+```
+
+## Condiciones de activación
+
+`intlayerMinify` está activo **solo** cuando se cumplen las tres condiciones siguientes:
+
+1. El comando de Vite es `build` (no `serve` / dev).
+2. `build.optimize` es `true` (o `undefined`, que por defecto es `true` para compilaciones).
+3. `build.minify` es `true` en su configuración de Intlayer.
+
+Se **desactiva** automáticamente cuando `editor.enabled` es `true` porque el editor necesita el contenido del diccionario completo y legible por humanos.
+
+## Qué se minifica
+
+El plugin apunta a dos ubicaciones de diccionarios (según lo resuelto a partir de `intlayer.system`):
+
+- `dictionariesDir` — diccionarios estáticos para todos los idiomas (por ejemplo, `.intlayer/dictionaries/*.json`)
+- `dynamicDictionariesDir` — diccionarios dinámicos por idioma
+
+> Los diccionarios en modo fetch (`fetchDictionariesDir`) **nunca** se minifican porque se sirven desde una API remota en tiempo de ejecución utilizando sus nombres de campo originales. Cambiar el nombre de los campos crearía una discrepancia entre la respuesta del servidor y los accesos a propiedades en el lado del cliente.
+
+## Ofuscación de nombres de campo (minificación de propiedades)
+
+Cuando `intlayerPrune` ha analizado el código fuente y ha llenado `pruneContext.dictionaryKeyToFieldRenameMap`, `intlayerMinify` también cambia el nombre de los campos de contenido a alias cortos. Por ejemplo:
+
+```json
+// antes
+{ "key": "myDict", "content": { "title": "Hello", "description": "World" } }
+
+// después (con ofuscación)
+{ "key": "myDict", "content": { "a": "Hello", "b": "World" } }
+```
+
+Los accesos a propiedades de archivos fuente correspondientes se renombran mediante el paso de Babel dentro de `intlayerOptimize`, por lo que el comportamiento en tiempo de ejecución no cambia.
+
+Los campos internos de Intlayer (`nodeType`, `translation`, etc.) nunca se renombran.
+
+## Dicionarios de casos extremos (Edge cases)
+
+Los diccionarios marcados en `pruneContext.dictionariesWithEdgeCases` (anomalías estructurales detectadas durante la fase de prune) se omiten por completo — ni se minifican ni se ofuscan — para evitar el envío de datos dañados.
+
+## Grupos calificados (colecciones / variantes / registros meta)
+
+Para diccionarios con una matriz `qualifierTypes` (colecciones, variantes y registros meta), el plugin conserva la matriz `qualifierTypes` y el mapa lateral `meta` literalmente. Solo las entradas de `content` tienen sus nombres de campo ofuscados. Las claves compuestas (utilizadas para la coincidencia de selectores en tiempo de ejecución) nunca se tocan.

package/docs/es/packages/vite-intlayer/intlayerProxy.md

@@ -0,0 +1,172 @@
+---
+createdAt: 2026-06-25
+updatedAt: 2026-06-25
+title: Documentación del plugin Vite intlayerProxy | vite-intlayer
+description: Middleware de enrutamiento de idiomas para los servidores dev/preview de Vite y SSR de producción. Maneja la detección de idioma, redireccionamientos de URL y reescrituras internas.
+keywords:
+  - intlayerProxy
+  - vite
+  - plugin
+  - middleware
+  - idioma
+  - enrutamiento
+  - internacionalización
+  - i18n
+  - SSR
+slugs:
+  - doc
+  - packages
+  - vite-intlayer
+  - intlayerProxy
+history:
+  - version: 9.0.0
+    date: 2026-06-25
+    changes: "Se fusionó configOptions en un solo objeto de opciones; proxy integrado en intlayer()"
+author: aymericzip
+---
+
+# intlayerProxy
+
+`intlayerProxy` es un plugin de Vite que registra un middleware de enrutamiento de idiomas para **todos los entornos**: servidor de desarrollo, servidor de vista previa y SSR de producción (Nitro / TanStack Start).
+
+> **Desde Intlayer v9**, `intlayerProxy` se incluye automáticamente dentro del plugin principal [`intlayer()`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/packages/vite-intlayer/intlayer.md) y está habilitado por defecto mediante `routing.enableProxy: true`. Solo necesita registrarlo por separado si requiere un control de nivel inferior o si lo está utilizando fuera de la configuración estándar de `intlayer()`.
+
+## Uso
+
+### Como parte de `intlayer()` (recomendado, v9+)
+
+Pase las opciones de `proxy` al plugin principal en lugar de registrar `intlayerProxy` por separado:
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayer } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
+  ],
+});
+```
+
+### Autónomo (cuando sea necesario)
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayer } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [intlayer()],
+});
+```
+
+## Opciones
+
+```ts
+import type { IntlayerProxyPluginOptions } from "vite-intlayer";
+```
+
+Todas las opciones son opcionales y se pasan como un único objeto:
+
+| Opción          | Tipo                                | Descripción                                                                                                                                                                |
+| --------------- | ----------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `ignore`        | `(req: IncomingMessage) => boolean` | Predicado que excluye solicitudes del enrutamiento de idiomas. Devuelva `true` para omitir una solicitud (por ejemplo, rutas de API, controles de salud).                  |
+| `configOptions` | `GetConfigurationOptions`           | Anulaciones de configuración de Intlayer reenviadas a `getConfiguration()`. Úselo cuando necesite que el proxy lea un archivo de configuración específico o anule valores. |
+
+### Ejemplo
+
+```ts
+intlayerProxy({
+  ignore: (req) => req.url?.startsWith("/api"),
+  configOptions: { configFile: "./config/intlayer.config.ts" },
+});
+```
+
+## createIntlayerProxyHandler
+
+`createIntlayerProxyHandler` crea un middleware Node.js `(req, res, next)` independiente del framework que contiene toda la lógica de enrutamiento de idiomas. Es útil en entornos donde la API del plugin de Vite no está disponible (por ejemplo, un servidor Node.js simple o un módulo Nitro personalizado).
+
+```ts
+import { createIntlayerProxyHandler } from "vite-intlayer";
+
+const handler = createIntlayerProxyHandler({
+  ignore: (req) => req.url?.startsWith("/api"),
+  configOptions: { configFile: "./config/intlayer.config.ts" },
+});
+
+// Express / Connect
+app.use(handler);
+```
+
+### SSR de producción (TanStack Start / Nitro a través de h3)
+
+```ts
+// server/middleware/intlayerProxy.ts
+import { fromNodeMiddleware } from "h3";
+import { createIntlayerProxyHandler } from "vite-intlayer";
+
+export default fromNodeMiddleware(
+  createIntlayerProxyHandler({
+    ignore: (req) => req.url?.startsWith("/api"),
+  })
+);
+```
+
+## Comportamiento de enrutamiento
+
+El middleware refleja la lógica de enrutamiento del middleware de `next-intlayer` y es compatible con todos los modos de enrutamiento de Intlayer.
+
+### Modos de enrutamiento
+
+| Modo            | URL visible en el navegador | Comportamiento                                                                                                                          |
+| --------------- | --------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
+| `prefix`        | `/es/about`                 | Por defecto. Prefijo de idioma en la URL. El idioma por defecto redirige a la URL sin prefijo a menos que `prefix-all` esté habilitado. |
+| `prefix-all`    | `/en/about`, `/es/about`    | Todos los idiomas — incluido el por defecto — siempre tienen prefijo.                                                                   |
+| `no-prefix`     | `/about`                    | Sin idioma en la URL. El idioma se almacena únicamente en las cookies; las reescrituras de URL ocurren internamente.                    |
+| `search-params` | `/about?locale=es`          | Idioma pasado como parámetro de consulta. Redirige para agregar/actualizar el parámetro `locale` cuando falta o está obsoleto.          |
+
+### Prioridad de detección
+
+1. Prefijo de ruta URL (por ejemplo, `/es/about` → `es`).
+2. Valor de cookie / localStorage (`intlayer-locale`).
+3. Cabecera `Accept-Language`.
+4. `defaultLocale` de la configuración.
+
+### Omisión automática
+
+El middleware siempre deja pasar estas solicitudes directamente sin manejo de idioma:
+
+- Solicitudes que coinciden con el predicado `ignore`.
+- `/node_modules/**`
+- `/@**` – Componentes internos de Vite (`@vite/`, `@fs/`, `@id/`, etc.).
+- `/_**` – Componentes internos del servidor (`__vite_ping`, `__manifest`, etc.).
+- Solicitudes cuya ruta termina con una extensión de archivo (activos estáticos). Si hay un prefijo de idioma presente en la ruta de un activo estático (por ejemplo, `/es/logo.png`), se elimina para que el archivo se pueda servir correctamente.
+
+### Enrutamiento de dominio
+
+Cuando `routing.domains` está configurado en su configuración de Intlayer, el middleware maneja el enrutamiento de idiomas entre dominios:
+
+- Una solicitud para `/zh/about` en `intlayer.org` se redirige a `https://intlayer.zh/about` cuando `domains.zh = "intlayer.zh"`.
+- Una solicitud a `intlayer.zh/about` se reescribe internamente a `/zh/about` para que se complete el parámetro de ruta `[locale]`.
+
+### Protección contra bucles de redirección
+
+El middleware realiza un seguimiento de los recuentos de redireccionamientos por par `originalUrl → newUrl` dentro de una ventana deslizante de 2 segundos. Más de 10 redireccionamientos dentro de esa ventana devuelven una respuesta `500` con un error descriptivo en lugar de entrar en un bucle infinito.
+
+## Nitro / SSR de producción (inyección automática, v9+)
+
+Cuando se usa `intlayerProxy` como plugin de Vite, lleva una propiedad `.nitro`. El plugin de compilación `nitro/vite` lee esta propiedad y la agrega a `nitroConfig.modules`, por lo que `intlayerNitroHandler` se registra como middleware del servidor Nitro automáticamente; no se necesita configuración manual para el SSR de producción.
+
+El controlador Nitro utiliza el modelo de eventos de la API Web Fetch de h3 v2 (no `fromNodeMiddleware`), por lo que es compatible con todos los preajustes de Nitro: Node, Bun, Deno, entornos de ejecución edge.
+
+## Alias obsoletos
+
+| Exportación obsoleta       | Reemplazo       |
+| -------------------------- | --------------- |
+| `intlayerMiddleware`       | `intlayerProxy` |
+| `intLayerMiddlewarePlugin` | `intlayerProxy` |

package/docs/es/packages/vue-intlayer/exports.md

@@ -14,6 +14,9 @@ slugs:
   - vue-intlayer
   - exports
 history:
+  - version: 10.0.0
+    date: 2026-06-23
+    changes: "Agregar utilidad usePathname"
   - version: 8.0.0
     date: 2026-01-21
     changes: "Documentación unificada para todas las exportaciones"
@@ -59,6 +62,7 @@ import "vue-intlayer";
 | `useDictionaryAsync`   | Igual que `useDictionary`, pero maneja diccionarios asíncronos.                                                                                     | -                                                                                                                     |
 | `useDictionaryDynamic` | Igual que `useDictionary`, pero maneja diccionarios dinámicos.                                                                                      | -                                                                                                                     |
 | `useLocale`            | Devuelve la locale actual y una función para establecerla.                                                                                          | -                                                                                                                     |
+| `usePathname`          | Devuelve el pathname actual como un `ComputedRef<string>` con el segmento de la locale eliminado. Es reactivo a eventos `popstate`.                 | [usePathname](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/packages/vue-intlayer/usePathname.md)     |
 | `useRewriteURL`        | Composable del lado del cliente para gestionar reescrituras de URL. Actualiza automáticamente la URL si existe una regla de reescritura localizada. | [useRewriteURL](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/packages/vue-intlayer/useRewriteURL.md) |
 | `useIntl`              | Devuelve el objeto Intl para la locale actual.                                                                                                      | -                                                                                                                     |
 | `useLoadDynamic`       | Composable para cargar diccionarios dinámicos.                                                                                                      | -                                                                                                                     |

package/docs/es/packages/vue-intlayer/usePathname.md

@@ -0,0 +1,109 @@
+---
+createdAt: 2026-06-22
+updatedAt: 2026-06-22
+title: Documentación de la función usePathname | vue-intlayer
+description: Aprenda cómo usar la función usePathname del paquete vue-intlayer
+keywords:
+  - usePathname
+  - pathname
+  - locale
+  - Intlayer
+  - Internacionalización
+  - Documentación
+  - Vue
+  - JavaScript
+slugs:
+  - doc
+  - packages
+  - vue-intlayer
+  - usePathname
+history:
+  - version: 10.0.0
+    date: 2026-06-23
+    changes: "Agregar utilidad usePathname"
+  - version: 8.2.0
+    date: 2026-06-22
+    changes: "Inicializar historial"
+author: aymericzip
+---
+
+# Integración con Vue: Documentación de `usePathname`
+
+La función `usePathname` devuelve la ruta actual (pathname) del navegador con el segmento de la locale eliminado, como un `ComputedRef<string>` de Vue. Es útil para construir navegación con conocimiento de la locale — por ejemplo, para determinar qué elemento de navegación está activo — sin tener que eliminar el prefijo de la locale manualmente.
+
+## Importar `usePathname` en Vue
+
+```typescript
+import { usePathname } from "vue-intlayer";
+```
+
+## Visión General
+
+`usePathname` crea una referencia calculada (computed ref) de Vue que lee `window.location.pathname`, elimina el prefijo de la locale mediante `getPathWithoutLocale` y actualiza su valor cada vez que el navegador dispara un evento `popstate` (navegación atrás/adelante). El valor se puede usar directamente en los templates de Vue o funciones setup.
+
+## Uso
+
+```vue fileName="src/components/NavItem.vue"
+<script setup lang="ts">
+import { usePathname } from "vue-intlayer";
+
+const props = defineProps<{
+  href: string;
+  label: string;
+}>();
+
+const pathname = usePathname();
+</script>
+
+<template>
+  <a :href="href" :aria-current="pathname === href ? 'page' : undefined">
+    {{ label }}
+  </a>
+</template>
+```
+
+## Valor de Retorno
+
+| Tipo                  | Descripción                                                                              |
+| --------------------- | ---------------------------------------------------------------------------------------- |
+| `ComputedRef<string>` | Referencia calculada de Vue que contiene el pathname actual sin el prefijo de la locale. |
+
+## Comportamiento
+
+- **Eliminación de Locale**: Remueve el segmento inicial de locale (ej. `/es/dashboard` → `/dashboard`).
+- **Reactivo**: Actualiza su valor en cada evento `popstate` (navegación atrás / adelante en el navegador).
+- **Seguro en SSR**: Devuelve `""` cuando `window` no está disponible.
+- **Limpieza (Cleanup)**: El event listener de `popstate` se añade de manera global al inicializar y por lo general no requiere limpieza manual por componente, gracias a cómo Vue maneja el ciclo de vida.
+
+## Ejemplo
+
+```vue fileName="src/components/Sidebar.vue"
+<script setup lang="ts">
+import { usePathname } from "vue-intlayer";
+
+const links = [
+  { href: "/dashboard", label: "Panel de control" },
+  { href: "/settings", label: "Ajustes" },
+];
+
+const pathname = usePathname();
+</script>
+
+<template>
+  <nav>
+    <a
+      v-for="link in links"
+      :key="link.href"
+      :href="link.href"
+      :style="{ fontWeight: pathname === link.href ? 'bold' : 'normal' }"
+    >
+      {{ link.label }}
+    </a>
+  </nav>
+</template>
+```
+
+## Relacionado
+
+- [`useLocale`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/packages/vue-intlayer/useLocale.md) — locale actual + selector de locale
+- [`getPathWithoutLocale`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/packages/intlayer/getPathWithoutLocale.md) — la utilidad subyacente que usa este composable