@intlayer/docs 7.0.6 → 7.0.8-canary.0

package/docs/pl/dictionary/enumeration.md

@@ -0,0 +1,245 @@
+---
+createdAt: 2025-08-23
+updatedAt: 2025-08-23
+title: Enumeracja
+description: Odkryj, jak deklarować i używać enumeracji na swojej wielojęzycznej stronie internetowej. Postępuj zgodnie z krokami w tej dokumentacji online, aby skonfigurować swój projekt w kilka minut.
+keywords:
+  - Enumeracja
+  - Internacjonalizacja
+  - Dokumentacja
+  - Intlayer
+  - Next.js
+  - JavaScript
+  - React
+slugs:
+  - doc
+  - concept
+  - content
+  - enumeration
+history:
+  - version: 5.5.10
+    date: 2025-06-29
+    changes: Inicjalizacja historii
+---
+
+# Enumeracja / Pluralizacja
+
+## Jak działa enumeracja
+
+W Intlayer enumeracja jest realizowana za pomocą funkcji `enu`, która mapuje określone klucze na odpowiadające im treści. Klucze te mogą reprezentować wartości liczbowe, zakresy lub niestandardowe identyfikatory. W przypadku użycia z React Intlayer lub Next Intlayer odpowiednia treść jest automatycznie wybierana na podstawie lokalizacji aplikacji i zdefiniowanych reguł.
+
+## Konfiguracja enumeracji
+
+Aby skonfigurować enumerację w swoim projekcie Intlayer, musisz utworzyć moduł zawartości, który zawiera definicje enumeracji. Oto przykład prostej enumeracji dla liczby samochodów:
+
+```typescript fileName="**/*.content.ts" contentDeclarationFormat="typescript"
+import { enu, type Dictionary } from "intlayer";
+
+const carEnumeration = {
+  key: "car_count",
+  content: {
+    numberOfCar: enu({
+      "<-1": "Mniej niż minus jeden samochód",
+      "-1": "Minus jeden samochód",
+      "0": "Brak samochodów",
+      "1": "Jeden samochód",
+      ">5": "Kilka samochodów",
+      ">19": "Wiele samochodów",
+      "fallback": "Wartość domyślna", // Opcjonalne
+    }),
+  },
+} satisfies Dictionary;
+
+export default carEnumeration;
+```
+
+```javascript fileName="**/*.content.mjs" contentDeclarationFormat="esm"
+import { enu } from "intlayer";
+
+/** @type {import('intlayer').Dictionary} */
+const carEnumeration = {
+  key: "car_count",
+  content: {
+    numberOfCar: enu({
+      "<-1": "Mniej niż minus jeden samochód",
+      "-1": "Minus jeden samochód",
+      "0": "Brak samochodów",
+      "1": "Jeden samochód",
+      ">5": "Kilka samochodów",
+      ">19": "Wiele samochodów",
+      "fallback": "Wartość domyślna", // Opcjonalne
+    }),
+  },
+};
+
+export default carEnumeration;
+```
+
+```javascript fileName="**/*.content.cjs" contentDeclarationFormat="commonjs"
+const { enu } = require("intlayer");
+
+/** @type {import('intlayer').Dictionary} */
+const carEnumeration = {
+  key: "car_count",
+  content: {
+    numberOfCar: enu({
+      "<-1": "Mniej niż minus jeden samochód",
+      "-1": "Minus jeden samochód",
+      "0": "Brak samochodów",
+      "1": "Jeden samochód",
+      ">5": "Kilka samochodów",
+      ">19": "Wiele samochodów",
+      "fallback": "Wartość domyślna", // Opcjonalne
+    }),
+  },
+};
+
+module.exports = carEnumeration;
+```
+
+```json fileName="**/*.content.json" contentDeclarationFormat="json"
+{
+  "$schema": "https://intlayer.org/schema.json",
+  "key": "car_count",
+  "content": {
+    "numberOfCar": {
+      "nodeType": "enumeration",
+      "enumeration": {
+        "<-1": "Mniej niż minus jeden samochód",
+        "-1": "Minus jeden samochód",
+        "0": "Brak samochodów",
+        "1": "Jeden samochód",
+        ">5": "Kilka samochodów",
+        ">19": "Wiele samochodów",
+        "fallback": "Wartość domyślna" // Opcjonalne
+      }
+    }
+  }
+}
+```
+
+W tym przykładzie `enu` mapuje różne warunki na określoną treść. Gdy jest używany w komponencie React, Intlayer może automatycznie wybrać odpowiednią treść na podstawie podanej zmiennej.
+
+> Kolejność deklaracji jest ważna w enumeracjach Intlayer. Pierwsza prawidłowa deklaracja jest tą, która zostanie wybrana. Jeśli wiele warunków ma zastosowanie, upewnij się, że są one poprawnie uporządkowane, aby uniknąć nieoczekiwanego zachowania.
+
+> Jeśli nie zostanie zadeklarowana wartość domyślna (fallback), funkcja zwróci `undefined`, jeśli żaden klucz nie pasuje.
+
+## Używanie enumeracji z React Intlayer
+
+Aby użyć enumeracji w komponencie React, możesz skorzystać z hooka `useIntlayer` z pakietu `react-intlayer`. Ten hook pobiera odpowiednią treść na podstawie określonego ID. Oto przykład, jak go użyć:
+
+```tsx fileName="**/*.tsx" codeFormat="typescript"
+import type { FC } from "react";
+import { useIntlayer } from "react-intlayer";
+
+const CarComponent: FC = () => {
+  const { numberOfCar } = useIntlayer("car_count");
+
+  return (
+    <div>
+      <p>
+        {
+          numberOfCar(0) // Wynik: Brak samochodów
+        }
+      </p>
+      <p>
+        {
+          numberOfCar(6) // Wynik: Kilka samochodów
+        }
+      </p>
+      <p>
+        {
+          numberOfCar(20) // Wynik: Wiele samochodów
+        }
+      </p>
+      <p>
+        {
+          numberOfCar(0.01) // Wynik: Wartość domyślna
+        }
+      </p>
+    </div>
+  );
+};
+```
+
+```javascript fileName="**/*.mjx" codeFormat="esm"
+import { useIntlayer } from "react-intlayer";
+
+const CarComponent = () => {
+  const { numberOfCar } = useIntlayer("car_count");
+
+  return (
+    <div>
+      <p>
+        {
+          numberOfCar(0) // Wynik: Brak samochodów
+        }
+      </p>
+      <p>
+        {
+          numberOfCar(6) // Wynik: Kilka samochodów
+        }
+      </p>
+      <p>
+        {
+          numberOfCar(20) // Wynik: Wiele samochodów
+        }
+      </p>
+      <p>
+        {
+          numberOfCar(0.01) // Wynik: Wartość domyślna
+        }
+      </p>
+    </div>
+  );
+};
+
+export default CarComponent;
+```
+
+```javascript fileName="**/*.cjs" codeFormat="commonjs"
+const { useIntlayer } = require("react-intlayer");
+
+const CarComponent = () => {
+  const { numberOfCar } = useIntlayer("car_count");
+
+  return (
+    <div>
+      <p>
+        {
+          numberOfCar(0) // Wynik: Brak samochodów
+        }
+      </p>
+      <p>
+        {
+          numberOfCar(6) // Wynik: Kilka samochodów
+        }
+      </p>
+      <p>
+        {
+          numberOfCar(20) // Wynik: Wiele samochodów
+        }
+      </p>
+      <p>
+        {
+          numberOfCar(0.01) // Wynik: Wartość domyślna
+        }
+      </p>
+    </div>
+  );
+};
+
+module.exports = CarComponent;
+```
+
+W tym przykładzie komponent dynamicznie dostosowuje swój wynik w zależności od liczby samochodów. Poprawna treść jest wybierana automatycznie, w zależności od określonego zakresu.
+
+## Dodatkowe zasoby
+
+Aby uzyskać bardziej szczegółowe informacje na temat konfiguracji i użytkowania, zapoznaj się z następującymi zasobami:
+
+- [Dokumentacja Intlayer CLI](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/intlayer_cli.md)
+- [Dokumentacja React Intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/intlayer_with_create_react_app.md)
+- [Dokumentacja Next Intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/intlayer_with_nextjs_15.md)
+
+Te zasoby dostarczają dodatkowych informacji na temat konfiguracji i użycia Intlayer w różnych środowiskach oraz z różnymi frameworkami.

