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

package/docs/pl/cli/login.md

@@ -76,42 +76,6 @@ pnpm intlayer login --cms-url https://intlayer.org
 bun x intlayer login --cms-url https://intlayer.org
 ```
 
-### Opcje konfiguracji
-
-Możesz także użyć standardowych opcji konfiguracji:
-
-- `--env-file <path>`: Ścieżka do pliku środowiskowego
-- `-e, --env <env>`: Środowisko wykonawcze
-- `--base-dir <dir>`: Katalog bazowy projektu
-- `--verbose`: Włącz szczegółowe logowanie (domyślnie: true)
-- `--prefix <prefix>`: Prefiks dla logów
-
-## Jak to działa
-
-1. **Uruchomienie serwera lokalnego**: Polecenie uruchamia lokalny serwer HTTP na losowym porcie, aby odebrać poświadczenia z CMS
-
-Określ URL Intlayer CMS, z którym należy się połączyć w celu uwierzytelnienia.
-
-- **Typ**: `string`
-- **Domyślna wartość**: Wartość skonfigurowana w `intlayer.config.*` lub `https://intlayer.org`
-- **Przykład**:
-
-```bash packageManager="npm"
-npx intlayer login --cms-url https://intlayer.org
-```
-
-```bash packageManager="yarn"
-yarn intlayer login --cms-url https://intlayer.org
-```
-
-```bash packageManager="pnpm"
-pnpm intlayer login --cms-url https://intlayer.org
-```
-
-```bash packageManager="bun"
-bun x intlayer login --cms-url https://intlayer.org
-```
-
 ### Opcje konfiguracyjne
 
 Możesz również użyć ogólnych opcji konfiguracyjnych:

package/docs/pl/cli/scan.md

@@ -18,7 +18,7 @@ slugs:
   - cli
   - scan
 history:
-  - version: 8.13.0
+  - version: 9.0.0
     date: 2026-06-11
     changes: "Dodano polecenie scan"
 author: aymericzip

package/docs/pl/compat/i18n-js.md

@@ -0,0 +1,44 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migracja z i18n-js do Intlayer"
+description: "Dowiedz się, jak przeprowadzić migrację aplikacji z i18n-js do Intlayer za pomocą adaptera kompatybilności."
+keywords:
+  - i18n-js
+  - intlayer
+  - migracja
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - i18n-js
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Migracja z i18n-js do Intlayer
+
+Przejście z biblioteki `i18n-js` do Intlayer to wysoce zoptymalizowana migracja zaprojektowana aby przenieść duże konfiguracje tłumaczeń do strukturalnego systemu rozwiązywania plików Intlayer.
+
+## Co zrobić
+
+Wykonaj następujące polecenie konfiguracyjne w swoim repozytorium:
+
+```bash
+npx intlayer init
+```
+
+Po przygotowaniu pliku `intlayer.config.ts`, możesz dodać alias Intlayer do konfiguracji twojego bundlera, aby wszelkie importy `i18n-js` wskazywały na pakiet compat `@intlayer/i18n-js`.
+
+## Co się dzieje za kulisami
+
+`i18n-js` uzyskuje dostęp do przestrzeni nazw poprzez wyrażenia takie jak `i18n.t('scope.key', {name})` wraz z rezerwowymi ustawieniami lokali i specjalnymi mapowaniami liczby mnogiej.
+
+Za kulisami:
+
+- **Interpolacja:** Adapter compat z łatwością parsuje mapowania `%{name}` na wartość słownika czasu wykonywania docelowego.
+- **Liczba mnoga:** Zastępuje podklucze `one/other` i mapuje je względem potężnych bazowych mechanizmów liczby mnogiej Intlayer (`Intl.PluralRules`), abstrakcyjnie oddzielając ręczne mapowania.
+- **Lokale:** Zamiast ładować monolityczne payload języka przy inicjalizacji, słowniki są serwowane optymalnie na podstawie obecnej konfiguracji kontekstu poprzez natywną konfigurację Intlayer.

package/docs/pl/compat/i18next.md

