@intlayer/docs 9.5.6 → 9.5.7

package/docs/pl/dictionary/html.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2026-01-20
-updatedAt: 2026-03-24
+updatedAt: 2026-09-21
 title: Zawartość HTML
 description: Dowiedz się, jak deklarować i używać zawartości HTML z niestandardowymi komponentami w Intlayer. Postępuj zgodnie z tą dokumentacją, aby osadzić bogate, przypominające HTML treści z dynamiczną podmianą komponentów w swoim zlokalizowanym projekcie.
 keywords:
@@ -13,6 +13,8 @@ keywords:
   - React
   - Vue
   - Svelte
+  - Remix
+  - Astro
   - Solid
   - Angular
 slugs:
@@ -238,6 +240,83 @@ Kiedy uzyskujesz dostęp do treści za pomocą `useIntlayer`, węzły HTML są j
     ```
 
   </Tab>
+  <Tab label="Remix" value="remix">
+    W Remix 3 węzły HTML są rozwiązywane do ciągu znaków HTML. Wstrzyknij go za pomocą właściwości `innerHTML` w Remix JSX lub za pomocą `html.raw` w widoku `html-template`.
+
+    ```tsx fileName="src/views/home.tsx"
+    import { useIntlayer } from "remix-intlayer";
+
+    export const HomePage = () => () => {
+      const { myHtmlContent } = useIntlayer("app");
+
+      return <div innerHTML={myHtmlContent.value} />;
+    };
+    ```
+
+    ```ts fileName="src/views/home.ts"
+    import { html } from "remix/html-template";
+    import { useIntlayer } from "remix-intlayer";
+
+    export const renderHomePage = () => {
+      const { myHtmlContent } = useIntlayer("app");
+
+      return html.raw`<div>${myHtmlContent.value}</div>`;
+    };
+    ```
+
+    > Remix domyślnie eskapuje interpolowane wartości. `innerHTML` i `html.raw` to dwa wyjątki, które są potrzebne dla ciągu znaków HTML.
+
+    Użyj metody `.use()`, aby nadpisać znaczniki lub zmapować niestandardowe komponenty. Nadpisania to funkcje zwracające ciąg znaków HTML:
+
+    ```tsx
+    <div
+      innerHTML={myHtmlContent.use({
+        p: ({ children }) => `<p class="prose">${children}</p>`,
+        CustomLink: ({ children }) => `<a href="/details">${children}</a>`,
+      })}
+    />
+    ```
+
+  </Tab>
+  <Tab label="Astro" value="astro">
+    W Astro węzły HTML są rozwiązywane do ciągu znaków HTML. Wstrzyknij go za pomocą dyrektywy `set:html` w szablonie lub za pomocą `innerHTML` w tagu `<script>` klienta.
+
+    ```astro fileName="src/pages/index.astro"
+    ---
+    import { useIntlayer } from "astro-intlayer";
+
+    const { myHtmlContent } = useIntlayer("app");
+    ---
+
+    <div set:html={myHtmlContent.value} />
+    ```
+
+    ```astro fileName="src/components/Content.astro"
+    <div id="content"></div>
+
+    <script>
+      import { useIntlayer } from "astro-intlayer";
+
+      const { myHtmlContent } = useIntlayer("app");
+
+      document.querySelector("#content")!.innerHTML = myHtmlContent.value;
+    </script>
+    ```
+
+    > Astro domyślnie eskapuje `{wyrażenia}`. `set:html` jest wyjątkiem, którego potrzebuje ciąg znaków HTML.
+
+    Użyj metody `.use()`, aby nadpisać znaczniki lub zmapować niestandardowe komponenty. Nadpisania to funkcje zwracające ciąg znaków HTML:
+
+    ```astro
+    <div
+      set:html={myHtmlContent.use({
+        p: ({ children }) => `<p class="prose">${children}</p>`,
+        CustomLink: ({ children }) => `<a href="/details">${children}</a>`,
+      })}
+    />
+    ```
+
+  </Tab>
 </Tabs>
 
 ## Konfiguracja globalna z `HTMLProvider`
@@ -473,6 +552,41 @@ Możesz skonfigurować renderowanie HTML globalnie dla całej aplikacji. To idea
     > Dynamiczne importowanie silnika renderującego HTML to dobry sposób na zmniejszenie rozmiaru paczki (bundle) Twojej aplikacji.
 
   </Tab>
+  <Tab label="Remix" value="remix">
+
+    Remix nie ma drzewa komponentów, które mogłoby pomieścić providera, więc konfiguracja jest instalowana raz, jako singleton, przy starcie serwera. Konfiguruje ona renderer zwracany przez `useHTMLRenderer()`. Węzły `html` zwracane przez `useIntlayer` są renderowane w obecnej postaci; nadpisuj ich znaczniki dla każdego węzła za pomocą `.use()`.
+
+    ```typescript fileName="src/router.ts"
+    import { installIntlayerHTML } from "remix-intlayer/html";
+
+    installIntlayerHTML({
+      renderHTML: (html) => html.replaceAll("<p>", '<p class="prose">'),
+    });
+    ```
+
+    > Użyj `installIntlayerHTMLDynamic(async () => …)`, aby załadować sam renderer leniwie; moduł ładujący uruchamia się tylko przy pierwszym wywołaniu.
+
+  </Tab>
+  <Tab label="Astro" value="astro">
+
+    Astro nie ma drzewa komponentów, które mogłoby pomieścić providera, więc konfiguracja jest instalowana raz, jako singleton, w middleware (serwer) oraz w tagu `<script>` klienta (przeglądarka). Konfiguruje ona renderer zwracany przez `useHTMLRenderer()`. Węzły `html` zwracane przez `useIntlayer` są renderowane w obecnej postaci; nadpisuj ich znaczniki dla każdego węzła za pomocą `.use()`.
+
+    ```typescript fileName="src/middleware.ts"
+    import { installIntlayerHTML } from "astro-intlayer/html";
+    import { defineMiddleware } from "astro:middleware";
+
+    // Uruchamia się raz przy starcie serwera; sam middleware Intlayer jest
+    // rejestrowany przez integrację przed tym plikiem.
+    installIntlayerHTML({
+      renderHTML: (html) => html.replaceAll("<p>", '<p class="prose">'),
+    });
+
+    export const onRequest = defineMiddleware((_context, next) => next());
+    ```
+
+    > Użyj `installIntlayerHTMLDynamic(async () => …)`, aby załadować sam renderer leniwie; moduł ładujący uruchamia się tylko przy pierwszym wywołaniu.
+
+  </Tab>
 </Tabs>
 
 ### Ręczne renderowanie i zaawansowane narzędzia
@@ -645,15 +759,69 @@ Jeśli musisz renderować surowe łańcuchy HTML lub potrzebujesz większej kont
     ```
 
   </Tab>
