@intlayer/docs 9.0.0-canary.6 → 9.0.0-canary.7

package/docs/pl/packages/@intlayer_babel/export.md

@@ -0,0 +1,131 @@
+---
+createdAt: 2026-06-25
+updatedAt: 2026-06-25
+title: "Dokumentacja pakietu @intlayer/babel"
+description: Wtyczki Babel dla Intlayer do obsługi ekstrakcji zawartości, optymalizacji importu, oczyszczania nieużywanych pól i maskowania nazw pól podczas budowania.
+keywords:
+  - "@intlayer/babel"
+  - babel
+  - plugin
+  - umiędzynarodowienie
+  - i18n
+  - kompilator
+  - optymalizuj
+  - oczyść
+  - minifikuj
+slugs:
+  - doc
+  - packages
+  - "@intlayer/babel"
+  - export
+history:
+  - version: 9.0.0
+    date: 2026-06-25
+    changes: "Ujednolicona dokumentacja wszystkich eksportów"
+author: aymericzip
+---
+
+# Pakiet @intlayer/babel
+
+Pakiet `@intlayer/babel` dostarcza zestaw wyspecjalizowanych wtyczek Babel dla Intlayer. Wtyczki te obejmują cały cykl budowania: ekstrahowanie deklaracji zawartości, przepisywanie wywołań `useIntlayer` / `getIntlayer` do zoptymalizowanych importów słowników, oczyszczanie nieużywanych pól i minifikację nazw pól.
+
+## Instalacja
+
+```bash
+npm install @intlayer/babel
+```
+
+## Eksporty
+
+Import:
+
+```ts
+import { ... } from "@intlayer/babel";
+```
+
+---
+
+### Wtyczki
+
+| Funkcja / Klasa                | Opis                                                                                                                                                                                                                      |
+| ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `intlayerExtractBabelPlugin`   | Wtyczka Babel, która ekstrahuje przetłumaczalną zawartość z plików źródłowych i automatycznie wstrzykuje hooki `useIntlayer` / `getIntlayer`. Przeznaczona do użytku z Next.js i narzędziami budowania opartymi na Babel. |
+| `intlayerOptimizeBabelPlugin`  | Wtyczka Babel, która przekształca wywołania `useIntlayer` i `getIntlayer` oraz przepisuje ich importy do zoptymalizowanych importów słowników JSON (statycznych, dynamicznych lub przez fetch).                           |
+| `intlayerPurgeBabelPlugin`     | Wtyczka Babel, która analizuje pliki źródłowe i przepisuje skompilowane pliki JSON słowników w celu usunięcia nieużywanych pól (`build.purge`) lub zmiany ich nazw na krótkie aliasy (`build.minify`).                    |
+| `intlayerMinifyBabelPlugin`    | Wtyczka Babel, która przepisuje pliki źródłowe w celu użycia krótkich aliasów pól przypisanych podczas fazy minifikacji (np. `content.title` ← `content.a`). Zależy od `intlayerPurgeBabelPlugin`.                        |
+| `makeFieldRenameBabelPlugin`   | Funkcja fabryczna (factory), która tworzy wtyczkę Babel do zmiany nazw dostępów do pól zawartości słownika w plikach źródłowych zgodnie z `dictionaryKeyToFieldRenameMap` wypełnioną w `PruneContext`.                    |
+| `makeUsageAnalyzerBabelPlugin` | Funkcja fabryczna, która tworzy wtyczkę Babel do analizowania użycia `useIntlayer` / `getIntlayer` w kodzie źródłowym i agregowania danych o użyciu pól we wspólnym `PruneContext`.                                       |
+| `getSharedPruneContext`        | Funkcja pomocnicza, która zwraca wspólny obiekt `PruneContext` dla określonego katalogu bazowego lub `null`, jeśli nie został jeszcze zainicjowany.                                                                       |
+
+---
+
+### Narzędzia konfiguracji wtyczek
+
+| Funkcja                    | Opis                                                                                                                                       |
+| -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
+| `getExtractPluginOptions`  | Ładuje konfigurację Intlayer i zwraca `ExtractPluginOptions` gotowe do użycia z `intlayerExtractBabelPlugin`.                              |
+| `getOptimizePluginOptions` | Ładuje konfigurację Intlayer i skompilowane słowniki oraz zwraca `OptimizePluginOptions` gotowe do użycia z `intlayerOptimizeBabelPlugin`. |
+| `getPurgePluginOptions`    | Ładuje konfigurację Intlayer i zwraca `PurgePluginOptions` gotowe do użycia z `intlayerPurgeBabelPlugin`.                                  |
+| `getMinifyPluginOptions`   | Ładuje konfigurację Intlayer i zwraca `MinifyPluginOptions` gotowe do użycia z `intlayerMinifyBabelPlugin`.                                |
+
+---
+
+### Typy
+
+| Typ                     | Opis                                                                                                                       |
+| ----------------------- | -------------------------------------------------------------------------------------------------------------------------- |
+| `CompilerMode`          | Tryb kompilatora: `'dev'` do programowania ze wsparciem HMR lub `'build'` dla kompilacji produkcyjnych.                    |
+| `ExtractPluginOptions`  | Opcje dla `intlayerExtractBabelPlugin`: lista plików, konfiguracja, callback `onExtract` itp.                              |
+| `ExtractResult`         | Wynik ekstrakcji: klucz słownika, ścieżka do pliku, zawartość i język.                                                     |
+| `OptimizePluginOptions` | Opcje dla `intlayerOptimizeBabelPlugin`: ścieżki słowników, tryb importu, mapa trybów dla słownika itp.                    |
+| `PurgePluginOptions`    | Opcje dla `intlayerPurgeBabelPlugin`: katalog bazowy, flagi purge/minify/optimize, lista plików komponentów.               |
+| `MinifyPluginOptions`   | Opcje dla `intlayerMinifyBabelPlugin`: katalog bazowy, flagi minify/optimize/editorEnabled.                                |
+| `PruneContext`          | Stan współdzielony między wtyczkami analizującymi i oczyszczającymi: mapy użycia pól, mapy zmiany nazw itp.                |
+| `DictionaryFieldUsage`  | Wynik użycia pola dla pojedynczego słownika: `Set<string>` lub `'all'`, gdy analiza statyczna jest niejednoznaczna.        |
+| `NestedRenameEntry`     | Węzeł w drzewie zmiany nazw: `shortName` i mapa dzieci.                                                                    |
+| `NestedRenameMap`       | Jeden poziom w drzewie zmiany nazw: `Map<string, NestedRenameEntry>`.                                                      |
+| `CompatCallerConfig`    | Konfiguracja dla kompatybilnego analizatora użycia dla pakietów compat-adapter (nazwa wywołującego i opcje przetwarzania). |
+| `ScriptBlock`           | Blok skryptu wyekstrahowany z pliku SFC (Vue lub Svelte): zawartość, przesunięcie początkowe i przesunięcie końcowe.       |
+
+---
+
+### Funkcje pomocnicze
+
+| Funkcja                           | Opis                                                                                                                                                        |
+| --------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `generateShortFieldName`          | Konwertuje liczbę całkowitą (zaczynając od zera) na krótki identyfikator alfabetyczny: `0` → `'a'`, `25` → `'z'`, `26` → `'aa'`, itp.                       |
+| `buildNestedRenameMapFromContent` | Rekurencyjnie buduje `NestedRenameMap` z wartości zawaktu skompilowanego słownika, przestrzegając struktur węzłów Intlayer (translation, enumeration itp.). |
+| `createPruneContext`              | Tworzy nowy pusty obiekt `PruneContext` zainicjowany wartościami domyślnymi.                                                                                |
+| `extractScriptBlocks`             | Ekstrahuje bloki `<script>` z plików SFC (Vue / Svelte) do późniejszej analizy Babel.                                                                       |
+| `BABEL_PARSER_OPTIONS`            | Stała reprezentująca opcje parsera Babel obejmująca obsługiwane frameworki (React/Vue/Svelte/Angular/...).                                                  |
+| `INTLAYER_CALLER_NAMES`           | Stała lista oryginalnych nazw wywołujących Intlayer: `['useIntlayer', 'getIntlayer']`.                                                                      |
+
+---
+
+## Przykładowe użycie
+
+```js
+// babel.config.js
+const {
+  intlayerExtractBabelPlugin,
+  intlayerPurgeBabelPlugin,
+  intlayerMinifyBabelPlugin,
+  intlayerOptimizeBabelPlugin,
+  getExtractPluginOptions,
+  getPurgePluginOptions,
+  getMinifyPluginOptions,
+  getOptimizePluginOptions,
+} = require("@intlayer/babel");
+
+module.exports = {
+  presets: ["next/babel"],
+  plugins: [
+    [intlayerExtractBabelPlugin, getExtractPluginOptions()],
+    [intlayerPurgeBabelPlugin, getPurgePluginOptions()],
+    [intlayerMinifyBabelPlugin, getMinifyPluginOptions()],
+    [intlayerOptimizeBabelPlugin, getOptimizePluginOptions()],
+  ],
+};
+```
+
+> **Uwaga:** Wtyczka `intlayerPurgeBabelPlugin` musi być zadeklarowana **przed** `intlayerMinifyBabelPlugin`, ponieważ ta druga odczytuje mapę zmian nazw utworzoną przez tę pierwszą. Ponadto obie muszą być poprzedzone wtyczką `intlayerOptimizeBabelPlugin`, aby mogła ona zobaczyć klucze słownika przed przepisaniem wywołań do `useIntlayer`.

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