@@ -0,0 +1,59 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migracja z i18next do Intlayer"
+description: "Dowiedz się, jak przeprowadzić migrację aplikacji Vanilla JS/TS z i18next do Intlayer za pomocą adaptera kompatybilności."
+keywords:
+  - i18next
+  - vanilla
+  - javascript
+  - typescript
+  - intlayer
+  - migracja
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - i18next
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Migracja z i18next do Intlayer
+
+Aby zapoznać się z szczegółowym samouczkiem krok po kroku, zapraszamy do naszego pełnego [Przewodnika migracji z i18next](../migration_from_i18next_to_intlayer.md).
+
+Intlayer doskonale replikuje podstawowe charakterystyki czasu wykonywania `i18next`. Wykorzystując pakiet compat, twoje aplikacje Vanilla lub moduły wewnętrzne mogą nadal korzystać ze znanej składni.
+
+## Co zrobić
+
+Aby rozpocząć, zainicjuj Intlayer w swoim projekcie:
+
+```bash
+npx intlayer init
+```
+
+Jeśli używasz Vite, dołącz plugin Intlayer aby przekierować importy do `@intlayer/i18next`:
+
+```typescript fileName="vite.config.ts"
+import { defineConfig } from "vite";
+import { i18nextVitePlugin } from "@intlayer/i18next/plugin";
+
+export default defineConfig({
+  plugins: [i18nextVitePlugin()],
+});
+```
+
+## Co się dzieje za kulisami
+
+Plugin `i18nextVitePlugin` aliasuje importy `i18next` do `@intlayer/i18next`, unikając obciążenia bundle z włączeniami plików JSON.
+
+Za kulisami:
+
+- **Konfiguracja instancji:** `createInstance` poprawnie parsuje i stosuje rezerwowe ustawienia przestrzeni nazw, korzystając z rurociągu kompilacji Intlayer dla pobierania słownika.
+- **Interpolacja:** Natywna obsługa zamian `{{name}}` i zagnieżdżania `$t(key)` rekursywnie.
+- **Kontekst i liczba mnoga:** Identyfikuje i rozwiązuje formaty sufiksów takie jak `key_male` i `key_one`/`key_other`, obliczając względem standardu `Intl.PluralRules`.
+- **Zwracanie obiektów:** Tryb `returnObjects: true` bezpiecznie wyodrębnia drzewa ze słowników Intlayer.

package/docs/pl/compat/index.md

@@ -0,0 +1,51 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Adaptery kompatybilności Intlayer"
+description: "Migruj istniejące rozwiązanie i18n do Intlayer bez tarcia za pomocą adapterów kompatybilności."
+keywords:
+  - compat
+  - migracja
+  - internationalization
+  - i18n
+  - Intlayer
+slugs:
+  - doc
+  - compatibility
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Adaptery kompatybilności Intlayer
+
+Migracja dużej aplikacji do nowej biblioteki internacjonalizacji może być zniechęcająca. Aby ułatwić to przejście, Intlayer zapewnia **adaptery kompatybilności** dla najpopularniejszych bibliotek i18n w ekosystemie.
+
+Te pakiety adapterów ujawniają **dokładnie taki sam publiczny API** co istniejące biblioteki i18n, ale delegują całą pracę tłumaczenia do Intlayer w czasie wykonywania.
+
+## Jak to działa
+
+Kiedy używasz adaptera compat, nie musisz przepisywać importów aplikacji ani zmieniać sposobu korzystania z hoków i komponentów tłumaczenia. Zamiast tego, wtyczki bundlera Intlayer automatycznie aliasują istniejące importy do pakietów compat Intlayer.
+
+Na przykład, deweloper zastępuje `import { useTranslation } from 'react-i18next'` przez `import { useTranslation } from '@intlayer/react-i18next'` (wykonane automatycznie poprzez wtyczkę bundlera), a aplikacja kontynuuje pracę z tłumaczeniami serwowanymi z słowników Intlayer. Klucze są również wpisane względem twoich słowników Intlayer!
+
+## Dostępne adaptery kompatybilności
+
+Wybierz istniejącą bibliotekę poniżej, aby zobaczyć jak bezproblemowo przeprowadzić migrację:
+
+- [Vue I18n](./vue-i18n.md)
+- [Transloco](./transloco.md)
+- [React Intl](./react-intl.md)
+- [Svelte I18n](./svelte-i18n.md)
+- [React i18next](./react-i18next.md)
+- [Polyglot.js](./polyglot.md)
+- [NuxtJS I18n](./nuxtjs-i18n.md)
+- [NGX Translate](./ngx-translate.md)
+- [Next Translate](./next-translate.md)
+- [Next Intl](./next-intl.md)
+- [Next i18next](./next-i18next.md)
+- [i18next](./i18next.md)
+- [Lingui](./lingui.md)
+- [I18n-js](./i18n-js.md)