+  <Tab label="Remix" value="remix">
+    #### Hook `useHTMLRenderer()`
+
+    Uzyskaj funkcję renderującą wstępnie skonfigurowaną przez `installIntlayerHTML()`. Zwraca ona ciąg znaków HTML.
+
+    ```tsx
+    import { useHTMLRenderer } from "remix-intlayer/html";
+
+    const renderHTML = useHTMLRenderer();
+
+    return <div innerHTML={renderHTML("<p>Hello <strong>World</strong></p>")} />;
+    ```
+
+    #### Narzędzie `renderHTML()`
+
+    Autonomiczne narzędzie, które ignoruje globalną konfigurację.
+
+    ```tsx
+    import { renderHTML } from "remix-intlayer/html";
+
+    const html = renderHTML("<p>Hello</p>");
+    ```
+
+  </Tab>
+  <Tab label="Astro" value="astro">
+    #### Hook `useHTMLRenderer()`
+
+    Uzyskaj funkcję renderującą wstępnie skonfigurowaną przez `installIntlayerHTML()`. Zwraca ona ciąg znaków HTML.
+
+    ```astro
+    ---
+    import { useHTMLRenderer } from "astro-intlayer/html";
+
+    const renderHTML = useHTMLRenderer();
+    ---
+
+    <div set:html={renderHTML("<p>Hello <strong>World</strong></p>")} />
+    ```
+
+    #### Narzędzie `renderHTML()`
+
+    Autonomiczne narzędzie, które ignoruje globalną konfigurację.
+
+    ```astro
+    ---
+    import { renderHTML } from "astro-intlayer/html";
+
+    const html = renderHTML("<p>Hello</p>");
+    ---
+
+    <div set:html={html} />
+    ```
+
+  </Tab>
 </Tabs>
 
 ## Referencja opcji
 
 Te opcje mogą być przekazane do `HTMLProvider`, `HTMLRenderer`, `useHTMLRenderer` i `renderHTML`.
 