@@ -0,0 +1,120 @@
+---
+createdAt: 2026-06-25
+updatedAt: 2026-06-25
+title: Dokumentacja wtyczki Vite intlayerCompiler | vite-intlayer
+description: Wtyczka Vite, która ekstrahuje wbudowane deklaracje zawartości Intlayer z plików komponentów i zapisuje je do plików JSON słownika w czasie budowania/transformacji.
+keywords:
+  - intlayerCompiler
+  - vite
+  - wtyczka
+  - kompilator
+  - zawartość
+  - słownik
+  - umiędzynarodowienie
+  - i18n
+slugs:
+  - doc
+  - packages
+  - vite-intlayer
+  - intlayerCompiler
+history:
+  - version: 9.0.0
+    date: 2026-06-25
+    changes: "Zintegrowano z intlayer(); inicjalizacja dokumentacji"
+author: aymericzip
+---
+
+# intlayerCompiler
+
+`intlayerCompiler` to wtyczka Vite, która skanuje pliki źródłowe komponentów w poszukiwaniu **wbudowanych deklaracji zawartości Intlayer** (inline declarations) — zawartości zdefiniowanej bezpośrednio w komponencie, a nie w osobnym pliku `.content.ts` — i zapisuje je do plików JSON słownika podczas fazy transformacji.
+
+> **Od Intlayer v9** `intlayerCompiler` jest automatycznie dołączany do głównej wtyczki [`intlayer()`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/packages/vite-intlayer/intlayer.md), gdy zarówno `compiler.enabled` ma wartość `true`, jak i `compiler.output` jest ustawiony w konfiguracji Intlayer. Musisz go zarejestrować osobno tylko wtedy, gdy chcesz mieć pełną kontrolę nad konfiguracją specyficzną dla kompilatora.
+
+## Użycie
+
+### Jako część `intlayer()` (zalecane, v9+)
+
+Włącz kompilator w konfiguracji Intlayer:
+
+```ts
+// intlayer.config.ts
+import { defineConfig } from "intlayer";
+
+export default defineConfig({
+  compiler: {
+    enabled: true,
+    output: "./src/dictionaries", // gdzie zapisywane są wyekstrahowane słowniki
+  },
+});
+```
+
+Następnie użyj standardowej wtyczki bez dodatkowej rejestracji:
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayer } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [intlayer()],
+});
+```
+
+### Samodzielnie (w razie potrzeby)
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayerCompiler } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [intlayerCompiler()],
+});
+```
+
+## Opcje
+
+```ts
+import type { IntlayerCompilerOptions } from "vite-intlayer";
+```
+
+| Opcja            | Typ                       | Opis                                                                                                |
+| ---------------- | ------------------------- | --------------------------------------------------------------------------------------------------- |
+| `configOptions`  | `GetConfigurationOptions` | Nadpisania konfiguracji Intlayer przekazywane do `getConfiguration()`.                              |
+| `compilerConfig` | `Partial<CompilerConfig>` | Nadpisania sekcji konfiguracji specyficznej dla kompilatora (np. `enabled`, `output`, `filesList`). |
+
+### Przykład
+
+```ts
+intlayerCompiler({
+  configOptions: { configFile: "./config/intlayer.config.ts" },
+  compilerConfig: { enabled: true, output: "./src/dictionaries" },
+});
+```
+
+## Jak to działa
+
+### Faza transformacji
+
+Dla każdego pliku źródłowego, który pasuje do `compiler.filesList`, wtyczka kompilatora:
+
+1. Przekazuje zawartość pliku do `extractContent` z pakietu `@intlayer/babel`.
+2. Wywołuje `onExtract` dla każdej znalezionej deklaracji, co zapisuje wynikowy słownik JSON do ścieżki `compiler.output`.
+3. Zwraca przetransformowany kod źródłowy z wbudowanymi deklaracjami zastąpionymi standardowymi wywołaniami `useIntlayer('key')` / `getIntlayer('key')`.
+
+Obsługiwane typy plików: `.ts`, `.tsx`, `.js`, `.jsx`, `.vue`, `.svelte`, `.astro`.
+
+### HMR (Hot Module Replacement)
+
+Gdy plik komponentu zostanie zapisany w trybie deweloperskim, kompilator:
+
+1. Wykrywa zmianę pliku za pomocą hooka `handleHotUpdate` w Vite.
+2. Ponownie ekstrahuje zawartość ze zaktualizowanego pliku.
+3. Zapisuje zaktualizowany słownik JSON.
+4. Wyzwala pełne przeładowanie strony (`server.ws.send({ type: 'full-reload' })`).
+
+Debounce o wartości 500 ms zapobiega zapętleniu ponownej ekstrakcji spowodowanemu przez sam zapis słownika (który również wyzwala zdarzenie zmiany pliku).
+
+### Deduplikacja
+
+`intlayerCompiler` używa tego samego mechanizmu deduplikacji `createPrimaryInstanceGuard` co inne wbudowane wtyczki. Gdy obecne są zarówno `intlayer()` (który zawiera kompilator), jak i ręczne wywołanie `intlayerCompiler()`, uruchamiana jest tylko pierwsza zarejestrowana instancja — żadne słowniki nie są zapisywane dwukrotnie.

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