package/docs/pl/compat/lingui.md

@@ -0,0 +1,44 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migracja z Lingui do Intlayer"
+description: "Dowiedz się, jak przeprowadzić migrację aplikacji z Lingui do Intlayer za pomocą adaptera kompatybilności."
+keywords:
+  - lingui
+  - intlayer
+  - migracja
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - lingui
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Migracja z Lingui do Intlayer
+
+Jeśli twój projekt opiera się na kompilacji opartej na makrach Lingui, przejście na Intlayer pozwala ci utrzymać potężne przepływy pracy makr, wspierając je natywnie strategią kompilacji JSON Intlayer.
+
+## Co zrobić
+
+Aby rozpocząć, zainicjuj Intlayer w swoim projekcie:
+
+```bash
+npx intlayer init
+```
+
+To tworzy twój `intlayer.config.ts`. Upewnij się, że zachowujesz `@lingui/babel-plugin-lingui-macro` / `@lingui/swc-plugin` w kroku budowania, aby działał _przed_ kompilator Intlayer. Następnie, użyj aliasu wtyczki bundlera aby przekierować `@lingui/core` i `@lingui/react` do `@intlayer/lingui`.
+
+## Co się dzieje za kulisami
+
+Lingui wykorzystuje makra (takie jak `` t`Hello ${name}` `` i `<Trans>`) które są kompilowane w wywołania czasu wykonywania takie jak `i18n._(id, values)`.
+
+Za kulisami:
+
+- **Makra:** Kompilują się dokładnie jak wcześniej, zapewniając brak przerwy w składni źródła.
+- **Tłumaczenie czasu wykonywania:** Alias `i18n._()` korzysta ze słowników Intlayer. Zarówno jawnie nazwane identyfikatory jak i zahaszowane identyfikatory są w pełni mapowane używając wtyczek synchronizacji Intlayer `.po` aby agregować i usuwać klucze bezpiecznie.
+- **Możliwości ICU:** Obsługa pluralizacji, selekcji i wariantów ICU pozostaje solidna dzięki ujednoliconemu parserowi ICU Intlayer, zapewniając identyczne wyniki renderowania.

package/docs/pl/compat/next-i18next.md

@@ -0,0 +1,57 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migracja z next-i18next do Intlayer"
+description: "Dowiedz się, jak przeprowadzić migrację aplikacji Next.js z next-i18next do Intlayer za pomocą adaptera kompatybilności."
+keywords:
+  - next-i18next
+  - nextjs
+  - intlayer
+  - migracja
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - next-i18next
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Migracja z next-i18next do Intlayer
+
+Aby zapoznać się z kompletnym i szczegółowym samouczkiem krok po kroku, zapraszamy do naszego pełnego [Przewodnika migracji z next-i18next](../migration_from_next-i18next_to_intlayer.md).
+
+Intlayer obsługuje wszystkie implementacje Next.js Pages Router i App Router transparentnie. Korzystając z adaptera możesz przeprowadzić migrację swojej implementacji `next-i18next` bez przepisywania kodu.
+
+## Co zrobić
+
+Aby rozpocząć, uruchom:
+
+```bash
+npx intlayer init
+```
+
+To tworzy wymagany plik konfiguracji Intlayer. Aby przełączyć się na Intlayer za kulisami, zaktualizuj swój `next.config.ts`:
+
+```typescript fileName="next.config.ts"
+import type { NextConfig } from "next";
+import { createNextI18nPlugin } from "@intlayer/next-i18next/plugin";
+
+const withIntlayer = createNextI18nPlugin();
+
+const nextConfig: NextConfig = {};
+
+export default withIntlayer(nextConfig);
+```
+
+## Co się dzieje za kulisami
+
+Plugin `createNextI18nPlugin` komponuje natywne zachowanie Next.js wraz z podstawową wtyczką `next-intlayer`, wstrzykując wszystkie wymagane aliasy Webpack/Turbopack dla `next-i18next`, `react-i18next` i `i18next`.
+
+Za kulisami:
+
+- **`serverSideTranslations` & `appWithTranslation`:** Teraz funkcjonują jako opakowania dla wewnętrznych zaladowników Intlayer, omijając dużą statyczną iniekcję JSON.
+- **Hooki klienckie:** Delegują natychmiast do `@intlayer/react-i18next` zachowując wszystkie funkcje formatowania, liczby mnogiej i zagnieżdżone przestrzenie nazw.