-| Opcja        | Typ                   | Domyślnie | Opis                                                                                                  |
-| :----------- | :-------------------- | :-------- | :---------------------------------------------------------------------------------------------------- |
-| `components` | `Record<string, any>` | `{}`      | Mapa tagów HTML lub niestandardowych nazw komponentów do odpowiadających im komponentów.              |
-| `renderHTML` | `Function`            | `null`    | Funkcja renderująca, która całkowicie zastąpi domyślny parser HTML (tylko dla providerów Vue/Svelte). |
+| Opcja        | Typ                   | Domyślnie | Opis                                                                                                        |
+| :----------- | :-------------------- | :-------- | :---------------------------------------------------------------------------------------------------------- |
+| `components` | `Record<string, any>` | `{}`      | Mapa tagów HTML lub niestandardowych nazw komponentów do odpowiadających im komponentów.                    |
+| `renderHTML` | `Function`            | `null`    | Funkcja renderująca, która całkowicie zastąpi domyślny parser HTML (providerzy Vue, Svelte, Remix i Astro). |
 
 > Uwaga: Dla React i Preact standardowe tagi HTML są dostarczane automatycznie. Prop `components` trzeba przekazać tylko wtedy, gdy chcesz je nadpisać lub dodać niestandardowe komponenty.

package/docs/pl/dictionary/markdown.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2025-02-07
-updatedAt: 2026-05-19
+updatedAt: 2026-09-21
 title: Markdown
 description: Dowiedz się, jak deklarować i używać treści Markdown na swojej wielojęzycznej stronie internetowej za pomocą Intlayer. Postępuj zgodnie z instrukcjami w tej dokumentacji online, aby bezproblemowo zintegrować Markdown ze swoim projektem.
 keywords:
@@ -11,6 +11,8 @@ keywords:
   - Next.js
   - JavaScript
   - React
+  - Remix
+  - Astro
 slugs:
   - doc
   - concept