package/docs/pl/dictionary/file.md

@@ -0,0 +1,234 @@
+---
+createdAt: 2025-03-13
+updatedAt: 2025-06-29
+title: Plik
+description: Dowiedz się, jak osadzić zewnętrzne pliki w słowniku treści za pomocą funkcji `file`. Ta dokumentacja wyjaśnia, jak Intlayer dynamicznie łączy i zarządza zawartością plików.
+keywords:
+  - Plik
+  - Internacjonalizacja
+  - Dokumentacja
+  - Intlayer
+  - Next.js
+  - JavaScript
+  - React
+slugs:
+  - doc
+  - concept
+  - content
+  - file
+history:
+  - version: 5.5.10
+    date: 2025-06-29
+    changes: Inicjalizacja historii
+---
+
+# Zawartość pliku / Osadzanie plików w Intlayer
+
+W Intlayer funkcja `file` pozwala na osadzenie zawartości zewnętrznego pliku w słowniku. Takie podejście zapewnia, że Intlayer rozpoznaje plik źródłowy, umożliwiając płynną integrację z Intlayer Visual Editor i CMS.
+
+## Dlaczego używać `file` zamiast `import`, `require` lub `fs`?
+
+W przeciwieństwie do metod odczytu plików takich jak `import`, `require` czy `fs`, użycie `file` wiąże plik ze słownikiem, co pozwala Intlayer na śledzenie i dynamiczną aktualizację zawartości po edycji pliku. W efekcie użycie `file` zapewnia lepszą integrację z Intlayer Visual Editor i CMS.
+
+## Konfiguracja zawartości pliku
+
+Aby osadzić zawartość pliku w projekcie Intlayer, użyj funkcji `file` w module zawartości. Poniżej znajdują się przykłady różnych implementacji.
+
+```typescript fileName="**/*.content.ts" contentDeclarationFormat="typescript"
+import { file, type Dictionary } from "intlayer";
+
+const myFileContent = {
+  key: "my_key",
+  content: {
+    myFile: file("./path/to/file.txt"),
+  },
+} satisfies Dictionary;
+
+export default myFileContent;
+```
+
+```javascript fileName="**/*.content.mjs" contentDeclarationFormat="esm"
+import { file } from "intlayer";
+
+/** @type {import('intlayer').Dictionary} */
+// Typ słownika importowany z Intlayer
+const myFileContent = {
+  key: "my_key",
+  content: {
+    myFile: file("./path/to/file.txt"), // osadzenie pliku
+  },
+};
+
+export default myFileContent;
+```
+
+```javascript fileName="**/*.content.cjs" contentDeclarationFormat="commonjs"
+const { file } = require("intlayer");
+
+/** @type {import('intlayer').Dictionary} */
+// Typ słownika importowany z Intlayer
+const myFileContent = {
+  key: "my_key",
+  content: {
+    myFile: file("./path/to/file.txt"), // osadzenie pliku
+  },
+};
+
+module.exports = myFileContent;
+```
+
+```json5 fileName="**/*.content.json" contentDeclarationFormat="json"
+{
+  "$schema": "https://intlayer.org/schema.json",
+  "key": "my_key",
+  "content": {
+    "myFile": {
+      "nodeType": "file",
+      "value": "./path/to/file.txt",
+    },
+  },
+}
+```
+
+## Używanie zawartości pliku w React Intlayer
+
+Aby użyć osadzonej zawartości pliku w komponencie React, zaimportuj i użyj hooka `useIntlayer` z pakietu `react-intlayer`. Pozwala to na pobranie zawartości z określonego klucza i dynamiczne jej wyświetlenie.
+
+```tsx fileName="**/*.tsx" codeFormat="typescript"
+import type { FC } from "react";
+import { useIntlayer } from "react-intlayer";
+
+const FileComponent: FC = () => {
+  const { myFile } = useIntlayer("my_key");
+
+  return (
+    <div>
+      <pre>{myFile}</pre>
+    </div>
+  );
+};
+
+export default FileComponent;
+```
+
+```javascript fileName="**/*.mjx" codeFormat="esm"
+import { useIntlayer } from "react-intlayer";
+
+const FileComponent = () => {
+  const { myFile } = useIntlayer("my_key");
+
+  return (
+    <div>
+      <pre>{myFile}</pre>
+    </div>
+  );
+};
+
+export default FileComponent;
+```
+
+```javascript fileName="**/*.cjs" codeFormat="commonjs"
+const { useIntlayer } = require("react-intlayer");
+
+const FileComponent = () => {
+  const { myFile } = useIntlayer("my_key");
+
+  return (
+    <div>
+      <pre>{myFile}</pre>
+    </div>
+  );
+};
+
+module.exports = FileComponent;
+```
+
+## Przykład wielojęzycznego Markdown
+
+Aby obsługiwać wielojęzyczne edytowalne pliki Markdown, możesz użyć `file` w połączeniu z `t()` i `md()`, aby zdefiniować różne wersje językowe pliku z zawartością Markdown.
+
+```typescript fileName="**/*.content.ts" contentDeclarationFormat="typescript"
+import { file, t, md, type Dictionary } from "intlayer";
+
+const myMultilingualContent = {
+  key: "my_multilingual_key",
+  content: {
+    myContent: md(
+      t({
+        en: file("src/components/test.en.md"),
+        fr: file("src/components/test.fr.md"),
+        es: file("src/components/test.es.md"),
+      })
+    ),
+  },
+} satisfies Dictionary;
+
+export default myMultilingualContent;
+```
+
+```javascript fileName="**/*.content.mjs" contentDeclarationFormat="esm"
+import { file, t, md } from "intlayer";
+
+/** @type {import('intlayer').Dictionary} */
+const myMultilingualContent = {
+  key: "my_multilingual_key",
+  content: {
+    myContent: md(
+      t({
+        en: file("src/components/test.en.md"),
+        fr: file("src/components/test.fr.md"),
+        es: file("src/components/test.es.md"),
+      })
+    ),
+  },
+};
+
+export default myMultilingualContent;
+```
+
+```javascript fileName="**/*.content.cjs" contentDeclarationFormat="commonjs"
+const { file, t, md } = require("intlayer");
+
+const myMultilingualContent = {
+  key: "my_multilingual_key",
+  content: {
+    myContent: md(
+      t({
+        en: file("src/components/test.en.md"),
+        fr: file("src/components/test.fr.md"),
+        es: file("src/components/test.es.md"),
+      })
+    ),
+  },
+};
+```
+
+Ta konfiguracja pozwala na dynamiczne pobieranie zawartości w oparciu o preferencje językowe użytkownika. Gdy jest używana w Intlayer Visual Editor lub CMS, system rozpozna, że zawartość pochodzi z określonych plików Markdown i zapewni, że pozostaną one edytowalne.
+
+## Różne typy ścieżek
+
+Podczas używania funkcji `file` można stosować różne typy ścieżek do określenia pliku do osadzenia.
+
+- `file("./path/to/file.txt")` - Ścieżka względna względem bieżącego pliku
+- `file("path/to/file.txt")` - Ścieżka względna względem katalogu głównego projektu
+- `file("/users/username/path/to/file.txt")` - Ścieżka absolutna
+
+## Jak Intlayer obsługuje zawartość plików
+
+Funkcja `file` opiera się na module `fs` Node.js, aby odczytać zawartość określonego pliku i wstawić ją do słownika. Używana w połączeniu z Intlayer Visual Editor lub CMS, Intlayer może śledzić relację między słownikiem a plikiem. Pozwala to Intlayer na:
+
+- Rozpoznanie, że zawartość pochodzi z określonego pliku.
+- Automatyczną aktualizację zawartości słownika, gdy powiązany plik zostanie edytowany.
+- Zapewnić synchronizację między plikiem a słownikiem, zachowując integralność zawartości.
+
+## Dodatkowe zasoby
+
+Aby uzyskać więcej informacji na temat konfigurowania i używania osadzania plików w Intlayer, zapoznaj się z następującymi zasobami:
+
+- [Dokumentacja Intlayer CLI](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/intlayer_cli.md)
+- [Dokumentacja React Intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/intlayer_with_create_react_app.md)
+- [Dokumentacja Next Intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/intlayer_with_nextjs_15.md)
+- [Dokumentacja zawartości Markdown](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/dictionary/markdown.md)
+- [Dokumentacja zawartości tłumaczeń](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/dictionary/translation.md)
+
+Te zasoby dostarczają dodatkowych informacji na temat osadzania plików, zarządzania zawartością oraz integracji Intlayer z różnymi frameworkami.