package/docs/pl/compat/next-intl.md

@@ -0,0 +1,59 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migracja z next-intl do Intlayer"
+description: "Dowiedz się, jak przeprowadzić migrację aplikacji Next.js z next-intl do Intlayer za pomocą adaptera kompatybilności."
+keywords:
+  - next-intl
+  - nextjs
+  - intlayer
+  - migracja
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - next-intl
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Migracja z next-intl do Intlayer
+
+Aby zapoznać się z kompletnym i szczegółowym samouczkiem krok po kroku, zapraszamy do naszego pełnego [Przewodnika migracji z next-intl](../migration_from_next-intl_to_intlayer.md).
+
+Migracja z `next-intl` do Intlayer pozwala ci utrzymać routing aplikacji i składnię całkowicie niezakłócone.
+
+## Co zrobić
+
+Wykonaj następujące polecenie w swoim repozytorium:
+
+```bash
+npx intlayer init
+```
+
+To będzie tworzyć `intlayer.config.ts`. W swoim `next.config.ts`, użyj opakowania wtyczki aby bezproblemowo wstrzyknąć aliasy `next-intl` do `@intlayer/next-intl`.
+
+```typescript fileName="next.config.ts"
+import type { NextConfig } from "next";
+import { createNextIntlPlugin } from "@intlayer/next-intl/plugin";
+
+const withIntlayer = createNextIntlPlugin();
+
+const nextConfig: NextConfig = {};
+
+export default withIntlayer(nextConfig);
+```
+
+## Co się dzieje za kulisami
+
+Opakowywacz bundlera zastępuje tłumaczenia, ale **pozostawia funkcje `next-intl/navigation` nienaruszone** (np. `Link`, `redirect`, `usePathname`).
+
+Za kulisami:
+
+- **Runtime ICU:** Liczby mnoga (`=0`, `one`, `other`), select/selectordinal, argumenty `#` i sformatowane argumenty (`{ts, date, long}`) działają poprawnie używając wspólnego `resolveMessage(..., 'icu')` resolver.
+- **`useTranslations()` & `getTranslations()`:** Wywołania zakresu bare wyodrębniają pierwszy segment klucza jako prawidłowy identyfikator słownika. Zagnieżdżone przestrzenie nazw łagodnie dzielą się na ścieżki słownika i prefiksy.
+- **Formatowanie bogate:** Zarówno `t.rich()` jak i `t.markup()` są w pełni natywnie implementowane, konwertując węzły podobne do HTML na wyrenderowane fragmenty React.
+- **`useFormatter`:** `relativeTime`, `list`, `dateTimeRange` i nazwane formaty z konfiguracji mostu do podstawowych natywnych `Intl` formatów.

package/docs/pl/compat/next-translate.md

