@intlayer/docs 9.0.0-canary.2 → 9.0.0-canary.21

package/docs/pl/dictionary/translation.md

@@ -259,64 +259,3 @@ document.getElementById("welcome-message")!.textContent = String(
 
   </Tab>
 </Tabs>
-
-## Niestandardowe obiekty treści
-
-`intlayer` obsługuje niestandardowe obiekty treści do tłumaczenia, co pozwala na definiowanie bardziej złożonych struktur przy jednoczesnym zapewnieniu bezpieczeństwa typów. Oto przykład z niestandardowym obiektem:
-
-```typescript fileName="**/*.content.ts" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
-import { t, type Dictionary } from "intlayer";
-
-interface ICustomContent {
-  title: string;
-  content: string;
-}
-
-const customContent = {
-  key: "custom_content",
-  content: {
-    profileText: t<ICustomContent>({
-      en: {
-        title: "Page Title",
-        content: "Page Content",
-      },
-      fr: {
-        title: "Titre de la Page",
-        content: "Contenu de la Page",
-      },
-      es: {
-        title: "Título de la Página",
-        content: "Contenido de la Página",
-      },
-    }),
-  },
-} satisfies Dictionary;
-
-export default customContent;
-```
-
-```json fileName="**/*.content.json" contentDeclarationFormat="json"
-{
-  "$schema": "https://intlayer.org/schema.json",
-  "key": "custom_content",
-  "content": {
-    "profileText": {
-      "nodeType": "translation",
-      "translation": {
-        "en": {
-          "title": "Page Title",
-          "content": "Page Content"
-        },
-        "fr": {
-          "title": "Titre de la Page",
-          "content": "Contenu de la Page"
-        },
-        "es": {
-          "title": "Tytuł strony",
-          "content": "Zawartość strony"
-        }
-      }
-    }
-  }
-}
-```

package/docs/pl/dynamic_dictionaries/index.md

@@ -1,15 +1,14 @@
 ---
 createdAt: 2026-06-12
-updatedAt: 2026-06-12
-title: Słowniki Dynamiczne
-description: Omówienie trzech funkcji dynamicznych słowników w Intlayer — kolekcji, wariantów i rekordów dynamicznych — do budowania elastycznych, sterowanych w czasie wykonania treści i18n.
+updatedAt: 2026-06-26
+title: Słowniki dynamiczne
+description: Przegląd funkcji słowników dynamicznych Intlayer — kolekcji i wariantów — do tworzenia elastycznej, sterowanej w czasie wykonywania treści i18n.
 keywords:
-  - Słowniki Dynamiczne
+  - Słowniki dynamiczne
   - Kolekcje
   - Warianty
-  - Rekordy Dynamiczne
   - Intlayer
-  - Umiędzynarodowienie
+  - Internacjonalizacja
 slugs:
   - doc
   - concept
@@ -18,31 +17,38 @@ history:
   - version: 9.0.0
     date: 2026-06-12
     changes: "Wydanie funkcji słowników dynamicznych"
+  - version: 9.1.0
+    date: 2026-06-26
+    changes: "Scalono rekordy dynamiczne z wariantami — `variant` przyjmuje teraz ciąg znaków lub obiekt"
 author: aymericzip
 ---
 
-# Słowniki Dynamiczne
+# Słowniki dynamiczne
 
-Intlayer obsługuje trzy mechanizmy definiowania treści wykraczających poza pojedynczy, statyczny słownik na klucz. Każdy z nich jest deklarowany poprzez **pole metadanych najwyższego poziomu** w pliku zawartości; funkcja opakowująca (wrapper) nie jest wymagana.
+Intlayer obsługuje dwa mechanizmy wyrażania treści wykraczającej poza pojedynczy statyczny słownik na klucz. Każdy jest deklarowany przez **pole metadanych najwyższego poziomu** w pliku treści; nie jest potrzebna żadna funkcja opakowująca.
 
-| Funkcja                                                                                                                     | Pole metadanych   | Selektor w `useIntlayer` |
-| --------------------------------------------------------------------------------------------------------------------------- | ----------------- | ------------------------ |
-| [Kolekcje](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/dynamic_dictionaries/collections.md)               | `item: N`         | `{ item: N }`            |
-| [Warianty](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/dynamic_dictionaries/variants.md)                  | `variant: "name"` | `{ variant: "name" }`    |
-| [Rekordy Dynamiczne](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/dynamic_dictionaries/dynamic_content.md) | `meta: { id, … }` | `{ id, … }`              |
+| Funkcja                                                                                                       | Pole metadanych                          | Selektor w `useIntlayer`                         |
+| ------------------------------------------------------------------------------------------------------------- | ---------------------------------------- | ------------------------------------------------ |
+| [Kolekcje](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/dynamic_dictionaries/collections.md) | `item: N`                                | `{ item: N }`                                    |
+| [Warianty](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/dynamic_dictionaries/variants.md)    | `variant: "name"` _lub_ `variant: { … }` | `{ variant: "name" }` _lub_ `{ variant: { … } }` |
 
-Wszystkie trzy łączą się z argumentem lokalizacji i obsługują wybiórcze / leniwe ładowanie (lazy loading) za pomocą `importMode`.
+Oba łączą się z argumentem locale i obsługują selektywne / leniwe ładowanie przez `importMode`.
 
-## Kiedy używać którego rozwiązania
+## Kiedy czego używać
 
 - **Kolekcje** — uporządkowana lista elementów zarządzanych w osobnych plikach (wpisy FAQ, posty na blogu, produkty).
-- **Warianty** — nazwane alternatywy treści dla testów A/B, banerów sezonowych lub flag funkcji (feature flags).
-- **Rekordy dynamiczne** — treści pobierane w czasie wykonania za pomocą nieprzezroczystego identyfikatora ID (rekordy CMS, treści specyficzne dla użytkownika).
+- **Warianty** — nazwane lub strukturalne alternatywy treści:
+  - wariant **tekstowy** do testów A/B, banerów sezonowych lub feature flag;
+  - wariant **obiektowy** dla rekordów CMS, treści zależnej od użytkownika lub dowolnej treści adresowanej zestawem pól (dawne „rekordy dynamiczne").
 
-## Rozstrzyganie konfliktów selektorów
+> Wcześniejsze wersje udostępniały osobne pole `meta` dla treści indeksowanej rekordami. Zostało scalone z `variant`: przekaż do `variant` **obiekt** zamiast używać `meta`.
 
-Gdy słownik posiada wiele selektorów, kolejność ich rozstrzygania to:
+## Ujednoznacznianie selektora
+
+Klucz może deklarować obydwa wymiary jednocześnie (np. kolekcja, której elementy mają wariant). Są one rozwiązywane w kolejności:
 
 ```
-variant → meta → item
+variant → item
 ```
+
+Zatem `{ variant: "promo" }` dla klucza variant × item zwraca wszystkie elementy promo jako tablicę, a dodanie `{ item: 2 }` zawęża wynik do pojedynczego wpisu.

package/docs/pl/dynamic_dictionaries/variants.md

@@ -1,15 +1,17 @@
 ---
 createdAt: 2026-06-12
-updatedAt: 2026-06-12
+updatedAt: 2026-06-26
 title: Warianty
-description: Użyj pola metadanych variant w plikach zawartości Intlayer, aby deklarować nazwane alternatywne wersje treści (testy A/B, banery sezonowe, treści z flagami funkcji) i przełączać się między nimi w czasie wykonywania bez modyfikacji kodu.
+description: Użyj pola metadanych variant w plikach treści Intlayer, aby zadeklarować nazwane lub strukturalne alternatywy treści — testy A/B, banery sezonowe, teksty z feature flag, rekordy CMS, treść zależną od użytkownika — i przełączać się między nimi w czasie wykonywania bez zmian w kodzie.
 keywords:
   - Warianty
   - Testy A/B
-  - Flagi Funkcji
-  - Zawartość Dynamiczna
+  - Feature flagi
+  - Treść dynamiczna
+  - Rekordy dynamiczne
+  - CMS
   - Intlayer
-  - Umiędzynarodowienie
+  - Internacjonalizacja
 slugs:
   - doc
   - concept
@@ -17,17 +19,27 @@ slugs:
 history:
   - version: 9.0.0
     date: 2026-06-12
-    changes: "Wydanie funkcji wariantów słowników"
+    changes: "Wydanie funkcji wariantów"
+  - version: 9.1.0
+    date: 2026-06-26
+    changes: "`variant` przyjmuje teraz ciąg znaków lub obiekt — dawne `meta` / rekordy dynamiczne deklaruje się jako warianty obiektowe"
 author: aymericzip
 ---
 
 # Warianty
 
-**Wariant** (Variant) to zestaw plików zawartości, które współdzielą ten sam klucz słownika (`key`), ale każdy ma inną nazwę wariantu (`variant`). Intlayer serwuje odpowiedni plik na podstawie selektora przekazanego do `useIntlayer`.
+**Wariant** to zestaw plików treści, które dzielą ten sam klucz słownika (`key`), lecz każdy ma inną wartość `variant`. Intlayer udostępnia odpowiedni plik na podstawie selektora przekazanego do `useIntlayer`.
 
-## Deklarowanie wariantów
+Wartość `variant` może przyjmować **dwie formy**:
 
-Każdy plik reprezentuje jedną nazwaną alternatywę. Pominięcie klucza `variant` (lub ustawienie go na `"default"`) oznacza dany plik jako wariant domyślny (fallback).
+- **Ciąg znaków** — pojedyncza nazwana alternatywa (testy A/B, banery sezonowe, feature flagi).
+- **Obiekt** — strukturalny dyskryminator adresowany zestawem pól (rekordy CMS, treść zależna od użytkownika, dowolna treść z nieprzezroczystym ID jako kluczem). Tożsamością jest cały obiekt: selektor musi dostarczyć **równy** obiekt, aby rozwiązać wpis.
+
+> Forma obiektowa zastępuje dawne pole `meta`. Wszędzie, gdzie wcześniej pisałeś `meta: { id, … }`, napisz `variant: { id, … }` i wybierz ją przez `{ variant: { id, … } }`.
+
+## Warianty nazwane (tekstowe)
+
+Każdy plik reprezentuje jedną nazwaną alternatywę. Pominięcie `variant` (lub ustawienie na `"default"`) oznacza go jako domyślny.
 
 ```ts fileName="hero-banner.content.ts" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
 import { t, type Dictionary } from "intlayer";
@@ -65,9 +77,9 @@ const dictionary = {
 export default dictionary;
 ```
 
-## Używanie wariantów
+### Korzystanie z wariantów nazwanych
 
-### Wariant domyślny
+#### Wariant domyślny
 
 <Tabs group="framework">
   <Tab label="React" value="react">
@@ -209,7 +221,7 @@ export default dictionary;
   </Tab>
 </Tabs>
 
-### Nazwany wariant
+#### Wariant nazwany
 
 ```tsx
 const { headline, cta } = useIntlayer("hero-banner", {
@@ -217,18 +229,264 @@ const { headline, cta } = useIntlayer("hero-banner", {
 });
 ```
 
-### Nazwany wariant z jawnym wskazaniem lokalizacji
+#### Wariant nazwany z jawnym locale
 
 ```tsx
 const content = useIntlayer("hero-banner", {
   variant: "black_friday",
-  locale: "pl",
+  locale: "fr",
 });
 ```
 
+## Warianty obiektowe (strukturalne)
+
+Wariant obiektowy adresuje treść dowolnym zestawem par klucz-wartość zadeklarowanych w polu `variant` — co umożliwia modelowanie rekordów CMS, treści zależnej od użytkownika lub dowolnej treści z nieprzezroczystym ID jako kluczem. Tożsamością jest **cały obiekt**: selektor musi dostarczyć równy obiekt, aby wpis został rozwiązany.
+
+```ts fileName="product.abc.content.ts" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+import { t, type Dictionary } from "intlayer";
+
+const dictionary = {
+  key: "product",
+  variant: { id: "prod_abc", userId: "user_123" },
+  content: {
+    name: t({ en: "Widget Pro", fr: "Widget Pro" }),
+    description: t({ en: "The best widget.", fr: "Le meilleur widget." }),
+  },
+} satisfies Dictionary;
+
+export default dictionary;
+```
+
+```ts fileName="product.abcd.content.ts" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+import { t, type Dictionary } from "intlayer";
+
+const dictionary = {
+  key: "product",
+  variant: { id: "prod_abcd", userId: "user_123" },
+  content: {
+    name: t({ en: "Widget Lite", fr: "Widget Lite" }),
+    description: t({ en: "A lighter option.", fr: "Une option plus légère." }),
+  },
+} satisfies Dictionary;
+
+export default dictionary;
+```
+
+### Korzystanie z wariantów obiektowych
+
+Przekaż pasujący obiekt do `variant`. Każde pole zadeklarowane w słowniku musi zostać podane i być równe; w przeciwnym razie wynik to `null`. Kolejność pól nie ma znaczenia.
+
+<Tabs group="framework">
+  <Tab label="React" value="react">
+    ```tsx fileName="Product.tsx" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    import { useIntlayer } from "react-intlayer";
+
+    export const Product = ({
+      productId,
+      userId,
+    }: {
+      productId: string;
+      userId: string;
+    }) => {
+      const content = useIntlayer("product", {
+        variant: { id: productId, userId },
+      });
+
+      if (!content) return null;
+
+      return <p>{content.description}</p>;
+    };
+    ```
+
+  </Tab>
+  <Tab label="Next.js" value="nextjs">
+    ```tsx fileName="Product.tsx" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    import { useIntlayer } from "next-intlayer";
+
+    export const Product = ({
+      productId,
+      userId,
+    }: {
+      productId: string;
+      userId: string;
+    }) => {
+      const content = useIntlayer("product", {
+        variant: { id: productId, userId },
+      });
+
+      if (!content) return null;
+
+      return <p>{content.description}</p>;
+    };
+    ```
+
+  </Tab>
+  <Tab label="Vue" value="vue">
+    ```vue fileName="Product.vue" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    <script setup>
+    import { useIntlayer } from "vue-intlayer";
+
+    const props = defineProps({
+      productId: String,
+      userId: String,
+    });
+
+    const content = useIntlayer("product", {
+      variant: { id: props.productId, userId: props.userId },
+    });
+    </script>
+
+    <template>
+      <p v-if="content">{{ content.description }}</p>
+    </template>
+    ```
+
+  </Tab>
+  <Tab label="Svelte" value="svelte">
+    ```svelte fileName="Product.svelte" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    <script lang="ts">
+    import { useIntlayer } from "svelte-intlayer";
+
+    export let productId: string;
+    export let userId: string;
+
+    const content = useIntlayer("product", {
+      variant: { id: productId, userId },
+    });
+    </script>
+
+    {#if $content}
+      <p>{$content.description}</p>
+    {/if}
+    ```
+
+  </Tab>
+  <Tab label="Preact" value="preact">
+    ```tsx fileName="Product.tsx" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    import { useIntlayer } from "preact-intlayer";
+
+    export const Product = ({
+      productId,
+      userId,
+    }: {
+      productId: string;
+      userId: string;
+    }) => {
+      const content = useIntlayer("product", {
+        variant: { id: productId, userId },
+      });
+
+      if (!content) return null;
+
+      return <p>{content.description}</p>;
+    };
+    ```
+
+  </Tab>
+  <Tab label="Solid" value="solid">
+    ```tsx fileName="Product.tsx" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    import { useIntlayer } from "solid-intlayer";
+
+    export const Product = (props: {
+      productId: string;
+      userId: string;
+    }) => {
+      const content = useIntlayer("product", {
+        variant: { id: props.productId, userId: props.userId },
+      });
+
+      return (
+        <>
+          {content() && <p>{content().description}</p>}
+        </>
+      );
+    };
+    ```
+
+  </Tab>
+  <Tab label="Angular" value="angular">
+    ```typescript fileName="product.component.ts" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    import { Component, Input, OnInit } from "@angular/core";
+    import { useIntlayer } from "angular-intlayer";
+
+    @Component({
+      selector: "app-product",
+      template: `
+        @if (content()) {
+          <p>{{ content().description }}</p>
+        }
+      `,
+    })
+    export class ProductComponent implements OnInit {
+      @Input() productId!: string;
+      @Input() userId!: string;
+
+      content: any;
+
+      ngOnInit() {
+        this.content = useIntlayer("product", {
+          variant: { id: this.productId, userId: this.userId },
+        });
+      }
+    }
+    ```
+
+  </Tab>
+  <Tab label="Vanilla JS" value="vanilla">
+    ```javascript fileName="product.js"
+    import { useIntlayer } from "vanilla-intlayer";
+
+    const content = useIntlayer("product", {
+      variant: { id: "prod_abcd", userId: "user_123" },
+    });
+
+    if (content) {
+      document.body.innerHTML = `<p>${content.description}</p>`;
+    }
+    ```
+
+  </Tab>
+</Tabs>
+
+#### Z jawnym locale
+
+```tsx
+const content = useIntlayer("product", {
+  variant: { id: "prod_abc", userId: "user_123" },
+  locale: "fr",
+});
+```
+
+#### Brakujące pole — brak dopasowania
+
+```ts
+// Zwraca null: brakuje `userId`, więc obiekt nie pasuje do zadeklarowanego wariantu
+const content = useIntlayer("product", { variant: { id: "prod_abc" } });
+```
+
+## Tryb ładowania
+
+Warianty obiektowe są często ładowane leniwie. Ustaw `importMode` w słowniku, aby to kontrolować:
+
+```ts contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+const dictionary = {
+  key: "product",
+  importMode: "fetch", // or "dynamic"
+  variant: { id: "prod_abc", userId: "user_123" },
+  content: { … },
+} satisfies Dictionary;
+
+export default dictionary;
+```
+
+Zobacz [optymalizację bundla](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/bundle_optimization.md), aby poznać szczegóły trybów `static`, `dynamic` i `fetch`.
+
 ## Typowe przypadki użycia
 
-- Testy A/B kopii sterowane przez klucz eksperymentu
+- Testy A/B tekstu sterowane kluczem eksperymentu
 - Banery sezonowe lub promocyjne
-- Komunikaty powiązane z flagami funkcji (feature flags)
-- Lokalne kampanie marketingowe specyficzne dla danego obszaru
+- Komunikaty z feature flag
+- Kampanie marketingowe specyficzne dla locale
+- Teksty marketingowe per produkt zarządzane w CMS
+- Treść zależna od użytkownika lub konta
+- Dowolna treść adresowana nieprzezroczystym ID w czasie wykonywania

package/docs/pl/formatters.md

@@ -53,6 +53,8 @@ author: aymericzip
 
 Intlayer dostarcza zestaw lekkich helperów opartych na natywnych API `Intl`, oraz opakowanie `Intl` z pamięcią podręczną, które zapobiega wielokrotnemu tworzeniu ciężkich formatterów. Te narzędzia są w pełni świadome lokalizacji i mogą być używane z głównego pakietu `intlayer`.
 
+## React Formatters
+
 ### Import
 
 ```ts
@@ -80,6 +82,61 @@ import {
 
 Jeśli używasz React, dostępne są również hooki; zobacz `react-intlayer/format`.
 
+### Dostępne Hooks
+
+Wszystkie hooks automatycznie używają locale z `IntlayerProvider` lub `IntlayerServerProvider`.
+
+| Hook                | Opis                                     | Przykładowe wyjście           |
+| ------------------- | ---------------------------------------- | ----------------------------- |
+| `useNumber()`       | Formatuj liczby z grupowaniem            | `"123,456.789"`               |
+| `useCurrency()`     | Formatuj wartości waluty                 | `"€1,234.50"`                 |
+| `usePercentage()`   | Formatuj procenty                        | `"25%"`                       |
+| `useDate()`         | Formatuj daty i godziny                  | `"Aug 2, 2025"`               |
+| `useRelativeTime()` | Formatuj czas względny                   | `"in 3 days"`                 |
+| `useUnit()`         | Formatuj wartości z jednostkami          | `"5 kilometers"`              |
+| `useCompact()`      | Formatuj liczby w notacji zwartej        | `"1.2K"`                      |
+| `useList()`         | Formatuj tablice jako listy              | `"apple, banana, and orange"` |
+| `useIntl()`         | Pobierz obiekt `Intl` powiązany z locale | Pełny dostęp do API `Intl`    |
+
+### Pełny Przykład
+
+```tsx
+import {
+  useNumber,
+  useCurrency,
+  useDate,
+  usePercentage,
+  useCompact,
+  useList,
+  useRelativeTime,
+  useUnit,
+} from "react-intlayer/format";
+
+const MyComponent = () => {
+  const number = useNumber();
+  const currency = useCurrency();
+  const date = useDate();
+  const percentage = usePercentage();
+  const compact = useCompact();
+  const list = useList();
+  const relativeTime = useRelativeTime();
+  const unit = useUnit();
+
+  return (
+    <div>
+      <p>{number(123456.789)}</p>
+      <p>{currency(1234.5, { currency: "EUR" })}</p>
+      <p>{date(new Date(), "short")}</p>
+      <p>{percentage(0.25)}</p>
+      <p>{compact(1200)}</p>
+      <p>{list(["apple", "banana", "orange"])}</p>
+      <p>{relativeTime(new Date(), new Date(Date.now() + 86400000))}</p>
+      <p>{unit(5, { unit: "kilometer" })}</p>
+    </div>
+  );
+};
+```
+
 ## Buforowany Intl
 
 Eksportowany `Intl` to cienkie, buforowane opakowanie wokół globalnego `Intl`. Zapamiętuje instancje `NumberFormat`, `DateTimeFormat`, `RelativeTimeFormat`, `ListFormat`, `DisplayNames`, `Collator` oraz `PluralRules`, co zapobiega wielokrotnemu tworzeniu tego samego formattera.
@@ -134,6 +191,61 @@ const regionNames = new Intl.DisplayNames("fr", { type: "region" });
 regionNames.of("US"); // "États-Unis"
 ```
 
+### Dostępne Composables
+
+Wszystkie composables zwracają computed refs, które automatycznie używają locale'a z wstrzykniętego `IntlayerProvider`.
+
+| Composable          | Description                              | Example Output                |
+| ------------------- | ---------------------------------------- | ----------------------------- |
+| `useNumber()`       | Formatowanie liczb z grupowaniem         | `"123,456.789"`               |
+| `useCurrency()`     | Formatowanie wartości walut              | `"€1,234.50"`                 |
+| `usePercentage()`   | Formatowanie procentów                   | `"25%"`                       |
+| `useDate()`         | Formatowanie dat i czasów                | `"Aug 2, 2025"`               |
+| `useRelativeTime()` | Formatowanie czasu względnego            | `"in 3 days"`                 |
+| `useUnit()`         | Formatowanie wartości z jednostkami      | `"5 kilometers"`              |
+| `useCompact()`      | Formatowanie liczb w notacji zwartej     | `"1.2K"`                      |
+| `useList()`         | Formatowanie tablic jako listy           | `"apple, banana, and orange"` |
+| `useIntl()`         | Pobierz obiekt `Intl` powiązany z locale | Pełny dostęp do API `Intl`    |
+
+### Kompletny Przykład
+
+```vue
+<script setup>
+import {
+  useNumber,
+  useCurrency,
+  useDate,
+  usePercentage,
+  useCompact,
+  useList,
+  useRelativeTime,
+  useUnit,
+} from "vue-intlayer/format";
+
+const number = useNumber();
+const currency = useCurrency();
+const date = useDate();
+const percentage = usePercentage();
+const compact = useCompact();
+const list = useList();
+const relativeTime = useRelativeTime();
+const unit = useUnit();
+</script>
+
+<template>
+  <div>
+    <p>{{ number.value(123456.789) }}</p>
+    <p>{{ currency.value(1234.5, { currency: "EUR" }) }}</p>
+    <p>{{ date.value(new Date(), "short") }}</p>
+    <p>{{ percentage.value(0.25) }}</p>
+    <p>{{ compact.value(1200) }}</p>
+    <p>{{ list.value(["apple", "banana", "orange"]) }}</p>
+    <p>{{ relativeTime.value(new Date(), new Date(Date.now() + 86400000)) }}</p>
+    <p>{{ unit.value(5, { unit: "kilometer" }) }}</p>
+  </div>
+</template>
+```
+
 ### `Intl.Collator`
 
 Do porównywania i sortowania łańcuchów znaków z uwzględnieniem lokalizacji:
@@ -150,6 +262,10 @@ const words = ["äpfel", "zebra", "100", "20"];
 words.sort(collator.compare); // ["20", "100", "äpfel", "zebra"]
 ```
 
+## Vanilla JS / Node.js Formatters
+
+W kontekstach bez frameworka, importuj formatters bezpośrednio z `intlayer`. Pamiętaj, że musisz ręcznie przekazać locale.
+
 ### `Intl.PluralRules`
 
 Do określania form liczby mnogiej w różnych lokalizacjach:
@@ -303,6 +419,8 @@ const content = getTranslation(
 - **locale**: Docelowa lokalizacja (domyślnie skonfigurowana lokalizacja domyślna)
 - **fallback**: Czy użyć lokalizacji domyślnej jako zapasowej (domyślnie true)
 
+### Dodatkowe funkcje Intl
+
 ### `getIntlayer(dictionaryKey, locale?, plugins?)`
 
 Pobiera i transformuje treść ze słownika na podstawie klucza:
@@ -468,6 +586,8 @@ list(["red", "green", "blue"], { locale: "fr", type: "disjunction" }); // "rouge
 list([1, 2, 3], { type: "unit" }); // "1, 2, 3"
 ```
 
+## Narzędzia do obsługi zawartości
+
 ## Uwagi
 
 - Wszystkie helpery akceptują dane wejściowe typu `string`; są one wewnętrznie konwertowane na liczby lub daty.

package/docs/pl/how_works_intlayer.md

@@ -220,9 +220,9 @@ Pakiet `@intlayer/mcp` dostarcza serwer MCP (Model Context Protocol), który ofe
 
 Pakiety `@intlayer/dictionaries-entry`, `@intlayer/unmerged-dictionaries-entry` oraz `@intlayer/dynamic-dictionaries-entry` zwracają ścieżkę wejściową słowników Intlayer. Ponieważ przeszukiwanie systemu plików z poziomu przeglądarki jest niemożliwe, używanie bundlerów takich jak Webpack czy Rollup do pobrania ścieżki wejściowej słowników również nie jest możliwe. Te pakiety zostały zaprojektowane do aliasowania, co pozwala na optymalizację bundlowania w różnych bundlerach, takich jak Vite, Webpack i Turbopack.
 
-### @intlayer/chokidar
+### @intlayer/engine
 
-Pakiet `@intlayer/chokidar` służy do monitorowania plików z zawartością i regenerowania zmodyfikowanego słownika przy każdej zmianie.
+Pakiet `@intlayer/engine` służy do monitorowania plików z zawartością i regenerowania zmodyfikowanego słownika przy każdej zmianie.
 
 ### @intlayer/editor