@@ -487,6 +489,111 @@ Renderowanie Markdown obsługuje **MDX** — użyj dowolnego komponentu JSX/fram
     ```
 
   </Tab>
+  <Tab label="Remix" value="remix">
+    W Remix 3 węzły Markdown są renderowane na serwerze do ciągu znaków HTML. Wstrzyknij go za pomocą właściwości `innerHTML` w Remix JSX lub za pomocą `html.raw` w widoku `html-template`.
+
+    ```tsx fileName="src/views/home.tsx"
+    import { useIntlayer } from "remix-intlayer";
+
+    export const HomePage = () => () => {
+      const { myMarkdownContent } = useIntlayer("app");
+
+      return <div innerHTML={myMarkdownContent.value} />;
+    };
+    ```
+
+    ```ts fileName="src/views/home.ts"
+    import { html } from "remix/html-template";
+    import { useIntlayer } from "remix-intlayer";
+
+    export const renderHomePage = () => {
+      const { myMarkdownContent } = useIntlayer("app");
+
+      return html.raw`<div>${myMarkdownContent.value}</div>`;
+    };
+    ```
+
+    > Remix domyślnie eskapuje interpolowane wartości. `innerHTML` i `html.raw` to dwa wyjątki, które są potrzebne dla wyrenderowanego ciągu znaków Markdown.
+
+    Możesz także zapewnić lokalne nadpisania dla określonych znaczników za pomocą metody `.use()`. Nadpisania to funkcje zwracające ciąg znaków HTML:
+
+    ```tsx
+    <div
+      innerHTML={myMarkdownContent.use({
+        h1: ({ children }) => `<h1 class="text-3xl font-bold">${children}</h1>`,
+      })}
+    />
+    ```
+
+    `.value` to wyrenderowany ciąg HTML, podczas gdy `String()` / `.toString()` zwracają surowy kod źródłowy Markdown:
+
+    ```tsx
+    myMarkdownContent.value // "<h1>…</h1>"
+    String(myMarkdownContent) // "# …"
+    myMarkdownContent.toString() // "# …"
+    ```
+
+    I możesz uzyskać dostęp do metadanych markdown w następujący sposób:
+
+    ```tsx
+    myMarkdownContent.metadata
+    myMarkdownContent.metadata.title
+    ```
+
+  </Tab>
+  <Tab label="Astro" value="astro">
+    W Astro węzły Markdown są renderowane do ciągu znaków HTML. Wstrzyknij go za pomocą dyrektywy `set:html` w szablonie lub za pomocą `innerHTML` w tagu `<script>` klienta.
+
+    ```astro fileName="src/pages/index.astro"
+    ---
+    import { useIntlayer } from "astro-intlayer";
+
+    const { myMarkdownContent } = useIntlayer("app");
+    ---
+
+    <div set:html={myMarkdownContent.value} />
+    ```
+
+    ```astro fileName="src/components/Content.astro"
+    <div id="content"></div>
+
+    <script>
+      import { useIntlayer } from "astro-intlayer";
+
+      const { myMarkdownContent } = useIntlayer("app");
+
+      document.querySelector("#content")!.innerHTML = myMarkdownContent.value;
+    </script>
+    ```
+
+    > Astro domyślnie eskapuje `{wyrażenia}`. `set:html` jest wyjątkiem, którego potrzebuje wyrenderowany ciąg znaków Markdown.
+
+    Możesz także zapewnić lokalne nadpisania dla określonych znaczników za pomocą metody `.use()`. Nadpisania to funkcje zwracające ciąg znaków HTML:
+
+    ```astro
+    <div
+      set:html={myMarkdownContent.use({
+        h1: ({ children }) => `<h1 class="text-3xl font-bold">${children}</h1>`,
+      })}
+    />
+    ```
+
+    `.value` to wyrenderowany ciąg HTML, podczas gdy `String()` / `.toString()` zwracają surowy kod źródłowy Markdown:
+
+    ```astro
+    myMarkdownContent.value // "<h1>…</h1>"
+    String(myMarkdownContent) // "# …"
+    myMarkdownContent.toString() // "# …"
+    ```
+
+    I możesz uzyskać dostęp do metadanych markdown w następujący sposób:
+
+    ```astro
+    myMarkdownContent.metadata
+    myMarkdownContent.metadata.title
+    ```
+
+  </Tab>
 </Tabs>
 
 ### 2. Narzędzia pomocnicze (tylko ciągi znaków Markdown)
@@ -698,6 +805,60 @@ Te narzędzia renderują **tylko surowe ciągi znaków Markdown** i są niezale
     ```
 
   </Tab>