@@ -0,0 +1,45 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migracja z Next Translate do Intlayer"
+description: "Dowiedz się, jak przeprowadzić migrację aplikacji Next.js z next-translate do Intlayer za pomocą adaptera kompatybilności."
+keywords:
+  - next-translate
+  - nextjs
+  - intlayer
+  - migracja
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - next-translate
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Migracja z Next Translate do Intlayer
+
+Migracja z `next-translate` do Intlayer to prawie drop-in replacement, który zachowuje istniejącą składnię i tagi.
+
+## Co zrobić
+
+Zainicjuj Intlayer w swoim projekcie:
+
+```bash
+npx intlayer init
+```
+
+CLI będzie budować twoją konfigurację. Możesz następnie zastosować wtyczkę Intlayer w swoim `next.config.ts`, która wstrzykuje aliasy ścieżki czasu budowania mapujące `next-translate/useTranslation` do `@intlayer/next-translate`.
+
+## Co się dzieje za kulisami
+
+`next-translate` zapewnia hooki takie jak `useTranslation('ns')`, `t('ns:key.path')` i komponent `<Trans>`.
+
+Za kulisami:
+
+- **Interpolacja i liczba mnoga:** Opiera się ściśle na zachowaniu adaptera `react-i18next`. Dynamicznie obsługiwane są symbole zastępcze `{{var}}` i pluralizacja mapowana z sufiksów takich jak `key_0`, `key_one` i `key_other`.
+- **Komponent `<Trans>`:** Bezpośrednio obsługiwany do parsowania tagów podobnych do HTML wraz z prop `components` na podstawie tablic.
+- **Przestrzenie nazw:** Aliasing ścieżki podrzędnej zapewnia, że twoje referencje `useTranslation` odwołują się do prawidłowych wewnętrznych słowników przestrzeni nazw bez ręcznej modyfikacji.

package/docs/pl/compat/ngx-translate.md

@@ -0,0 +1,45 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migracja z NGX-Translate do Intlayer"
+description: "Dowiedz się, jak przeprowadzić migrację aplikacji Angular z ngx-translate do Intlayer za pomocą adaptera kompatybilności."
+keywords:
+  - ngx-translate
+  - angular
+  - intlayer
+  - migracja
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - ngx-translate
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Migracja z NGX-Translate do Intlayer
+
+Migracja aplikacji Angular z `ngx-translate` do Intlayer jest łatwa za pomocą adaptera compat, pozwalając pominąć potrzebę przepisywania wszystkich szablonów.
+
+## Co zrobić
+
+Rozpocznij uruchamiając:
+
+```bash
+npx intlayer init
+```
+
+To ustawia `intlayer.config.ts`. Zastąp konfiguracje `TranslateModule.forRoot()` i aliasy importu odpowiednio aby wskazywały na `@intlayer/ngx-translate`.
+
+## Co się dzieje za kulisami
+
+`ngx-translate` wykorzystuje `TranslateService` (`instant`, `get`, `stream`) wraz z piperem `{{ 'KEY' | translate:params }}` i dyrektywą `[translate]`.
+
+Za kulisami:
+
+- **Serwisy:** `TranslateService` opakuje `getIntlayer` i obserwowalne lokali, zapewniając dokładnie te same metody.
+- **Pipy i dyrektywy:** Ponownie wdrożone aby rozwiązywać względem słowników Intlayer bezpośrednio.
+- **Zaladowniki:** Konfiguracje `TranslateHttpLoader` są konwertowane na zadania ostrzeżeń, ponieważ Intlayer natywnie rozwiązuje i powiązuje twoje słowniki w czasie budowania (lub poprzez standardowe importy dynamiczne), całkowicie eliminując potrzebę zaladowników HTTP.

package/docs/pl/compat/nuxtjs-i18n.md