package/docs/pl/dictionary/function_fetching.md

@@ -0,0 +1,214 @@
+---
+createdAt: 2025-08-23
+updatedAt: 2025-08-23
+title: Pobieranie funkcji
+description: Dowiedz się, jak deklarować i używać pobierania funkcji na swojej wielojęzycznej stronie internetowej. Postępuj zgodnie z krokami w tej dokumentacji online, aby skonfigurować swój projekt w kilka minut.
+keywords:
+  - Pobieranie funkcji
+  - Internacjonalizacja
+  - Dokumentacja
+  - Intlayer
+  - Next.js
+  - JavaScript
+  - React
+slugs:
+  - doc
+  - concept
+  - content
+  - function-fetching
+history:
+  - version: 5.5.10
+    date: 2025-06-29
+    changes: Inicjalizacja historii
+---
+
+# Pobieranie funkcji
+
+Intlayer pozwala na deklarowanie funkcji zawartości w Twoich modułach zawartości, które mogą być zarówno synchroniczne, jak i asynchroniczne. Podczas budowania aplikacji Intlayer wykonuje te funkcje, aby uzyskać wynik funkcji. Wartość zwracana musi być obiektem JSON lub prostą wartością, taką jak string lub liczba.
+
+> Uwaga: pobieranie funkcji jest obecnie niedostępne w deklaracjach zawartości JSON oraz w plikach zdalnych deklaracji zawartości.
+
+## Deklaracje funkcji
+
+Oto przykład prostej synchronicznej funkcji pobierającej zawartość:
+
+```typescript fileName="**/*.content.ts" contentDeclarationFormat="typescript"
+import type { Dictionary } from "intlayer";
+
+const functionContent = {
+  key: "function_content",
+  content: {
+    text: () => "To jest zawartość renderowana przez funkcję",
+  },
+} satisfies Dictionary;
+
+export default functionContent;
+```
+
+```javascript fileName="**/*.content.mjs" contentDeclarationFormat="esm"
+/** @type {import('intlayer').Dictionary} */
+const functionContent = {
+  key: "function_content",
+  content: {
+    text: () => "To jest zawartość renderowana przez funkcję",
+  },
+};
+
+export default functionContent;
+```
+
+```javascript fileName="**/*.content.cjs" contentDeclarationFormat="commonjs"
+/** @type {import('intlayer').Dictionary} */
+const functionContent = {
+  key: "function_content",
+  content: {
+    text: () => "To jest zawartość renderowana przez funkcję",
+  },
+};
+
+module.exports = functionContent;
+```
+
+```json fileName="**/*.content.json" contentDeclarationFormat="json"
+{
+  "$schema": "https://intlayer.org/schema.json",
+  "key": "function_content",
+  "content": {
+    "text": "To jest zawartość renderowana przez funkcję"
+  }
+}
+```
+
+W tym przykładzie klucz `text` zawiera funkcję, która zwraca łańcuch znaków. Ta zawartość może być renderowana w Twoich komponentach React za pomocą pakietów interpretera Intlayer, takich jak `react-intlayer`.
+
+## Asynchroniczne pobieranie funkcji
+
+Oprócz funkcji synchronicznych, Intlayer obsługuje funkcje asynchroniczne, co pozwala na pobieranie danych z zewnętrznych źródeł lub symulowanie pobierania danych za pomocą danych testowych (mock).
+
+Poniżej znajduje się przykład funkcji asynchronicznej, która symuluje pobieranie z serwera:
+
+```typescript fileName="**/*.content.ts" contentDeclarationFormat="typescript"
+import { setTimeout } from "node:timers/promises";
+import type { Dictionary } from "intlayer";
+
+const fakeFetch = async (): Promise<string> => {
+  // Poczekaj 200ms, aby zasymulować pobieranie z serwera
+  return await setTimeout(200).then(
+    () => "To jest zawartość pobrana z serwera"
+  );
+};
+
+const asyncFunctionContent = {
+  key: "async_function",
+  content: { text: fakeFetch },
+} satisfies Dictionary;
+
+export default asyncFunctionContent;
+```
+
+```javascript fileName="**/*.content.mjs" contentDeclarationFormat="esm"
+import { setTimeout } from "node:timers/promises";
+
+/** @type {import('intlayer').Dictionary} */
+const fakeFetch = async () => {
+  // Poczekaj 200ms, aby zasymulować pobieranie z serwera
+  await setTimeout(200);
+  return "To jest zawartość pobrana z serwera";
+};
+
+const asyncFunctionContent = {
+  key: "async_function",
+  content: { text: fakeFetch },
+};
+
+export default asyncFunctionContent;
+```
+
+```javascript fileName="**/*.content.cjs" contentDeclarationFormat="commonjs"
+const { setTimeout } = require("node:timers/promises");
+
+/** @type {import('intlayer').Dictionary} */
+const fakeFetch = async () => {
+  // Poczekaj 200ms, aby zasymulować pobieranie z serwera
+  await setTimeout(200);
+  return "To jest zawartość pobrana z serwera";
+};
+
+const asyncFunctionContent = {
+  key: "async_function",
+  content: { text: fakeFetch },
+};
+
+module.exports = asyncFunctionContent;
+```
+
+```plaintext fileName="**/*.content.json" contentDeclarationFormat="json"
+Brak możliwości pobrania zawartości z pliku JSON, użyj zamiast tego pliku .ts lub .js
+```
+
+W tym przypadku funkcja `fakeFetch` naśladuje opóźnienie, aby zasymulować czas odpowiedzi serwera. Intlayer wykonuje funkcję asynchroniczną i używa wyniku jako zawartości dla klucza `text`.
+
+## Używanie zawartości opartej na funkcjach w komponentach React
+
+Aby użyć zawartości opartej na funkcjach w komponencie React, musisz zaimportować `useIntlayer` z `react-intlayer` i wywołać ją z identyfikatorem zawartości, aby pobrać zawartość. Oto przykład:
+
+```typescript fileName="**/*.jsx" codeFormat="typescript"
+import type { FC } from "react";
+import { useIntlayer } from "react-intlayer";
+
+const MyComponent: FC = () => {
+  const functionContent = useIntlayer("function_content");
+  const asyncFunctionContent = useIntlayer("async_function_content");
+
+  return (
+    <div>
+      <p>{functionContent.text}</p>
+      {/* Wyjście: To jest zawartość renderowana przez funkcję */}
+      <p>{asyncFunctionContent.text}</p>
+      {/* Wyjście: To jest zawartość pobrana z serwera */}
+    </div>
+  );
+};
+
+export default MyComponent;
+```
+
+```javascript fileName="**/*.mjx" codeFormat="esm"
+import { useIntlayer } from "react-intlayer";
+
+const MyComponent = () => {
+  const functionContent = useIntlayer("function_content");
+  const asyncFunctionContent = useIntlayer("async_function_content");
+
+  return (
+    <div>
+      <p>{functionContent.text}</p>
+      {/* Wyjście: To jest zawartość renderowana przez funkcję */}
+      <p>{asyncFunctionContent.text}</p>
+      {/* Wyjście: To jest zawartość pobrana z serwera */}
+    </div>
+  );
+};
+
+export default MyComponent;
+```
+
+```javascript fileName="**/*.cjs" codeFormat="commonjs"
+const { useIntlayer } = require("react-intlayer");
+
+const MyComponent = () => {
+  const functionContent = useIntlayer("function_content");
+  const asyncFunctionContent = useIntlayer("async_function_content");
+
+  return (
+    <div>
+      <p>{functionContent.text}</p>
+      {/* Wyjście: To jest zawartość renderowana przez funkcję */}
+      <p>{asyncFunctionContent.text}</p>
+      {/* Wyjście: To jest zawartość pobrana z serwera */}
+    </div>
+  );
+};
+
+module.exports = MyComponent;
+```