+  <Tab label="Remix" value="remix">
+    #### Hook `useMarkdownRenderer()`
+
+    Uzyskaj funkcję renderującą wstępnie skonfigurowaną przez `installIntlayerMarkdown()`. Zwraca ona ciąg znaków HTML.
+
+    ```tsx
+    import { useMarkdownRenderer } from "remix-intlayer/markdown";
+
+    const renderMarkdown = useMarkdownRenderer({ forceBlock: true });
+
+    return <div innerHTML={renderMarkdown("# My Title")} />;
+    ```
+
+    #### Narzędzie `renderMarkdown()`
+
+    Autonomiczne narzędzie, które ignoruje globalną konfigurację.
+
+    ```tsx
+    import { renderMarkdown } from "remix-intlayer/markdown";
+
+    const html = renderMarkdown("# My Title", { forceBlock: true });
+    ```
+
+  </Tab>
+  <Tab label="Astro" value="astro">
+    #### Hook `useMarkdownRenderer()`
+
+    Uzyskaj funkcję renderującą wstępnie skonfigurowaną przez `installIntlayerMarkdown()`. Zwraca ona ciąg znaków HTML.
+
+    ```astro
+    ---
+    import { useMarkdownRenderer } from "astro-intlayer/markdown";
+
+    const renderMarkdown = useMarkdownRenderer({ forceBlock: true });
+    ---
+
+    <div set:html={renderMarkdown("# My Title")} />
+    ```
+
+    #### Narzędzie `renderMarkdown()`
+
+    Autonomiczne narzędzie, które ignoruje globalną konfigurację.
+
+    ```astro
+    ---
+    import { renderMarkdown } from "astro-intlayer/markdown";
+
+    const html = renderMarkdown("# My Title", { forceBlock: true });
+    ---
+
+    <div set:html={html} />
+    ```
+
+  </Tab>
 </Tabs>
 
 ## Konfiguracja globalna z `MarkdownProvider`
@@ -997,6 +1158,73 @@ Te narzędzia renderują **tylko surowe ciągi znaków Markdown** i są niezale
     > Dynamiczne importowanie twojego renderera Markdown to świetny sposób na zmniejszenie rozmiaru pakietu twojej aplikacji.
 
   </Tab>
+  <Tab label="Remix" value="remix">
+
+    Remix nie ma drzewa komponentów, które mogłoby pomieścić providera, więc konfiguracja jest instalowana raz, jako singleton, przy starcie serwera. Konfiguruje ona renderer zwracany przez `useMarkdownRenderer()`. Węzły `md` zwracane przez `useIntlayer` są renderowane za pomocą domyślnego kompilatora; nadpisuj ich znaczniki dla każdego węzła za pomocą `.use()`.
+
+    ```typescript fileName="src/router.ts"
+    import { installIntlayerMarkdown } from "remix-intlayer/markdown";
+
+    installIntlayerMarkdown({
+      forceBlock: true,
+      components: {
+        h1: ({ children }) => `<h1 class="text-2xl font-bold">${children}</h1>`,
+      },
+    });
+    ```
+
+    Możesz także użyć własnego renderera markdown:
+
+    ```typescript fileName="src/router.ts"
+    import { installIntlayerMarkdown } from "remix-intlayer/markdown";
+
+    installIntlayerMarkdown({
+      renderMarkdown: async (md) => {
+        const { marked } = await import("marked");
+        return marked(md) as string;
+      },
+    });
+    ```
+
+    > Użyj `installIntlayerMarkdownDynamic(async () => …)`, aby załadować sam renderer leniwie; moduł ładujący uruchamia się tylko przy pierwszym wywołaniu.
+
+  </Tab>
+  <Tab label="Astro" value="astro">
+
+    Astro nie ma drzewa komponentów, które mogłoby pomieścić providera, więc konfiguracja jest instalowana raz, jako singleton, w middleware (serwer) oraz w tagu `<script>` klienta (przeglądarka). Konfiguruje ona renderer zwracany przez `useMarkdownRenderer()`. Węzły `md` zwracane przez `useIntlayer` są renderowane za pomocą domyślnego kompilatora; nadpisuj ich znaczniki dla każdego węzła za pomocą `.use()`.
+
+    ```typescript fileName="src/middleware.ts"
+    import { installIntlayerMarkdown } from "astro-intlayer/markdown";
+    import { defineMiddleware } from "astro:middleware";
+
+    // Uruchamia się raz przy starcie serwera; sam middleware Intlayer jest
+    // rejestrowany przez integrację przed tym plikiem.
+    installIntlayerMarkdown({
+      forceBlock: true,
+      components: {
+        h1: ({ children }) => `<h1 class="text-2xl font-bold">${children}</h1>`,
+      },
+    });
+
+    export const onRequest = defineMiddleware((_context, next) => next());
+    ```
+
+    Możesz także użyć własnego renderera markdown:
+
+    ```typescript fileName="src/middleware.ts"
+    import { installIntlayerMarkdown } from "astro-intlayer/markdown";
+
+    installIntlayerMarkdown({
+      renderMarkdown: async (md) => {
+        const { marked } = await import("marked");
+        return marked(md) as string;
+      },
+    });
+    ```
+
+    > Użyj `installIntlayerMarkdownDynamic(async () => …)`, aby załadować sam renderer leniwie; moduł ładujący uruchamia się tylko przy pierwszym wywołaniu.
+
+  </Tab>
 </Tabs>
 
 ## Suspense