@@ -0,0 +1,46 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migracja z NuxtJS I18n do Intlayer"
+description: "Dowiedz się, jak przeprowadzić migrację aplikacji Nuxt.js z @nuxtjs/i18n do Intlayer za pomocą adaptera kompatybilności."
+keywords:
+  - nuxtjs-i18n
+  - nuxt
+  - vue
+  - intlayer
+  - migracja
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - nuxtjs-i18n
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Migracja z NuxtJS I18n do Intlayer
+
+Migracja aplikacji Nuxt z `@nuxtjs/i18n` do Intlayer jest bezproblemową operacją za pomocą modułu adaptera Nuxt.
+
+## Co zrobić
+
+Aby zainicjować projekt, uruchom:
+
+```bash
+npx intlayer init
+```
+
+To będzie ustawiać `intlayer.config.ts`. Następnie, dodaj moduł Intlayer Nuxt (np. `@intlayer/nuxt-i18n`) w tablicy modułów `nuxt.config.ts`. To automatycznie stosuje konfigurację compat dla twojej aplikacji.
+
+## Co się dzieje za kulisami
+
+`@nuxtjs/i18n` opakuje `vue-i18n` przy jednoczesnym zapewnieniu composables specyficznych dla Nuxt (`useLocalePath`, `useSwitchLocalePath`, `<NuxtLinkLocale>`).
+
+Za kulisami:
+
+- **Tłumaczenia:** Opiera się natywnie na warstwie compat `@intlayer/vue-i18n` dla wszystkich zadań tłumaczenia ciągu (w pełni obsługujące formaty `vue-i18n`, pipe liczby mnogiej i reaktywność).
+- **Routing:** Odzwierciedla composables routingu używając pomocników URL zlokalizowanych przez Intlayer.
+- **Konfiguracja:** Czyta `availableLocales` i ustawienia domyślne bezpośrednio z twojego `intlayer.config.ts` aby koordynować strony Nuxt automatycznie.

package/docs/pl/compat/polyglot.md

@@ -0,0 +1,45 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migracja z Polyglot.js do Intlayer"
+description: "Dowiedz się, jak przeprowadzić migrację z Polyglot.js do Intlayer za pomocą adaptera kompatybilności."
+keywords:
+  - polyglot
+  - airbnb
+  - intlayer
+  - migracja
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - polyglot
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Migracja z Polyglot.js do Intlayer
+
+Jeśli używasz Airbnb Polyglot.js, migracja do Intlayer jest niezwykle prosta za pomocą warstwy compat.
+
+## Co zrobić
+
+Po prostu uruchom polecenie inicjalizacji w swoim projekcie:
+
+```bash
+npx intlayer init
+```
+
+To generuje `intlayer.config.ts`. Możesz następnie wykorzystać alias wtyczki bundlera aby transparentnie przekierować importy Polyglot do `@intlayer/polyglot`.
+
+## Co się dzieje za kulisami
+
+Składnia Polyglot.js zazwyczaj opiera się na `polyglot.t('key', {name})` z interpolacjami `%{name}` i liczby mnogiej `smart_count` rozdzielonymi przez `"singular |||| plural"`.
+
+Za kulisami:
+
+- **Interpolacja:** Warstwa compat obsługuje symbole zastępcze `%{var}` natywnie.
+- **Liczba mnoga:** Ciąg jest dzielony w `||||` i obliczany względem natywnego `Intl.PluralRules` zgodnie z aktywną lokalą, odzwierciedlając własny porządek zasobnika Polyglot na lokalę.
+- **Słowniki:** Omijasz potrzebę dostarczania ogromnych konfiguracji JSON do `new Polyglot()` – Intlayer obsługuje słowniki dynamicznie i automatycznie je oczyści.

package/docs/pl/compat/react-i18next.md