@@ -0,0 +1,92 @@
+---
+createdAt: 2026-06-25
+updatedAt: 2026-06-25
+title: Dokumentacja wtyczki Vite intlayerMinify | vite-intlayer
+description: Wtyczka Vite, która minifikuje skompilowane pliki JSON słownika Intlayer i opcjonalnie maskuje nazwy pól zawartości w celu zmniejszenia rozmiaru pakietu.
+keywords:
+  - intlayerMinify
+  - vite
+  - wtyczka
+  - minifikacja
+  - rozmiar pakietu
+  - słownik
+  - umiędzynarodowienie
+  - i18n
+slugs:
+  - doc
+  - packages
+  - vite-intlayer
+  - intlayerMinify
+history:
+  - version: 9.0.0
+    date: 2026-06-25
+    changes: "Inicjalizacja dokumentacji"
+author: aymericzip
+---
+
+# intlayerMinify
+
+`intlayerMinify` to wtyczka Vite, która minifikuje skompilowane pliki JSON słowników podczas kompilacji produkcyjnej. Usuwa wszystkie niepotrzebne białe znaki i, w połączeniu z `intlayerPrune`, opcjonalnie zmienia nazwy pól zawartości na krótkie alfabetyczne aliasy (`a`, `b`, `c`, …), aby jeszcze bardziej zmniejszyć rozmiar pakietu (bundle'a).
+
+> Ta wtyczka jest automatycznie dołączana i konfigurowana, gdy używasz wtyczki [`intlayer()`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/packages/vite-intlayer/intlayer.md). Musisz ją zarejestrować ręcznie tylko wtedy, gdy samodzielnie tworzysz stos wtyczek.
+
+## Użycie
+
+```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),
+  ],
+});
+```
+
+## Warunki aktywacji
+
+`intlayerMinify` jest aktywna **tylko** wtedy, gdy spełnione są wszystkie trzy poniższe warunki:
+
+1. Polecenie Vite to `build` (nie `serve` / dev).
+2. Opcja `build.optimize` ma wartość `true` (lub `undefined`, co dla kompilacji domyślnie oznacza `true`).
+3. Opcja `build.minify` w konfiguracji Intlayer ma wartość `true`.
+
+Wtyczka jest automatycznie **wyłączana**, gdy `editor.enabled` ma wartość `true`, ponieważ edytor wymaga pełnej, czytelnej dla człowieka zawartości słownika.
+
+## Co podlega minifikacji
+
+Wtyczka kieruje swoje działanie na dwie lokalizacje słowników (rozpoznane na podstawie `intlayer.system`):
+
+- `dictionariesDir` — statyczne słowniki dla wszystkich języków (np. `.intlayer/dictionaries/*.json`)
+- `dynamicDictionariesDir` — dynamiczne słowniki dla poszczególnych języków
+
+> Słowniki w trybie pobierania (`fetchDictionariesDir`) **nigdy** nie są minifikowane, ponieważ są serwowane z zewnętrznego API w czasie rzeczywistym przy użyciu ich oryginalnych nazw pól. Zmiana nazw pól stworzyłaby niezgodność między odpowiedzią serwera a dostępem do właściwości po stronie klienta.
+
+## Maskowanie nazw pól (minifikacja właściwości)
+
+Gdy wtyczka `intlayerPrune` przeanalizuje bazę kodu i uzupełni `pruneContext.dictionaryKeyToFieldRenameMap`, wtyczka `intlayerMinify` również zmienia nazwy pól zawartości na krótkie aliasy. Na przykład:
+
+```json
+// przed
+{ "key": "myDict", "content": { "title": "Hello", "description": "World" } }
+
+// po (z maskowaniem)
+{ "key": "myDict", "content": { "a": "Hello", "b": "World" } }
+```
+
+Odpowiednie odwołania do właściwości w plikach źródłowych są zmieniane przez przebieg Babel wewnątrz `intlayerOptimize`, więc zachowanie w czasie rzeczywistym pozostaje niezmienione.
+
+Wewnętrzne pola Intlayer (`nodeType`, `translation` itp.) nigdy nie zmieniają nazw.
+
+## Słowniki z przypadkami brzegowymi
+
+Słowniki oznaczone w `pruneContext.dictionariesWithEdgeCases` (anomalie strukturalne wykryte podczas fazy oczyszczania/prune) są całkowicie pomijane — nie są minifikowane ani maskowane — aby uniknąć dostarczenia uszkodzonych danych.
+
+## Grupy kwalifikowane (kolekcje / warianty / metarekordy)
+
+W przypadku słowników z tablicą `qualifierTypes` (kolekcje, warianty i metarekordy), wtyczka zachowuje tablicę `qualifierTypes` oraz mapę poboczną `meta` w oryginalnej formie. Maskowane są tylko nazwy pól wewnątrz wpisów `content`. Złożone klucze (używane do dopasowywania selektorów w czasie rzeczywistym) nigdy nie są modyfikowane.

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

@@ -0,0 +1,172 @@
+---
+createdAt: 2026-06-25
+updatedAt: 2026-06-25
+title: Dokumentacja wtyczki Vite intlayerProxy | vite-intlayer
+description: Oprogramowanie pośredniczące (middleware) do routingu języków dla serwerów deweloperskich i podglądu Vite oraz produkcyjnego SSR. Obsługuje wykrywanie języka, przekierowania URL i wewnętrzne przepisywanie ścieżek.
+keywords:
+  - intlayerProxy
+  - vite
+  - wtyczka
+  - middleware
+  - język
+  - routing
+  - umiędzynarodowienie
+  - i18n
+  - SSR
+slugs:
+  - doc
+  - packages
+  - vite-intlayer
+  - intlayerProxy
+history:
+  - version: 9.0.0
+    date: 2026-06-25
+    changes: "Scalono configOptions w jeden obiekt opcji; proxy jest wbudowane w intlayer()"
+author: aymericzip
+---
+
+# intlayerProxy
+
+`intlayerProxy` to wtyczka Vite, która rejestruje oprogramowanie pośredniczące (middleware) do routingu języków dla **każdego środowiska**: serwera deweloperskiego, serwera podglądu i produkcyjnego SSR (Nitro / TanStack Start).
+
+> **Od Intlayer v9** `intlayerProxy` jest automatycznie dołączany do głównej wtyczki [`intlayer()`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/packages/vite-intlayer/intlayer.md) i domyślnie włączony poprzez `routing.enableProxy: true`. Musisz go zarejestrować osobno tylko wtedy, gdy potrzebujesz kontroli na niższym poziomie lub używasz go poza standardową konfiguracją `intlayer()`.
+
+## Użycie
+
+### Jako część `intlayer()` (zalecane, v9+)
+
+Przekaż opcje `proxy` do głównej wtyczki zamiast rejestrować `intlayerProxy` osobno:
+
+```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"),
+      },
+    }),
+  ],
+});
+```
+
+### Samodzielnie (w razie potrzeby)
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayer } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [intlayer()],
+});
+```
+
+## Opcje
+
+```ts
+import type { IntlayerProxyPluginOptions } from "vite-intlayer";
+```
+
+Wszystkie opcje są opcjonalne i przekazywane jako pojedynczy obiekt:
+
+| Opcja           | Typ                                 | Opis                                                                                                                                                                     |
+| --------------- | ----------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `ignore`        | `(req: IncomingMessage) => boolean` | Predykat wykluczający żądania z routingu języków. Zwróć `true`, aby pominąć żądanie (np. ścieżki API, testy kondycji/health checki).                                     |
+| `configOptions` | `GetConfigurationOptions`           | Nadpisania konfiguracji Intlayer przekazywane do `getConfiguration()`. Użyj, gdy potrzebujesz, aby proxy czytało określony plik konfiguracyjny lub nadpisywało wartości. |
+
+### Przykład
+
+```ts
+intlayerProxy({
+  ignore: (req) => req.url?.startsWith("/api"),
+  configOptions: { configFile: "./config/intlayer.config.ts" },
+});
+```
+
+## createIntlayerProxyHandler
+
+`createIntlayerProxyHandler` tworzy samodzielne, niezależne od frameworka oprogramowanie pośredniczące Node.js `(req, res, next)`, które zawiera całą logikę routingu języków. Jest przydatne w środowiskach, w których API wtyczek Vite jest niedostępne (np. czysty serwer Node.js lub niestandardowy moduł Nitro).
+
+```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);
+```
+
+### Produkcyjny SSR (TanStack Start / Nitro przez 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"),
+  })
+);
+```
+
+## Zachowanie routingu
+
+Oprogramowanie pośredniczące odzwierciedla logikę routingu z middleware `next-intlayer` i obsługuje wszystkie tryby routingu Intlayer.
+
+### Tryby routingu
+
+| Tryb            | Widoczność URL w przeglądarce | Zachowanie                                                                                                                                                          |
+| --------------- | ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `prefix`        | `/pl/about`                   | Domyślny. Prefiks języka w adresie URL. Domyślny język przekierowuje do adresu URL bez prefiksu, chyba że włączono `prefix-all`.                                    |
+| `prefix-all`    | `/en/about`, `/pl/about`      | Wszystkie języki — w tym domyślny — są zawsze poprzedzone prefiksem.                                                                                                |
+| `no-prefix`     | `/about`                      | Brak języka w adresie URL. Język jest przechowywany wyłącznie w plikach cookie; przepisywanie URL odbywa się wewnętrznie.                                           |
+| `search-params` | `/about?locale=pl`            | Język przekazywany jako parametr zapytania (query parameter). Przekierowuje w celu dodania/aktualizacji parametru `locale`, jeśli go brakuje lub jest przestarzały. |
+
+### Priorytet wykrywania
+
+1. Prefiks ścieżki URL (np. `/pl/about` → `pl`).
+2. Wartość pliku cookie / localStorage (`intlayer-locale`).
+3. Nagłówek `Accept-Language`.
+4. `defaultLocale` z konfiguracji.
+
+### Automatyczne pomijanie (bypass)
+
+Oprogramowanie pośredniczące zawsze przepuszcza te żądania bezpośrednio, bez obsługi języka:
+
+- Żądania pasujące do predykatu `ignore`.
+- `/node_modules/**`
+- `/@**` – wewnętrzne zasoby Vite (`@vite/`, `@fs/`, `@id/` itp.).
+- `/_**` – wewnętrzne zasoby serwera (`__vite_ping`, `__manifest` itp.).
+- Żądania, których ścieżka kończy się rozszerzeniem pliku (zasoby statyczne). Jeśli w ścieżce zasobu statycznego obecny jest prefiks języka (np. `/pl/logo.png`), zostaje on usunięty, aby plik mógł być serwowany poprawnie.
+
+### Routing domenowy
+
+Gdy w konfiguracji Intlayer skonfigurowano `routing.domains`, oprogramowanie pośredniczące obsługuje routing językowy między różnymi domenami:
+
+- Żądanie dla `/zh/about` w domenie `intlayer.org` jest przekierowywane na `https://intlayer.zh/about`, gdy `domains.zh = "intlayer.zh"`.
+- Żądanie do `intlayer.zh/about` jest wewnętrznie przepisywane na `/zh/about`, aby parametr trasy `[locale]` został uzupełniony.
+
+### Ochrona przed pętlą przekierowań
+
+Oprogramowanie pośredniczące śledzi liczbę przekierowań dla pary `originalUrl → newUrl` w ruchomym oknie 2 sekund. Więcej niż 10 przekierowań w tym oknie zwraca odpowiedź `500` z opisowym błędem zamiast zapętlania się w nieskończoność.
+
+## Nitro / produkcyjny SSR (automatyczna iniekcja, v9+)
+
+Gdy `intlayerProxy` jest używany jako wtyczka Vite, niesie ze sobą właściwość `.nitro`. Wtyczka budująca `nitro/vite` odczytuje tę właściwość i wstrzykuje ją do `nitroConfig.modules`, dzięki czemu `intlayerNitroHandler` rejestruje się jako serwerowe oprogramowanie pośredniczące Nitro automatycznie — dla produkcyjnego SSR nie jest wymagana żadna ręczna konfiguracja.
+
+Handler Nitro korzysta z modelu zdarzeń Web Fetch API h3 v2 (nie `fromNodeMiddleware`), więc jest kompatybilny ze wszystkimi szablonami (presets) Nitro: Node, Bun, Deno, środowiskami edge.
+
+## Zdeprecjonowane aliasy
+
+| Zdeprecjonowany eksport    | Zamiennik       |
+| -------------------------- | --------------- |
+| `intlayerMiddleware`       | `intlayerProxy` |
+| `intLayerMiddlewarePlugin` | `intlayerProxy` |