@@ -1325,6 +1553,40 @@ Możesz użyć funkcji `parseMarkdown` z pakietu Intlayer swojego frameworka po
     ```
 
   </Tab>
+  <Tab label="Remix" value="remix">
+
+    Remix 3 renderuje na serwerze i strumieniuje HTML, więc żadne AST nie musi trafiać do klienta. Przetwórz raz i renderuj AST wszędzie tam, gdzie budowana jest strona:
+
+    ```tsx fileName="src/views/article.tsx"
+    import { parseMarkdown, renderMarkdown } from "remix-intlayer/markdown";
+
+    // 1. Przetwórz markdown na serializowalne AST (np. raz, podczas ładowania modułu)
+    const ast = parseMarkdown("## My title \n\nLorem Ipsum");
+
+    export const ArticlePage = () => () => (
+      // 2. Renderuj AST: renderer akceptuje surowy ciąg znaków lub przetworzone AST
+      <article innerHTML={renderMarkdown(ast)} />
+    );
+    ```
+
+  </Tab>
+  <Tab label="Astro" value="astro">
+
+    Strony Astro są renderowane na serwerze, więc żadne AST nie musi trafiać do klienta. Przetwórz Markdown w frontmatter i wyrenderuj go za pomocą `set:html`:
+
+    ```astro fileName="src/pages/article.astro"
+    ---
+    import { parseMarkdown, renderMarkdown } from "astro-intlayer/markdown";
+
+    // 1. Przetwórz markdown na serializowalne AST
+    const ast = parseMarkdown("## My title \n\nLorem Ipsum");
+    ---
+
+    <!-- 2. Renderuj AST: renderer akceptuje surowy ciąg znaków lub przetworzone AST -->
+    <article set:html={renderMarkdown(ast)} />
+    ```
+
+  </Tab>
 </Tabs>
 
 Ten wzorzec zapewnia, że logika parsowania Markdown jest wykonywana całkowicie na serwerze, co znacznie skraca czas wykonywania po stronie klienta i poprawia szybkość początkowej hydratacji.

package/docs/pl/intlayer_with_analog.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2025-04-18
-updatedAt: 2026-05-31
+updatedAt: 2026-09-21
 title: "Analog i18n - Kompletny przewodnik po tłumaczeniu swojej aplikacji"
 description: "Koniec z i18next. Przewodnik 2026 do budowania wielojęzycznej (i18n) aplikacji Analog. Tłumacz z agentami AI i optymalizuj rozmiar bundle, SEO i wydajność."
 keywords:
@@ -157,6 +157,28 @@ bun add intlayer angular-intlayer vite-intlayer
 </Step>
 <Step number={2} title="Konfiguracja projektu">
 
+### Architektura
+
+W tej architekturze `angular-intlayer` zapewnia `provideIntlayer()`, zarejestrowane w `src/app/app.config.ts`, dzięki czemu każdy komponent i strona oparta na plikach może odczytywać swoją zawartość za pomocą sygnału `useIntlayer`. Analog bazuje na Vite, więc wtyczka `intlayer()` z `vite-intlayer` jest dodawana obok `analog()` w `vite.config.ts`, aby śledzić i przebudowywać deklaracje zawartości oraz uruchamiać proxy locale. Deklaracje zawartości są umieszczane obok komponentów i stron w `src/app/`.
+
+```bash
+.
+├── src
+│   ├── app
+│   │   ├── pages
+│   │   │   └── index.page.ts         # File-based route using useIntlayer
+│   │   ├── app.config.ts             # Application config with provideIntlayer()
+│   │   ├── app.content.ts            # App content declaration
+│   │   └── locale-switcher.component.ts
+│   └── main.ts
+├── intlayer.config.ts
+├── package.json
+├── tsconfig.json
+└── vite.config.ts                    # analog() and intlayer() Vite plugins
+```
+
+### Konfiguracja
+
 Utwórz plik konfiguracyjny, aby skonfigurować języki swojej aplikacji:
 
 ```typescript fileName="intlayer.config.ts" codeFormat={["typescript", "esm", "commonjs"]}