@@ -0,0 +1,58 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migracja z react-i18next do Intlayer"
+description: "Dowiedz się, jak przeprowadzić migrację aplikacji React z react-i18next do Intlayer za pomocą adaptera kompatybilności."
+keywords:
+  - react-i18next
+  - i18next
+  - intlayer
+  - migracja
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - react-i18next
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Migracja z react-i18next do Intlayer
+
+Aby zapoznać się z kompletnym i szczegółowym samouczkiem krok po kroku, zapraszamy do naszego pełnego [Przewodnika migracji z react-i18next](../migration_from_react-i18next_to_intlayer.md).
+
+Korzystając z adaptera compat Intlayer możesz przeprowadzić migrację z `react-i18next` bez żadnych zmian importów kodu źródłowego.
+
+## Co zrobić
+
+Aby zainicjować projekt, uruchom:
+
+```bash
+npx intlayer init
+```
+
+Podczas inicjalizacji, Intlayer zainstaluje `@intlayer/react-i18next` i stworzy `intlayer.config.ts`. W swoim bundlerze (takim jak Vite), zastosuj wtyczkę Intlayer:
+
+```typescript fileName="vite.config.ts"
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+import { reactI18nextVitePlugin } from "@intlayer/react-i18next/plugin";
+
+export default defineConfig({
+  plugins: [react(), reactI18nextVitePlugin()],
+});
+```
+
+## Co się dzieje za kulisami
+
+Plugin `reactI18nextVitePlugin` opakuje podstawową wtyczkę `vite-intlayer` i wstrzykuje aliasy rozwiązania dla `react-i18next` i `i18next`, przekierowując je do `@intlayer/react-i18next` i `@intlayer/i18next`.
+
+Za kulisami:
+
+- **`useTranslation` & `withTranslation`:** Przepisane aby korzystać z natywnych hoków Intlayer, dając ci automatyczne uzupełnianie TypeScript dla kluczy słownika. Bezproblemowo obsługuje przestrzenie nazw (np. `t('namespace:key')`).
+- **Liczba mnoga i kontekst:** Obsługuje sufiks-bazowaną pluralizację i18next (`key_one`, `key_other`) używając natywnego `Intl.PluralRules` i sufiksów kontekstu (`key_male`).
+- **Komponent `<Trans>`:** Ponownie wdrożony aby obsługiwać prop `components`, formy obiektu i tablic, i numerowane tagi `<1>...</1>` bezpośrednio mapujące do węzłów React.
+- **Instancja `i18n`:** Rozwiązuje klucze bezpośrednio ze słowników Intlayer bez pobierania dużych plików JSON, powodując znacznie mniejsze rozmiary bundle.

package/docs/pl/compat/react-intl.md

@@ -0,0 +1,55 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migracja z React Intl do Intlayer"
+description: "Dowiedz się, jak przeprowadzić migrację aplikacji React z react-intl do Intlayer za pomocą adaptera kompatybilności."
+keywords:
+  - react-intl
+  - formatjs
+  - intlayer
+  - migracja
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - react-intl
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Migracja z React Intl do Intlayer
+
+Jeśli aplikacja React używa `react-intl` (FormatJS), przejście do Intlayer jest proste. Nasza warstwa compat bezproblemowo obsługuje ICU MessageFormat i wszystkie istniejące komponenty `Formatted*`.
+
+## Co zrobić
+
+Zacznij uruchamiając polecenie inicjalizacji w swoim projekcie:
+
+```bash
+npx intlayer init
+```
+
+Następnie, ustaw wtyczkę Vite lub Next.js Intlayer w konfiguracji. Ta wtyczka wstrzykuje aliasy czasu budowania aby przekierować importy `react-intl` do `@intlayer/react-intl`.
+
+```typescript fileName="vite.config.ts"
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+import reactIntlVitePlugin from "@intlayer/react-intl/plugin";
+
+export default defineConfig({
+  plugins: [react(), reactIntlVitePlugin()],
+});
+```
+
+## Co się dzieje za kulisami
+
+Wtyczka bundlera aliasuje `react-intl` do `@intlayer/react-intl`. Zamiast ręcznego parsowania dużych plików JSON i opakowywania aplikacji w `IntlProvider`, wtyczka Intlayer statycznie wyodrębnia klucze i używa słowników Intlayer w czasie wykonywania.
+
+Za kulisami:
+
+- **ICU MessageFormat:** Intlayer używa `resolveMessage(..., 'icu')` resolver, który w pełni obsługuje pluralizację ICU, selekcję, formatowanie daty/liczb i tagi bogatego tekstu natywnie.
+- **Metoda i wywoływane JSX:** `intl.formatMessage({ id: 'a.b' })` i `<FormattedMessage id="a.b">` są identyfikowane przez wtyczki kompilera Intlayer (`@intlayer/babel` / `@intlayer/swc`), konwertując płaskie klucze punktowe tak aby pierwszy segment prawidłowo rozwiązywał klucz słownika Intlayer.
+- **Formatery:** `<FormattedNumber>`, `<FormattedDate>` itd., stanowią most do natywnego `core/formatters` używając `Intl`.