package/docs/pl/releases/v9.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2026-06-14
-updatedAt: 2026-06-14
+updatedAt: 2026-06-25
 title: Nowy Intlayer v9 - Co nowego?
 description: Odkryj nowości w Intlayer v9. Przedstawiamy pakiety kompatybilności typu drop-in dla popularnych bibliotek i18n oraz wsparcie dla Kolekcji (Collections), Wariantów (Variants) i Dynamicznych Rekordów (Dynamic Records).
 keywords:
@@ -252,6 +252,28 @@ Autonomiczne pluginy `intlayerCompiler()` i `intlayerProxy()` pozostają eksport
 
 ---
 
+## React Native: importy z jednego pakietu
+
+W aplikacji React Native lub Expo nie musisz już żonglować pakietami `react-intlayer` i `react-native-intlayer`. Pakiet `react-native-intlayer` teraz **ponownie eksportuje pełne API `react-intlayer`** (hooki, narzędzia oraz podścieżki `/format`, `/html` i `/markdown`), a jego `IntlayerProvider` automatycznie stosuje polyfille React Native.
+
+Importuj wszystko z jednego pakietu `react-native-intlayer`:
+
+```tsx
+import {
+  IntlayerProvider,
+  useIntlayer,
+  useLocale,
+} from "react-native-intlayer";
+```
+
+```bash
+npm install intlayer react-native-intlayer
+```
+
+> Importowanie z `react-intlayer` nadal działa, ale `react-native-intlayer` jest teraz zalecanym pojedynczym punktem wejścia dla React Native — jego provider zawiera polyfille, których nie posiada zorientowany na web provider `react-intlayer`.
+
+---
+
 ## Uwagi dotyczące migracji z wersji v8
 
 Jeśli aktualizujesz aplikację z wersji v8, pamiętaj, że wersja v9 nie zawiera zmian wprowadzających niekompatybilność wsteczną (breaking changes). Oto jednak kluczowe zmiany:

package/docs/pt/compiler.md

@@ -79,12 +79,15 @@ Atualize seu `vite.config.ts` para incluir el plugin `intlayerCompiler`:
 
 ```ts fileName="vite.config.ts"
 import { defineConfig } from "vite";
-import { intlayer, intlayerCompiler } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 export default defineConfig({
   plugins: [
-    intlayer(),
-    intlayerCompiler(), // Adiciona o plugin do compilador
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
   ],
 });
 ```

package/docs/pt/custom_domains.md

@@ -167,10 +167,16 @@ O plugin Vite `intlayerProxy` aplica a mesma lógica durante o desenvolvimento:
 
 ```typescript fileName="vite.config.ts"
 import { defineConfig } from "vite";
-import { intlayerProxy } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 export default defineConfig({
-  plugins: [intlayerProxy()],
+  plugins: [
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
+  ],
 });
 ```
 

package/docs/pt/custom_url_rewrites.md

@@ -342,10 +342,16 @@ Para SolidJS, Vue e Svelte, o plugin Vite `intlayerProxy` gerencia as reescritas
 
 ```typescript fileName="vite.config.ts"
 import { defineConfig } from "vite";
-import { intlayerProxy } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 export default defineConfig({
-  plugins: [intlayerProxy()],
+  plugins: [
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
+  ],
 });
 ```
 

