@intlayer/docs 9.4.0-canary.0 → 9.4.0

package/docs/pl/intlayer_with_vite+vue.md

@@ -40,34 +40,51 @@ author: aymericzip
 
 W porównaniu do głównych rozwiązań, takich jak `vue-i18n` czy `i18next`, Intlayer jest rozwiązaniem wyposażonym w zintegrowane optymalizacje, takie jak:
 
+<AccordionGroup>
+
 **Pełne pokrycie Vue**
 
 Intlayer jest zoptymalizowany do doskonałej współpracy z Vue, oferując **zakres treści na poziomie komponentu**, **tłumaczenia reaktywne** i wszystkie funkcje potrzebne do skalowania internacjonalizacji (i18n).
 
 **Rozmiar bundle'a**
 
+<Accordion header="Rozmiar pakietu">
+
 Zamiast ładować ogromne pliki JSON na swoje strony, ładuj tylko niezbędną treść. Intlayer pomaga **zmniejszyć rozmiary bundle'a i stron nawet o 50%**.
 
+</Accordion>
+
 **Łatwość konserwacji**
 
 Określanie zakresu zawartości aplikacji **ułatwia konserwację** aplikacji na dużą skalę. Możesz powielić lub usunąć pojedynczy folder funkcji bez obciążania psychicznego koniecznością przeglądania całej bazy kodu zawartości. Dodatkowo Inlayer jest **w pełni napisany**, aby zapewnić dokładność treści.
 
 **Agent AI**
 
+<Accordion header="AI Agent">
+
 Wspólna lokalizacja treści **zmniejsza potrzebny kontekst** dzięki modelom dużego języka (LLM). Intlayer zawiera także zestaw narzędzi, taki jak **CLI** do sprawdzania brakujących tłumaczeń**[LSP](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/lsp.md)**, **[MCP](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/mcp_server.md)** i **[agent skills](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/agent_skills.md)**, aby praca programisty (DX) była jeszcze płynniejsza dla agentów AI.
 
+</Accordion>
+
 **Automatyzacja**
 
 Korzystaj z automatyzacji, aby tłumaczyć w swoim potoku CI/CD przy użyciu wybranego LLM na koszt dostawcy sztucznej inteligencji. Intlayer oferuje także **kompilator** do automatyzacji ekstrakcji treści, a także [platformę internetową] (https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/intlayer_CMS.md), która pomaga **tłumaczyć w tle**.
 
 **Wydajność**
 
+<Accordion header="Wydajność">
+
 Łączenie ogromnych plików JSON z komponentami może prowadzić do problemów z wydajnością i reaktywnością. Inlayer optymalizuje ładowanie treści w czasie kompilacji.
 
+</Accordion>
+
 **Skalowanie bez użycia dewelopera**
 
 Więcej niż tylko rozwiązanie i18n, Intlayer zapewnia **samodzielny [edytor wizualny](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/intlayer_visual_editor.md)** i **[pełny CMS](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/intlayer_CMS.md)**, który pomoże Ci zarządzać wielojęzyczną treścią w **w czasie rzeczywistym**, dzięki czemu współpraca z tłumaczami, copywriterami i innymi członkami zespołu będzie płynna. Treść może być przechowywana lokalnie i/lub zdalnie.
 
+</Accordion>
+</AccordionGroup>
+
 ---
 
 ## Przewodnik krok po kroku, jak skonfigurować Intlayer w aplikacji Vite i Vue
@@ -361,6 +378,8 @@ app.mount("#app");
 
 Uzyskaj dostęp do swoich słowników treści w całej aplikacji, tworząc główny komponent Vue i używając kompozycji `useIntlayer`:
 
+Uzyskaj dostęp do swoich słowników zawartości w całej aplikacji, tworząc główny komponent Vue i używając composables `useIntlayer`:
+
 ```vue fileName="src/HelloWord.vue"
 <script setup lang="ts">
 import { ref } from "vue";
@@ -412,6 +431,8 @@ const countRef = ref(0);
 </template>
 ```
 
+> Jeśli Twoja aplikacja już istnieje, możesz użyć [Intlayer Compiler](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/compiler.md), a także [polecenia extract](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/cli/extract.md), aby przekształcić tysiące komponentów w sekundę.
+
 #### Dostęp do treści w Intlayer
 
 Intlayer oferuje różne API do dostępu do Twojej treści:
@@ -430,8 +451,6 @@ Intlayer oferuje różne API do dostępu do Twojej treści:
   - Użyj `const content = useIntlayer("myContent");` oraz `{{ content.myContent }}` / `<content.myContent />`.
   - Lub użyj `const { myContent } = useIntlayer(\"myContent\");` oraz `{{ myContent }}` / `<myContent/>`, aby destrukturyzować zawartość.
 
-> Jeśli Twoja aplikacja już istnieje, możesz użyć [Intlayer Compiler](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/compiler.md) w połączeniu z [poleceniem extract](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/cli/extract.md), aby przekonwertować tysiące komponentów w jedną sekundę.
-
 </Step>
 
 <Step number={6} title="Zmień język swojej zawartości" isOptional={true}>
@@ -621,6 +640,8 @@ Równolegle możesz również użyć `intlayerProxy`, aby dodać routowanie po s
 
 > Zauważ, że aby używać `intlayerProxy` w produkcji, musisz przenieść pakiet `vite-intlayer` z `devDependencies` do `dependencies`.
 
+> Od wersji Intlayer v9, `intlayerProxy()` jest dołączony bezpośrednio do wtyczki `intlayer()` i domyślnie włączony przez opcję `routing.enableProxy` (`true` domyślnie). Rejestrowanie go osobno, jak pokazano poniżej, jest teraz opcjonalne — jest utrzymywane dla kompatybilności wstecznej i dla konfiguracji, które muszą kontrolować kolejność wtyczek. Ustaw `routing.enableProxy: false`, aby zrezygnować. Przeczytaj [notatki wydania v9](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/releases/v9.md).
+
 ```typescript {3,7} fileName="vite.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
 import { defineConfig } from "vite";
 import vue from "@vitejs/plugin-vue";
@@ -898,56 +919,6 @@ import RouterLink from "@components/RouterLink.vue";
 
 <Step number={11} title="Renderowanie Markdown" isOptional={true}>
 
-Intlayer obsługuje renderowanie zawartości Markdown bezpośrednio w Twojej aplikacji Vue. Domyślnie Markdown jest traktowany jako zwykły tekst. Aby przekształcić Markdown w bogaty HTML, możesz zintegrować [markdown-it](https://github.com/markdown-it/markdown-it), parser Markdown.
-
-Jest to szczególnie przydatne, gdy Twoje tłumaczenia zawierają sformatowaną zawartość, taką jak listy, linki czy wyróżnienia.
-
-Domyślnie Intlayer renderuje markdown jako ciąg znaków. Jednak Intlayer oferuje również sposób na renderowanie markdown do HTML za pomocą funkcji `installIntlayerMarkdown`.
-
-> Aby zobaczyć, jak deklarować zawartość markdown za pomocą pakietu `intlayer`, zobacz [dokumentację markdown](https://github.com/aymericzip/intlayer/tree/main/docs/pl/dictionary/markdown.md).
-
-```ts fileName="main.ts"
-import MarkdownIt from "markdown-it";
-import { createApp, h } from "vue";
-import { installIntlayer, installIntlayerMarkdown } from "vue-intlayer";
-
-const app = createApp(App);
-
-app.use(intlayer);
-
-const md = new MarkdownIt({
-  html: true, // zezwól na tagi HTML
-  linkify: true, // automatyczne linkowanie URL
-  typographer: true, // włącz inteligentne cudzysłowy, myślniki itp.
-});
-
-// Powiedz Intlayer, aby używał md.render() za każdym razem, gdy musi przekształcić markdown na HTML
-installIntlayerMarkdown(app, (markdown) => {
-  const html = md.render(markdown);
-  return h("div", { innerHTML: html });
-});
-```
-
-Po zarejestrowaniu możesz używać składni opartej na komponentach, aby bezpośrednio wyświetlać zawartość Markdown:
-
-```vue
-<template>
-  <div>
-    <myMarkdownContent />
-  </div>
-</template>
-
-<script setup lang="ts">
-import { useIntlayer } from "vue-intlayer";
-
-const { myMarkdownContent } = useIntlayer("my-component");
-</script>
-```
-
-</Step>
-
-<Step number={12} title="Wyodrębnij zawartość swoich komponentów" isOptional={true}>
-
 Jeśli masz istniejącą bazę kodu, transformacja tysięcy plików może być czasochłonna.
 
 Aby ułatwić ten proces, Intlayer proponuje [kompilator](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/compiler.md) / [ekstraktor](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/cli/extract.md), aby przetransformować komponenty i wyodrębnić zawartość.

package/docs/pl/migration_from_i18next_to_intlayer.md

@@ -98,10 +98,109 @@ Następujące kroki są minimalne wymagane aby uruchomić istniejącą aplikacj
 
 Zainstaluj pakiety rdzenia Intlayer i adapter compat:
 
+```bash packageManager="npm"
+npx intlayer init --interactive
+```
+
+```bash packageManager="pnpm"
+pnpm dlx intlayer@canary init --interactive
+```
+
+```bash packageManager="yarn"
+yarn dlx intlayer@canary init --interactive
+```
+
+```bash packageManager="bun"
+bunx intlayer@canary init --interactive
+```
+
+> flaga `--interactive` jest opcjonalna. Użyj `intlayer-cli init`, jeśli jesteś agentem AI.
+
+> To polecenie wykryje Twoje środowisko i zainstaluje wymagane pakiety. Na przykład:
+
+```bash packageManager="npm"
+npm install intlayer @intlayer/i18next @intlayer/sync-json-plugin
+```
+
+```bash packageManager="pnpm"
+pnpm add intlayer @intlayer/i18next @intlayer/sync-json-plugin
+```
+
+```bash packageManager="yarn"
+yarn add intlayer @intlayer/i18next @intlayer/sync-json-plugin
+```
+
+```bash packageManager="bun"
+bun add intlayer @intlayer/i18next @intlayer/sync-json-plugin
+```
+
+> Możesz zachować zainstalowany `i18next` — adapter kompatybilności używa go jako `devDependency` / `peerDependency` dla typów TypeScript.
+
+</Step>
+
+<Step number={2} title="Skonfiguruj Intlayer">
+
+Polecenie `intlayer init` tworzy starter `intlayer.config.ts`. Zaktualizuj go, aby odpowiadał Twoim istniejącym lokalizacjom i wskaż wtyczkę `syncJSON` na Twoje pliki komunikatów:
+
+```typescript fileName="intlayer.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
+import { Locales, type IntlayerConfig } from "intlayer";
+import { syncJSON } from "@intlayer/sync-json-plugin";
+
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [
+      Locales.ENGLISH,
+      Locales.FRENCH,
+      Locales.SPANISH,
+      // Dodaj tutaj wszystkie istniejące lokalizacje
+    ],
+    defaultLocale: Locales.ENGLISH,
+  },
+  plugins: [
+    syncJSON({
+      // pasuje do składni placeholdera i18next: {{name}}
+      format: "i18next",
+      source: ({ locale }) => `./src/locales/${locale}.json`,
+      location: "src/locales",
+    }),
+  ],
+};
+
+export default config;
+```
+
+> **`source`** mapuje locale na ścieżkę pliku JSON. **`location`** informuje watcher Intlayera, który folder monitorować pod kątem zmian. Opcja `format: 'i18next'` zapewnia, że placeholdery takie jak `{{name}}` są poprawnie parsowane.
+
+</Step>
+
+<Step number={3} title="Zaktualizuj aliasy bundlera (opcjonalnie)">
+
+Jeśli używasz bundlera (Vite, Webpack, esbuild), możesz wstrzyknąć alias modułu, aby `import ... from 'i18next'` automatycznie rozpoznawał `@intlayer/i18next`. To eliminuje potrzebę ręcznej zmiany jakichkolwiek importów w Twoim codebase.
+
+**Dla Vite:**
+
+```typescript fileName="vite.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
+import { defineConfig } from "vite";
+import i18nextVitePlugin from "@intlayer/i18next/plugin";
+
+export default defineConfig({
+  plugins: [i18nextVitePlugin()],
+});
+```
+
+> `i18nextVitePlugin()` opakowuje plugin `intlayer()` z `vite-intlayer` i dodaje
+> alias `i18next` → `@intlayer/i18next` dla Ciebie. Użycie zwykłego pluginu `intlayer()`
+> z `vite-intlayer` kompiluje słowniki, ale **nie** dodaje tego aliasu — musisz wtedy
+> ręcznie zmienić nazwy importów na `@intlayer/i18next` (zobacz następny krok).
+
 </Step>
 
 </Steps>
 
+To jest szybka migracja. Twoja aplikacja teraz działa na Intlayer, zachowując wszystkie `i18next` importy i API w niezmienionej formie.
+
+---
+
 ## Pełna migracja
 
 Poniższe kroki są opcjonalne i można je wykonywać stopniowo. Odblokowują one pełny zestaw funkcji Intlayer: edytor wizualny, CMS, pliki zawartości z typami, automatyczne tłumaczenie oparte na AI i wiele więcej.

package/docs/pl/migration_from_next-intl_to_intlayer.md

@@ -312,8 +312,6 @@ export default config;
 
 ---
 
-Zainstaluj pakiety rdzenia Intlayer i adapter compat `@intlayer/next-intl`:
-
 ## Co można usunąć po migracji
 
 Po wdrożeniu `@intlayer/next-intl` można usunąć następujący boilerplate `next-intl`:

package/docs/pl/migration_from_vue-i18n_to_intlayer.md

@@ -99,10 +99,133 @@ Następujące kroki są minimalne wymagane aby uruchomić istniejącą aplikacj
 
 Zainstaluj pakiety rdzenia Intlayer i adapter compat:
 
+```bash packageManager="npm"
+npx intlayer init --interactive
+```
+
+```bash packageManager="pnpm"
+pnpm dlx intlayer@canary init --interactive
+```
+
+```bash packageManager="yarn"
+yarn dlx intlayer@canary init --interactive
+```
+
+```bash packageManager="bun"
+bunx intlayer@canary init --interactive
+```
+
+> flaga `--interactive` jest opcjonalna. Użyj `intlayer-cli init`, jeśli jesteś agentem AI.
+
+> To polecenie wykryje Twoje środowisko i zainstaluje wymagane pakiety. Na przykład:
+
+```bash packageManager="npm"
+npm install intlayer vue-intlayer @intlayer/vue-i18n @intlayer/sync-json-plugin
+```
+
+```bash packageManager="pnpm"
+pnpm add intlayer vue-intlayer @intlayer/vue-i18n @intlayer/sync-json-plugin
+```
+
+```bash packageManager="yarn"
+yarn add intlayer vue-intlayer @intlayer/vue-i18n @intlayer/sync-json-plugin
+```
+
+```bash packageManager="bun"
+bun add intlayer vue-intlayer @intlayer/vue-i18n @intlayer/sync-json-plugin
+```
+
+> Możesz zachować `vue-i18n` zainstalowany — adapter kompatybilności używa go jako `devDependency` / `peerDependency` dla typów TypeScript.
+
+</Step>
+
+<Step number={2} title="Konfiguruj Intlayer">
+
+Polecenie `intlayer init` tworzy plik startowy `intlayer.config.ts`. Zaktualizuj go, aby pasował do twoich istniejących lokalizacji i wskaż wtyczkę `syncJSON` na twoje pliki wiadomości:
+
+```typescript fileName="intlayer.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
+import { Locales, type IntlayerConfig } from "intlayer";
+import { syncJSON } from "@intlayer/sync-json-plugin";
+
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [
+      Locales.ENGLISH,
+      Locales.FRENCH,
+      Locales.SPANISH,
+      // Dodaj wszystkie istniejące lokale tutaj
+    ],
+    defaultLocale: Locales.ENGLISH,
+  },
+  plugins: [
+    syncJSON({
+      // pasuje do składni placeholdera vue-i18n: {name}
+      format: "icu",
+      source: ({ locale }) => `./src/locales/${locale}.json`,
+      location: "src/locales",
+    }),
+  ],
+};
+
+export default config;
+```
+
+> **`source`** mapuje ustawienie regionalne na ścieżkę pliku JSON. **`location`** informuje obserwatora Intlayer, które foldery monitorować w poszukiwaniu zmian. Opcja `format: 'icu'` zapewnia, że symbole zastępcze są analizowane poprawnie dla `vue-i18n`.
+
+</Step>
+
+<Step number={3} title="Dodaj wtyczkę Intlayer do swojego bundlera">
+
+Zawiń istniejącą konfigurację bundlera za pomocą wtyczki compat. Komponuje core'owy plugin Intlayer, podłącza obserwację zawartości i — co krytyczne — **wstrzykuje alias modułu** tak aby istniejące wywołania `import … from 'vue-i18n'` były transparentnie przekierowywane do `@intlayer/vue-i18n` w czasie budowania. Nie są wymagane żadne zmiany plików źródłowych.
+
+**Dla Vite:**
+
+```typescript fileName="vite.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
+import { defineConfig } from "vite";
+import vue from "@vitejs/plugin-vue";
+import { vueI18nVitePlugin } from "@intlayer/vue-i18n/plugin";
+
+export default defineConfig({
+  plugins: [vue(), vueI18nVitePlugin()],
+});
+```
+
+> `vueI18nVitePlugin()` otacza plugin `intlayer()` z `vite-intlayer` i dodaje alias `vue-i18n`. Używając zwykłego pluginu `intlayer()` z `vite-intlayer`, kompiluje słowniki, ale **nie** dodaje aliasu — wtedy musisz ręcznie zmienić nazwy importów na `@intlayer/vue-i18n` (patrz Krok 4).
+
+**Dla Nuxt:**
+
+Jeśli używasz `@nuxtjs/i18n` (integracja Nuxt), zainstaluj `nuxt-intlayer` i dodaj go do swojego `nuxt.config.ts`:
+
+```bash packageManager="npm"
+npm install nuxt-intlayer
+```
+
+```typescript fileName="nuxt.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
+export default defineNuxtConfig({
+  modules: ["nuxt-intlayer"],
+  // Możesz bezpiecznie usunąć @nuxtjs/i18n ze swoich modułów
+});
+```
+
+> **Nie potrzebujesz już `createI18n()` ani ręcznego inicjowania providera.** Intlayer kompiluje wszystkie słowniki w **czasie buildowania**, więc nie ma kroku ładowania w runtime. Aliasowany provider obsługuje inicjalizację za Ciebie.
+
 </Step>
 
 </Steps>
 
+To koniec szybkiej migracji. Twoja aplikacja działa teraz na Intlayer, zachowując każdy import `vue-i18n` i API bez zmian.
+
+> **Wpisane klucze tłumaczeń — automatycznie.** Po skompilowaniu słowników przez Intlayer, `useI18n` jest typizowany względem rzeczywistej zawartości, gdy przekażesz opcję `namespace`. Klucze są autocompleted w twoim IDE, a nieprawidłowe ścieżki powodują błędy TypeScript w czasie budowania — nie jest wymagana żadna dodatkowa konfiguracja.
+>
+> ```ts
+> // 'about' to zarejestrowany klucz słownika
+> const { t } = useI18n({ namespace: "about" });
+> t("counter.label"); // ✓ autocompleted
+> t("does.not.exist"); // ✗ TypeScript error
+> ```
+
+---
+
 ## Pełna migracja
 
 Poniższe kroki są opcjonalne i mogą być wykonywane stopniowo. Odblokowują pełny zestaw funkcji Intlayer: edytor wizualny, CMS, pliki zawartości z typami, tłumaczenie wspierane przez AI i wiele więcej.

package/docs/pl/packages/elysia-intlayer/exports.md

@@ -0,0 +1,136 @@
+---
+createdAt: 2026-08-24
+updatedAt: 2026-08-24
+title: Dokumentacja pakietu elysia-intlayer
+description: Wtyczka Elysia dla Intlayer, zapewniająca funkcje tłumaczeń i wykrywanie locale.
+keywords:
+  - elysia-intlayer
+  - elysia
+  - plugin
+  - internationalization
+  - i18n
+slugs:
+  - doc
+  - packages
+  - elysia-intlayer
+  - exports
+history:
+  - version: 9.4.0
+    date: 2026-08-24
+    changes: "Ujednolicona dokumentacja dla wszystkich eksportów"
+author: aymericzip
+---
+
+# Pakiet elysia-intlayer
+
+Pakiet `elysia-intlayer` udostępnia wtyczkę dla aplikacji Elysia do obsługi internationalization (i18n). Wykrywa locale użytkownika i wstrzykuje obiekt `intlayer` do kontekstu route.
+
+## Instalacja
+
+```bash packageManager="npm"
+npm install intlayer elysia-intlayer
+```
+
+```bash packageManager="pnpm"
+pnpm add intlayer elysia-intlayer
+```
+
+```bash packageManager="yarn"
+yarn add intlayer elysia-intlayer
+```
+
+```bash packageManager="bun"
+bun add intlayer elysia-intlayer
+```
+
+> `elysia` jest peer dependency (`>=1.0.0`). Elysia jest przeznaczony dla runtime **Bun**.
+
+## Eksporty
+
+### Wtyczka
+
+Import:
+
+```ts
+import { intlayer } from "elysia-intlayer";
+```
+
+| Funkcja    | Opis                                                                                                                                                                                                                                                                                                                           | Powiązana dokumentacja                                                                                         |
+| ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------- |
+| `intlayer` | Wtyczka Elysia integrująca Intlayer z Twoją aplikacją Elysia. Obsługuje wykrywanie locale ze storage (cookies, headers), a następnie z `Accept-Language`, wstrzykuje obiekt `intlayer` udostępniający `locale`, `t`, `getIntlayer` i `getDictionary` do kontekstu route oraz konfiguruje kontekst żądania `AsyncLocalStorage`. | [intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/packages/elysia-intlayer/intlayer.md) |
+
+### Funkcje
+
+Import:
+
+```ts
+import { t, getIntlayer, getDictionary } from "elysia-intlayer";
+```
+
+| Funkcja         | Opis                                                                                                                                                                                                                                                                    | Powiązana dokumentacja                                                                                 |
+| --------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
+| `t`             | Globalna funkcja tłumaczenia pobierająca treść dla bieżącego locale w Elysia. Używa `AsyncLocalStorage`, aby uzyskać dostęp do kontekstu żądania skonfigurowanego przez wtyczkę `intlayer`, a poza nim wraca do domyślnego locale. Dostępna również przez `intlayer.t`. | [translation](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/dictionary/translation.md) |
+| `getIntlayer`   | Pobiera słownik po kluczu z wygenerowanej deklaracji i zwraca jego treść dla bieżącego locale. Zoptymalizowana wersja `getDictionary`. Używa `AsyncLocalStorage`, aby uzyskać dostęp do kontekstu żądania. Dostępna również przez `intlayer.getIntlayer`.               | -                                                                                                      |
+| `getDictionary` | Przetwarza obiekty słowników i zwraca treść dla bieżącego locale. Przetwarza tłumaczenia `t()`, enumeracje, markdown, HTML itd. Używa `AsyncLocalStorage`, aby uzyskać dostęp do kontekstu żądania. Dostępna również przez `intlayer.getDictionary`.                    | -                                                                                                      |
+
+### Typy
+
+Import:
+
+```ts
+import type { IntlayerContext, TranslateFunction } from "elysia-intlayer";
+```
+
+| Typ                 | Opis                                                                                                                                                                       |
+| ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `IntlayerContext`   | Kształt obiektu `intlayer` wstrzykiwanego do każdego kontekstu route: `locale`, `locale_storage`, `locale_detected`, `defaultLocale`, `t`, `getIntlayer`, `getDictionary`. |
+| `TranslateFunction` | Sygnatura funkcji tłumaczenia, przekształcającej locale map w treść odpowiadającą locale bieżącego żądania.                                                                |
+
+## Użycie
+
+```ts fileName="src/index.ts"
+import { Elysia } from "elysia";
+import { getDictionary, getIntlayer, intlayer, t } from "elysia-intlayer";
+import dictionaryExample from "./index.content";
+
+const app = new Elysia()
+  // Załaduj wtyczkę internacjonalizacji
+  .use(intlayer())
+  // Odczytaj locale i helpery z kontekstu trasy
+  .get("/", ({ intlayer }) => ({
+    locale: intlayer!.locale,
+    greeting: intlayer!.t({
+      pl: "Cześć",
+      en: "Hello",
+      fr: "Bonjour",
+      es: "Hola",
+    }),
+    content: intlayer!.getIntlayer("index").exampleOfContent,
+  }))
+  // Albo użyj samodzielnych helperów, powiązanych z bieżącym żądaniem
+  .get("/t_example", () =>
+    t({
+      pl: "Przykład zwróconej treści w języku polskim",
+      en: "Example of returned content in English",
+      fr: "Exemple de contenu renvoyé en français",
+      es: "Ejemplo de contenido devuelto en español",
+    })
+  )
+  .get("/getIntlayer_example", () => getIntlayer("index").exampleOfContent)
+  .get(
+    "/getDictionary_example",
+    () => getDictionary(dictionaryExample).exampleOfContent
+  )
+  .listen(3000);
+
+console.log(
+  `🦊 Elysia is running at ${app.server?.hostname}:${app.server?.port}`
+);
+```
+
+> Plugin rejestruje swój kontekst poprzez **globalny** `derive`, który Elysia typuje jako `Partial<{ intlayer: IntlayerContext }>`. W czasie działania wartość jest zawsze obecna dla tras zarejestrowanych po `.use(intlayer())`, dlatego użyj non-null assertion (`intlayer!.locale`) — lub optional chaining — aby zadowolić TypeScript w trybie `strict`.
+
+## Powiązana dokumentacja
+
+- [Elysia i18n - Kompletny przewodnik tłumaczenia aplikacji](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/intlayer_with_elysia.md)
+- [Konfiguracja](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/configuration.md)

package/docs/pl/packages/elysia-intlayer/intlayer.md

@@ -0,0 +1,139 @@
+---
+createdAt: 2026-08-24
+updatedAt: 2026-08-24
+title: Dokumentacja wtyczki intlayer dla Elysia | elysia-intlayer
+description: Zobacz, jak używać wtyczki intlayer z pakietu elysia-intlayer
+keywords:
+  - intlayer
+  - elysia
+  - plugin
+  - Intlayer
+  - Internacjonalizacja
+  - Dokumentacja
+slugs:
+  - doc
+  - packages
+  - elysia-intlayer
+  - intlayer
+history:
+  - version: 9.4.0
+    date: 2026-08-24
+    changes: "Inicjalizacja dokumentacji"
+author: aymericzip
+---
+
+# Dokumentacja wtyczki intlayer dla Elysia
+
+Wtyczka `intlayer` dla Elysia wykrywa locale użytkownika i wstrzykuje obiekt `intlayer` do kontekstu route. Umożliwia również użycie globalnych funkcji tłumaczeniowych w kontekście żądania.
+
+## Użycie
+
+```ts fileName="src/index.ts"
+import { Elysia } from "elysia";
+import { intlayer } from "elysia-intlayer";
+
+const app = new Elysia().use(intlayer()).get("/", ({ intlayer }) =>
+  intlayer!.t({
+    pl: "Cześć",
+    en: "Hello",
+    fr: "Bonjour",
+    es: "Hola",
+  })
+);
+```
+
+> Plugin rejestruje swój kontekst poprzez **globalny** `derive`, który Elysia typuje jako `Partial<{ intlayer: IntlayerContext }>`. W czasie działania wartość jest zawsze obecna dla tras zarejestrowanych po `.use(intlayer())`, dlatego użyj non-null assertion (`intlayer!.t`) — lub optional chaining — aby zadowolić TypeScript w trybie `strict`.
+
+Te same helpery są dostępne jako samodzielne eksporty, więc możesz je wywołać bez destrukturyzacji kontekstu route:
+
+```ts fileName="src/index.ts"
+import { Elysia } from "elysia";
+import { intlayer, t } from "elysia-intlayer";
+
+const app = new Elysia().use(intlayer()).get("/", () =>
+  t({
+    pl: "Cześć",
+    en: "Hello",
+    fr: "Bonjour",
+    es: "Hola",
+  })
+);
+```
+
+## Opis
+
+Wtyczka wykonuje następujące zadania:
+
+1. **Wykrywanie locale**: Odczytuje locale ustawione jawnie przez klienta ze storage (cookie, header), a następnie wraca do locale wynegocjowanego z nagłówka `Accept-Language`.
+2. **Wstrzyknięcie do kontekstu**: Dodaje właściwość `intlayer` do kontekstu trasy Elysia (zobacz tabelę Kontekst trasy poniżej).
+3. **Zarządzanie kontekstem**: Używa `AsyncLocalStorage` do zarządzania asynchronicznym kontekstem, dzięki czemu globalne funkcje Intlayer (`t`, `getIntlayer`, `getDictionary`) mają dostęp do locale specyficznego dla żądania bez przekazywania obiektu kontekstu.
+4. **Przygotowanie słowników**: Wywołuje `prepareIntlayer` przy tworzeniu pluginu, dzięki czemu słowniki są budowane przy starcie aplikacji.
+
+### Kontekst trasy
+
+| Właściwość        | Typ                    | Opis                                                                                                  |
+| ----------------- | ---------------------- | ----------------------------------------------------------------------------------------------------- |
+| `locale`          | `Locale`               | Locale używane dla tego żądania, przy czym `locale_storage` ma pierwszeństwo przed `locale_detected`. |
+| `locale_storage`  | `Locale` (opcjonalne)  | Locale zażądane jawnie przez klienta poprzez cookie lub header.                                       |
+| `locale_detected` | `Locale`               | Locale wynegocjowane z nagłówków żądania.                                                             |
+| `defaultLocale`   | `Locale`               | Locale skonfigurowane jako fallback w `intlayer.config.ts`.                                           |
+| `t`               | `TranslateFunction`    | Funkcja tłumaczenia.                                                                                  |
+| `getIntlayer`     | `typeof getIntlayer`   | Funkcja pobierająca słowniki po kluczu.                                                               |
+| `getDictionary`   | `typeof getDictionary` | Funkcja przetwarzająca obiekty słowników.                                                             |
+
+> W przeciwieństwie do wtyczek Intlayer opartych na Node, `elysia-intlayer` opiera się na `AsyncLocalStorage` zamiast `cls-hooked`, ponieważ `cls-hooked` zależy od `async_hooks.createHook`, którego Bun nie implementuje.
+
+Kontekst żądania jest zwalniany po zmapowaniu odpowiedzi, więc samodzielne helpery nigdy nie rozwiązują się względem już zakończonego żądania. Wywołane poza żądaniem obsługiwanym przez wtyczkę, wracają do skonfigurowanego domyślnego locale.
+
+## Kolejność rozwiązywania locale
+
+Domyślnie plugin rozwiązuje locale w następującej kolejności:
+
+1. Cookie `INTLAYER_LOCALE`.
+2. Nagłówek `x-intlayer-locale`.
+3. Negocjacja nagłówka `Accept-Language`.
+4. Skonfigurowany `defaultLocale`.
+
+```bash
+# Wynegocjowany z `Accept-Language`
+curl -H "Accept-Language: fr" http://localhost:3000/
+# Bonjour
+
+# Cookie ma pierwszeństwo przed `Accept-Language`
+curl -H "Accept-Language: fr" -H "Cookie: INTLAYER_LOCALE=es" http://localhost:3000/
+# Hola
+
+# Nagłówek ma pierwszeństwo przed `Accept-Language`
+curl -H "Accept-Language: fr" -H "x-intlayer-locale: es" http://localhost:3000/
+# Hola
+```
+
+## Konfiguracja
+
+Wtyczka odczytuje Twój plik `intlayer.config.ts`. Możesz dostosować cookie i header używane do wykrywania locale:
+
+```typescript fileName="intlayer.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
+import { Locales, type IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH, Locales.SPANISH],
+    defaultLocale: Locales.ENGLISH,
+  },
+  routing: {
+    storage: [
+      { type: "header", name: "my-locale-header" },
+      { type: "cookie", name: "my-locale-cookie" },
+    ],
+  },
+};
+
+export default config;
+```
+
+> Więcej informacji o konfiguracji znajdziesz w [dokumentacji konfiguracji](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/configuration.md).
+
+## Powiązana dokumentacja
+
+- [Dokumentacja pakietu elysia-intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/packages/elysia-intlayer/exports.md)
+- [Elysia i18n - Kompletny przewodnik tłumaczenia aplikacji](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/intlayer_with_elysia.md)