package/docs/pl/intlayer_with_angular_19.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2025-04-18
-updatedAt: 2026-05-31
+updatedAt: 2026-09-21
 title: "Angular 19 i18n - Kompletny przewodnik po tłumaczeniu swojej aplikacji"
 description: "Koniec z i18next. Przewodnik 2026 do budowania wielojęzycznej (i18n) aplikacji Angular 19. Tłumacz z agentami AI i optymalizuj rozmiar bundle, SEO i wydajność."
 keywords:
@@ -164,6 +164,29 @@ bun add @angular-builders/custom-webpack --dev
 </Step>
 <Step number={2} title="Konfiguracja projektu">
 
+### Architektura
+
+W tej architekturze `angular-intlayer` zapewnia `provideIntlayer()`, zarejestrowane w `src/app/app.config.ts`, dzięki czemu każdy komponent może odczytywać swoją zawartość za pomocą sygnału `useIntlayer`. Angular CLI jest przełączany na niestandardowy builder Webpack, a `webpack.config.ts` łączy wtyczkę Intlayer w procesie budowania, aby śledzić i przebudowywać deklaracje zawartości. Deklaracje zawartości są umieszczane obok komponentów w `src/app/`.
+
+```bash
+.
+├── src
+│   ├── app
+│   │   ├── app.component.html        # Root template reading the content signal
+│   │   ├── app.component.ts          # Root component using useIntlayer
+│   │   ├── app.config.ts             # Application config with provideIntlayer()
+│   │   ├── app.content.ts            # App content declaration
+│   │   └── locale-switcher.component.ts
+│   └── main.ts
+├── angular.json                      # Custom Webpack builder for build and serve
+├── intlayer.config.ts
+├── package.json
+├── tsconfig.json
+└── webpack.config.ts                 # mergeConfig() from angular-intlayer/webpack
+```
+
+### Konfiguracja
+
 Utwórz plik konfiguracyjny, aby ustawić języki swojej aplikacji:
 
 ```typescript fileName="intlayer.config.ts" codeFormat={["typescript", "esm", "commonjs"]}

package/docs/pl/intlayer_with_angular_21.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2025-04-18
-updatedAt: 2026-05-31
+updatedAt: 2026-09-21
 title: "Angular 22 i18n - Kompletny przewodnik po tłumaczeniu swojej aplikacji"
 description: "Koniec z i18next. Przewodnik 2026 do budowania wielojęzycznej (i18n) aplikacji Angular 22. Tłumacz z agentami AI i optymalizuj rozmiar bundle, SEO i wydajność."
 keywords:
@@ -166,6 +166,29 @@ bun add @angular-builders/custom-esbuild --dev
 </Step>
 <Step number={2} title="Konfiguracja twojego projektu">
 
+### Architektura
+
+W tej architekturze `angular-intlayer` zapewnia `provideIntlayer()`, zarejestrowane w `src/app/app.config.ts`, dzięki czemu każdy komponent może odczytywać swoją zawartość za pomocą sygnału `useIntlayer`. Angular CLI jest przełączany na niestandardowy builder esbuild, a `esbuild.plugins.ts` rejestruje wtyczkę Intlayer w procesie budowania, aby śledzić i przebudowywać deklaracje zawartości. Deklaracje zawartości są umieszczane obok komponentów w `src/app/`.
+
+```bash
+.
+├── src
+│   ├── app
+│   │   ├── app.component.html        # Root template reading the content signal
+│   │   ├── app.component.ts          # Root component using useIntlayer
+│   │   ├── app.config.ts             # Application config with provideIntlayer()
+│   │   ├── app.content.ts            # App content declaration
+│   │   └── locale-switcher.component.ts
+│   └── main.ts
+├── angular.json                      # Custom esbuild builder for build and serve
+├── esbuild.plugins.ts                # intlayerEsbuildPlugin() from angular-intlayer/esbuild
+├── intlayer.config.ts
+├── package.json
+└── tsconfig.json
+```
+
+### Konfiguracja
+
 Utwórz plik konfiguracyjny, aby skonfigurować języki swojej aplikacji:
 
 ```typescript fileName="intlayer.config.ts" codeFormat={["typescript", "esm", "commonjs"]}