package/docs/pt/intlayer_with_analog.md

@@ -207,7 +207,11 @@ import analog from "@analogjs/platform";
 export default defineConfig(() => ({
   plugins: [
     analog(),
-    intlayer(), // Adicione o plugin Intlayer
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
   ],
 }));
 ```

package/docs/pt/intlayer_with_astro.md

@@ -391,6 +391,8 @@ bun x intlayer extract
  </Tab>
  <Tab value='Compilador Babel'>
 
+> Since v9, the `intlayerCompiler` is included in the `intlayer` plugin. So you don't need to add it manually.
+
 Atualize seu `vite.config.ts` para incluir o plugin `intlayerCompiler`:
 
 ```ts fileName="vite.config.ts"
@@ -400,7 +402,7 @@ import { intlayer, intlayerCompiler } from "vite-intlayer";
 export default defineConfig({
   plugins: [
     intlayer(),
-    intlayerCompiler(), // Adiciona o plugin do compilador
+    intlayerCompiler(), // Adds the compiler plugin
   ],
 });
 ```
@@ -568,9 +570,9 @@ bun x intlayer extract
  </Tab>
  <Tab value='Babel compiler'>
 
-Atualize seu `vite.config.ts` para incluir o plugin `intlayerCompiler`:
+> Since v9, the `intlayerCompiler` is included in the `intlayer` plugin. So you don't need to add it manually.
 
-> Desde o Intlayer v9, o compiler é empacotado diretamente no plugin `intlayer()` e é ativado automaticamente quando `compiler.enabled` está definido com um caminho `compiler.output`. Registrar `intlayerCompiler()` separadamente conforme mostrado abaixo agora é opcional — ele se deduplica se também for adicionado. Veja as [notas de lançamento v9](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/releases/v9.md).
+Atualize seu `vite.config.ts` para incluir o plugin `intlayerCompiler`:
 
 ```ts fileName="vite.config.ts"
 import { defineConfig } from "vite";
@@ -579,7 +581,7 @@ import { intlayer, intlayerCompiler } from "vite-intlayer";
 export default defineConfig({
   plugins: [
     intlayer(),
-    intlayerCompiler(), // Adiciona o plugin do compiler
+    intlayerCompiler(), // Adds the compiler plugin
   ],
 });
 ```