package/docs/pl/intlayer_with_astro.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2024-03-07
-updatedAt: 2026-09-20
+updatedAt: 2026-09-21
 title: "Astro i18n - Kompletny przewodnik po tłumaczeniu swojej aplikacji"
 description: "Koniec z i18next. Przewodnik 2026 do budowania wielojęzycznej (i18n) aplikacji Astro. Tłumacz z agentami AI i optymalizuj rozmiar bundle, SEO i wydajność."
 keywords:
@@ -160,6 +160,29 @@ bun add intlayer astro-intlayer
 </Step>
 <Step number={2} title="Skonfiguruj swój projekt">
 
+### Architektura
+
+W tej architekturze integracja `intlayer()` zarejestrowana w `astro.config.ts` buduje Twoje słowniki i dodaje middleware, który rozwiązuje locale każdego żądania i udostępnia je w `Astro.locals.intlayer`. Strony znajdują się w segmencie rest `src/pages/[...locale]/`, dzięki czemu domyślne locale jest serwowane bez prefiksu, a każde inne locale otrzymuje własny dedykowany adres URL. Pliki `.astro` odczytują zawartość za pomocą hooków `useIntlayer` / `useLocale` z `astro-intlayer`, a deklaracje zawartości są umieszczane obok Twoich komponentów w `src/`.
+
+```bash
+.
+├── src
+│   ├── app.content.tsx               # App content declaration
+│   ├── components
+│   │   └── LocaleSwitcher.astro      # Locale switcher component
+│   └── pages
+│       ├── [...locale]
+│       │   └── index.astro           # Localized page (rest param also serves the default locale)
+│       ├── robots.txt.ts             # robots.txt endpoint
+│       └── sitemap.xml.ts            # Localized sitemap endpoint
+├── astro.config.ts                   # Astro config with the intlayer() integration
+├── intlayer.config.ts
+├── package.json
+└── tsconfig.json
+```
+
+### Konfiguracja
+
 Utwórz plik konfiguracyjny, aby zdefiniować języki swojej aplikacji:
 
 ```typescript fileName="intlayer.config.ts"