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

package/docs/cs/intlayer_with_vite+lit.md

@@ -79,28 +79,48 @@ S Intlayer můžete:
 
 Nainstalujte potřebné balíčky pomocí npm:
 
+```bash packageManager="npm"
+npx intlayer@canary init --interactive    # v9
+# npx intlayer init                       # v8
+```
+
+```bash packageManager="pnpm"
+pnpm dlx intlayer@canary init --interactive   # v9
+# pnpm dlx intlayer init                      # v8
+```
+
+```bash packageManager="yarn"
+yarn dlx intlayer@canary init --interactive   # v9
+# yarn dlx intlayer init                      # v8
+```
+
+```bash packageManager="bun"
+bunx intlayer@canary init --interactive   # v9
+# bunx intlayer init                      # v8
+```
+
+> příznak `--interactive` je volitelný. Pokud jste AI agent, použijte `intlayer-cli init`.
+
+> Tento příkaz detekuje vaše prostředí a nainstaluje potřebné balíčky. Například:
+
 ```bash packageManager="npm"
 npm install intlayer lit-intlayer
 npm install vite-intlayer --save-dev
-npx intlayer init
 ```
 
 ```bash packageManager="pnpm"
 pnpm add intlayer lit-intlayer
 pnpm add vite-intlayer --save-dev
-pnpm intlayer init
 ```
 
 ```bash packageManager="yarn"
 yarn add intlayer lit-intlayer
 yarn add vite-intlayer --save-dev
-yarn intlayer init
 ```
 
 ```bash packageManager="bun"
 bun add intlayer lit-intlayer
 bun add vite-intlayer --dev
-bun x intlayer init
 ```
 
 - **intlayer**
@@ -151,7 +171,13 @@ import { intlayer } from "vite-intlayer";
 
 // https://vitejs.dev/config/
 export default defineConfig({
-  plugins: [intlayer()],
+  plugins: [
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
+  ],
 });
 ```
 
@@ -420,7 +446,7 @@ Nejprve přidejte `intlayerProxy` do své konfigurace Vite:
 
 ```typescript {3,7} fileName="vite.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
 import { defineConfig } from "vite";
-import { intlayer, intlayerProxy } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 export default defineConfig({
   plugins: [intlayer(), intlayerProxy()],

package/docs/cs/intlayer_with_vite+vanilla.md

@@ -80,28 +80,48 @@ S Intlayer můžete:
 
 Nainstalujte potřebné balíčky pomocí npm:
 
+```bash packageManager="npm"
+npx intlayer@canary init --interactive    # v9
+# npx intlayer init                       # v8
+```
+
+```bash packageManager="pnpm"
+pnpm dlx intlayer@canary init --interactive   # v9
+# pnpm dlx intlayer init                      # v8
+```
+
+```bash packageManager="yarn"
+yarn dlx intlayer@canary init --interactive   # v9
+# yarn dlx intlayer init                      # v8
+```
+
+```bash packageManager="bun"
+bunx intlayer@canary init --interactive   # v9
+# bunx intlayer init                      # v8
+```
+
+> příznak `--interactive` je volitelný. Pokud jste AI agent, použijte `intlayer-cli init`.
+
+> Tento příkaz detekuje vaše prostředí a nainstaluje potřebné balíčky. Například:
+
 ```bash packageManager="npm"
 npm install intlayer vanilla-intlayer
 npm install vite-intlayer --save-dev
-npx intlayer init
 ```
 
 ```bash packageManager="pnpm"
 pnpm add intlayer vanilla-intlayer
 pnpm add vite-intlayer --save-dev
-pnpm intlayer init
 ```
 
 ```bash packageManager="yarn"
 yarn add intlayer vanilla-intlayer
 yarn add vite-intlayer --save-dev
-yarn intlayer init
 ```
 
 ```bash packageManager="bun"
 bun add intlayer vanilla-intlayer
 bun add vite-intlayer --dev
-bun x intlayer init
 ```
 
 - **intlayer**
@@ -151,7 +171,13 @@ import { intlayer } from "vite-intlayer";
 
 // https://vitejs.dev/config/
 export default defineConfig({
-  plugins: [intlayer()],
+  plugins: [
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
+  ],
 });
 ```
 
@@ -412,12 +438,15 @@ Nejprve přidejte `intlayerProxy` do konfigurace Vite:
 
 ```typescript {3,7} fileName="vite.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
 import { defineConfig } from "vite";
-import { intlayer, intlayerProxy } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 export default defineConfig({
   plugins: [
-    intlayerProxy(), // mělo by být umístěno jako první
-    intlayer(),
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
   ],
 });
 ```
@@ -549,6 +578,8 @@ bun x intlayer extract
  </Tab>
  <Tab value='Babel kompilátor'>
 
+> Since v9, the `intlayerCompiler` is included in the `intlayer` plugin. So you don't need to add it manually.
+
 Aktualizujte svůj `vite.config.ts` a zahrňte plugin `intlayerCompiler`:
 
 ```ts fileName="vite.config.ts"
@@ -558,7 +589,7 @@ import { intlayer, intlayerCompiler } from "vite-intlayer";
 export default defineConfig({
   plugins: [
     intlayer(),
-    intlayerCompiler(), // Přidá kompilátor plugin
+    intlayerCompiler(), // Adds the compiler plugin
   ],
 });
 ```

package/docs/cs/packages/intlayer/comparePaths.md

@@ -0,0 +1,173 @@
+---
+createdAt: 2026-06-22
+updatedAt: 2026-06-22
+title: Dokumentace funkce comparePaths | intlayer
+description: Zjistěte, jak používat funkci comparePaths z balíčku intlayer
+keywords:
+  - comparePaths
+  - normalizePath
+  - aktivní odkaz
+  - navigace
+  - Intlayer
+  - intlayer
+  - Internacionalizace
+  - Dokumentace
+  - Next.js
+  - JavaScript
+  - React
+slugs:
+  - doc
+  - packages
+  - intlayer
+  - comparePaths
+history:
+  - version: 9.0.0
+    date: 2026-06-22
+    changes: "Úvodní dokumentace"
+author: aymericzip
+---
+
+# Dokumentace: Funkce `comparePaths` v `intlayer`
+
+## Popis
+
+Funkce `comparePaths` porovnává dvě URL adresy nebo cesty na shodu, přičemž ignoruje segment s jazykem (locale), protokol/hostitele, dotazovací řetězec (query string), hash a koncová lomítka (trailing slashes). Jde o doporučený způsob, jak zjistit, zda navigační odkaz ukazuje na aktuální stránku — například za účelem zvýraznění aktivního odkazu — aniž byste museli psát vlastní (často chybovou) normalizační logiku.
+
+Interně znovu využívá [`getPathWithoutLocale`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/cs/packages/intlayer/getPathWithoutLocale.md) k odstranění segmentu s jazykem, takže respektuje váš nastavený režim směrování a nakonfigurované jazyky.
+
+Balíček také exportuje základní pomocnou funkci [`normalizePath`](#normalizepath), která vrací kanonickou cestu nezávislou na jazyce, využívanou k samotnému porovnání.
+
+**Klíčové vlastnosti:**
+
+- Porovnání nezávislé na jazyce (`/cs/about` odpovídá `/about`)
+- Funguje s absolutními URL i s relativními cestami
+- Ignoruje dotazovací řetězce, hash a koncová lomítka
+- Toleruje chybějící úvodní lomítka a prázdné hodnoty (normalizuje je na `/`)
+- Odlehčená (lightweight) — postavena nad funkcí `getPathWithoutLocale`
+
+---
+
+## Signatura funkce
+
+```typescript
+comparePaths(
+  pathname: string,  // Povinné
+  href: string,      // Povinné
+  locales?: Locales[] // Volitelné
+): boolean
+
+normalizePath(
+  inputUrl: string,   // Povinné
+  locales?: Locales[] // Volitelné
+): string
+```
+
+---
+
+## Parametry
+
+- `pathname: string`
+  - **Popis**: První URL řetězec nebo cesta k porovnání (typicky aktuální cesta).
+  - **Typ**: `string`
+  - **Povinné**: Ano
+
+- `href: string`
+  - **Popis**: Druhý URL řetězec nebo cesta k porovnání (typicky `href` navigačního odkazu).
+  - **Typ**: `string`
+  - **Povinné**: Ano
+
+- `locales: Locales[]`
+  - **Popis**: Volitelné pole podporovaných jazyků. Výchozí jsou jazyky nakonfigurované v projektu.
+  - **Typ**: `Locales[]`
+  - **Povinné**: Ne (Volitelné)
+
+### Vrací
+
+- **Typ**: `boolean`
+- **Popis**: `true`, když se oba vstupy přeloží na stejnou cestu nezávislou na jazyce, jinak `false`.
+
+---
+
+## Příklady použití
+
+### Základní použití
+
+```typescript codeFormat={["typescript", "esm", "commonjs"]}
+import { comparePaths } from "intlayer";
+
+comparePaths("/ru/path", "/path"); // true
+comparePaths("/ru/path/", "/path"); // true
+comparePaths("/ru/path", "/path/"); // true
+comparePaths("/ru/", "/"); // true
+comparePaths("/ru", "/"); // true
+comparePaths("ru/path", "/path"); // true
+comparePaths("", "/"); // true
+comparePaths("/ru", ""); // true
+comparePaths("/ru/path", "/other"); // false
+```
+
+### Absolutní a relativní URL
+
+```typescript
+import { comparePaths } from "intlayer";
+
+comparePaths("https://example.com/ru/path", "/path"); // true
+```
+
+### Zvýraznění aktivního navigačního odkazu
+
+```tsx
+import { comparePaths } from "intlayer";
+import { useLocation } from "react-router";
+
+const NavLink = ({ href, children }) => {
+  const { pathname } = useLocation();
+  const isActive = comparePaths(pathname, href);
+
+  return (
+    <a href={href} aria-current={isActive ? "page" : undefined}>
+      {children}
+    </a>
+  );
+};
+```
+
+---
+
+## normalizePath
+
+Funkce `normalizePath` vrací kanonickou cestu nezávislou na jazyce, kterou využívá `comparePaths`. Odstraní segment jazyka, protokol/hostitele, dotazovací řetězec i hash, zajistí jedno úvodní lomítko, odstraní veškerá koncová lomítka (s výjimkou kořenové složky) a u prázdnných hodnot se vrátí na `/`.
+
+```typescript codeFormat={["typescript", "esm", "commonjs"]}
+import { normalizePath } from "intlayer";
+
+normalizePath("/ru/path"); // "/path"
+normalizePath("/ru/path/"); // "/path"
+normalizePath("ru/path"); // "/path"
+normalizePath("/ru/"); // "/"
+normalizePath("/ru"); // "/"
+normalizePath(""); // "/"
+normalizePath("https://example.com/ru/path"); // "/path"
+```
+
+---
+
+## Související funkce
+
+- [`getPathWithoutLocale`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/cs/packages/intlayer/getPathWithoutLocale.md): Odstraní segment jazyka z URL nebo cesty.
+- [`getPrefix`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/cs/packages/intlayer/getPrefix.md): Získá URL prefix pro daný jazyk (locale).
+- [`getLocalizedUrl`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/cs/packages/intlayer/getLocalizedUrl.md): Vygeneruje lokalizovanou URL pro konkrétní jazyk.
+
+---
+
+## TypeScript
+
+```typescript
+function normalizePath(inputUrl: string, locales?: Locales[]): string;
+
+function comparePaths(
+  pathname: string,
+  href: string,
+  locales?: Locales[]
+): boolean;
+```

package/docs/cs/releases/v9.md

@@ -0,0 +1,340 @@
+---
+createdAt: 2026-06-14
+updatedAt: 2026-06-30
+title: Nový Intlayer v9 - Co je nového?
+description: Zjistěte, co je nového v Intlayer v9. Představujeme drop-in balíčky kompatibility pro oblíbené i18n knihovny, podporu pro Kolekce a Varianty a vlastní hostování přes Docker Compose.
+keywords:
+  - Intlayer
+  - Compatibility
+  - Migration
+  - Collections
+  - Variants
+  - CMS SDK
+  - Self-Hosting
+  - Docker
+  - i18next
+  - next-intl
+  - vue-i18n
+slugs:
+  - doc
+  - releases
+  - v9
+author: aymericzip
+---
+
+# Nový Intlayer v9 - Co je nového?
+
+Vítejte v Intlayer v9! Toto hlavní vydání představuje obrovský milník ve zjednodušení migrace na Intlayer díky **balíčkům compat adaptérů** pro hlavní i18n knihovny (`react-i18next`, `next-intl`, `vue-i18n` atd.) a přidává podporu pro bohaté struktury obsahu: **Kolekce** a **Varianty**.
+
+## Obsah
+
+<TOC levels={[2]} maxDepth={1} />
+
+---
+
+## Balíčky compat adaptérů
+
+Migrace na Intlayer z oblíbených i18n knihoven je nyní snazší než kdykoli předtím. Vytvořili jsme pět balíčků kompatibility, které vystavují **přesně stejná veřejná API** jako standardní i18n knihovny, ale při běhu delegují veškerou překladovou práci na Intlayer.
+
+### Vystavení stejného veřejného API se striktním typováním
+
+Nahrazením importů získáte všechny výhody Intlayeru (včetně typové bezpečnosti v době kompilace vůči vašim skutečným slovníkům) s minimálními změnami kódu:
+
+- `@intlayer/i18next`
+- `@intlayer/react-i18next`
+- `@intlayer/next-intl`
+- `@intlayer/react-intl`
+- `@intlayer/next-i18next`
+- `@intlayer/vue-i18n`
+- `@intlayer/lingui`
+
+Jednoduše například změňte:
+
+```ts
+import { useTranslation } from "react-i18next";
+```
+
+na:
+
+```ts
+import { useTranslation } from "@intlayer/react-i18next";
+```
+
+Vaše klíče budou nyní **striktně typovány** vůči vašim Intlayer slovníkům a nabídnou plné automatické doplňování tečkových cest ve vašem IDE!
+
+### Pluginy pro aliasy bundlerů (Vite, Next.js, Turbopack)
+
+Aby bylo možné migrovat bez ručního přepisování všech importů, každý balíček compat adaptéru obsahuje **vlastní plugin pro bundler** (Vite nebo Next.js) pod subcestou `/plugin`.
+
+Tyto pluginy automaticky přepisují stávající importy (např. `react-i18next` nebo `next-intl`) na jejich ekvivalenty `@intlayer/*` v době sestavení.
+
+#### Příklad Next.js (Webpack / Turbopack)
+
+Místo `withIntlayer` zabalte konfiguraci Next.js pomocí pluginu kompatibility:
+
+```ts fileName="next.config.ts"
+import { createNextI18nPlugin } from "@intlayer/next-i18next/plugin";
+import type { NextConfig } from "next";
+
+const withIntlayer = createNextI18nPlugin();
+const nextConfig: NextConfig = {};
+
+export default withIntlayer(nextConfig);
+```
+
+#### Příklad Vite (React, Vue, Solid, Svelte)
+
+```ts fileName="vite.config.ts"
+import vueI18nVitePlugin from "@intlayer/vue-i18n/plugin";
+
+export default defineConfig({
+  plugins: [vueI18nVitePlugin()],
+});
+```
+
+---
+
+## Sdílený runtime resolver
+
+Všechny compat adaptéry nyní směrují rozlišení překladů přes jeden vysoce optimalizovaný runtime parser: `@intlayer/core/messageFormat`.
+
+- **Interpolace zpráv**: Zpracovává standardní `{{var}}` (bílé znaky a tečkové cesty), argumenty ve formátu ICU (`{v, number, percent}` atd.) a holé šablony `{var}`.
+- **Resolver uzlů zpráv**: Zpracovává vnořené uzly: `insert()`, `plural()` (pravidla CLDR pro množné číslo), `enu()` (výčet), `gender()`, HTML tagy, pole a volatelné funkční uzly.
+- **Tokenizovaný parser tagů**: Podporuje vložené XML/HTML tagy a číslované tagy (např. `<1>children</1>`) pro vykreslování formátovaného textu přímo z krabice.
+
+---
+
+## Specifikace funkcí: Kolekce a varianty
+
+Intlayer v9 jde za hranice statických objektů klíč–hodnota a umožňuje slovníkům deklarovat dynamické rozložení struktur, které jsou plně typovány end-to-end.
+
+### 1. Kolekce
+
+Definujte seznam seřazených položek spravovaných CMS (např. FAQ, produkty nebo seznamy blogů). Každá položka žije ve vlastním souboru `.content.ts` se stejným `key` a číslem `item`:
+
+```ts fileName="faq.1.content.ts"
+import { t, type Dictionary } from "intlayer";
+
+export default {
+  key: "faq",
+  item: 1,
+  content: {
+    question: t({ en: "What is Intlayer?", fr: "Qu'est-ce qu'Intlayer ?" }),
+    answer: t({ en: "An i18n toolkit.", fr: "Une boîte à outils i18n." }),
+  },
+} satisfies Dictionary;
+```
+
+```ts fileName="faq.2.content.ts"
+import { t, type Dictionary } from "intlayer";
+
+export default {
+  key: "faq",
+  item: 2,
+  content: {
+    question: t({ en: "Is it free?", fr: "Est-ce gratuit ?" }),
+    answer: t({ en: "Yes, open-source.", fr: "Oui, open-source." }),
+  },
+} satisfies Dictionary;
+```
+
+#### Použití:
+
+```ts
+// Načíst všechny položky jako pole
+const allFaqs = useIntlayer("faq"); // -> { question: string, answer: string }[]
+
+// Načíst jednu položku podle indexu
+const faq = useIntlayer("faq", { item: 2 }); // -> { question: string, answer: string }
+```
+
+### 2. Varianty
+
+Poskytujte A/B testy, sezónní záhlaví, příznaky funkcí nebo vlastní vstupní stránky:
+
+#### Textové varianty (např. A/B testování)
+
+```ts fileName="hero.content.ts"
+import { t, type Dictionary } from "intlayer";
+
+export default {
+  key: "hero-banner",
+  variant: "default",
+  content: {
+    control: t({ en: "Welcome", fr: "Bienvenue" }),
+    black_friday: t({ en: "Shop now", fr: "Acheter maintenant" }),
+  },
+} satisfies Dictionary;
+```
+
+#### Použití:
+
+```ts
+const banner = useIntlayer("hero-banner", { variant: "black_friday" });
+```
+
+#### Objektové varianty (např. Dynamické záznamy)
+
+```ts fileName="product.content.ts"
+import { t, type Dictionary } from "intlayer";
+
+export default {
+  key: "product-copy",
+  variant: {
+    id: "prod_123",
+    category: "books",
+  },
+  content: {
+    title: t({ en: "Clean Code", fr: "Code Propre" }),
+  },
+} satisfies Dictionary;
+```
+
+#### Použití:
+
+```ts
+// Načte pouze požadovaný záznam dynamicky (vyžaduje Suspense)
+const product = useIntlayer("product-copy", {
+  variant: { id: "prod_123", category: "books" },
+});
+```
+
+---
+
+## Vite plugin: zabudovaný kompilátor a proxy
+
+Plugin Vite `intlayer()` nyní přímo sdružuje **kompilátor** a **proxy pro směrování jazyků**, takže většina projektů potřebuje pouze jeden plugin v `vite.config.ts`:
+
+```ts fileName="vite.config.ts"
+import { defineConfig } from "vite";
+import { intlayer } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [intlayer()],
+});
+```
+
+- **Kompilátor**: Aktivuje se automaticky, když je `compiler.enabled` nastaveno na `true` a je nakonfigurována cesta `compiler.output`. `intlayerCompiler()` již není třeba registrovat samostatně.
+- **Proxy**: Aktivuje se automaticky na základě nové možnosti `routing.enableProxy` (výchozí hodnota `true`). Propojuje middleware pro detekci jazyka, přesměrování a přepisování ve vývoji, náhledu a produkčním SSR. `intlayerProxy()` již není třeba registrovat samostatně.
+
+### Možnost `routing.enableProxy`
+
+Nová možnost `routing.enableProxy` řídí, zda je proxy pro směrování jazyků zapojena. Výchozí hodnota je `true`. Vypněte ji, když chcete směrování jazyků zpracovávat sami:
+
+```ts fileName="intlayer.config.ts"
+import type { IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  routing: {
+    enableProxy: false, // Výchozí: true
+  },
+};
+
+export default config;
+```
+
+Samostatné pluginy `intlayerCompiler()` a `intlayerProxy()` zůstávají exportovány pro pokročilá nastavení. Jejich registrace společně s `intlayer()` je bezpečná — každý plugin se deduplikuje a spustí se pouze jednou.
+
+---
+
+## Kompilátor je ve výchozím nastavení zakázán
+
+Počínaje Intlayer v9 je **kompilátor ve výchozím nastavení zakázán** (`compiler.enabled` nyní výchozí hodnota je `false`). Chcete-li zapnout extrakci vašich souborů `.content.ts` v době sestavení, nastavte `compiler.enabled: true` ve své konfiguraci:
+
+```ts fileName="intlayer.config.ts"
+import type { IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  compiler: {
+    enabled: true, // Výchozí: false — vyžadováno pro povolení kompilátoru od v9
+    output: ({ fileName }) => `./${fileName}.content.ts`,
+  },
+};
+
+export default config;
+```
+
+Když je kompilátor zakázán, Intlayer přeskočí krok extrakce v době sestavení a spoléhá na vaše již deklarované slovníky. Povolte jej pouze tehdy, když chcete, aby plugin bundleru (`@intlayer/swc`, `@intlayer/babel` nebo plugin Vite `intlayer()`) automaticky extrahoval obsah.
+
+---
+
+## React Native: importy z jednoho balíčku
+
+V aplikaci React Native nebo Expo již nemusíte žonglovat s `react-intlayer` i `react-native-intlayer`. Balíček `react-native-intlayer` nyní **znovu exportuje celé API `react-intlayer`** (hooks, utility a subcesty `/format`, `/html` a `/markdown`) a jeho `IntlayerProvider` automaticky aplikuje polyfilly React Native.
+
+Importujte vše z jediného balíčku `react-native-intlayer`:
+
+```tsx
+import {
+  IntlayerProvider,
+  useIntlayer,
+  useLocale,
+} from "react-native-intlayer";
+```
+
+```bash
+npm install intlayer react-native-intlayer
+```
+
+> Import z `react-intlayer` nadále funguje, ale `react-native-intlayer` je nyní doporučeným jediným vstupním bodem pro React Native — jeho provider dodává polyfilly, které webově orientovaný provider `react-intlayer` nemá.
+
+---
+
+## CMS SDK: použijte Intlayer jako headless databázi obsahu
+
+Intlayer v9 dodává přehledné, automaticky autentizující SDK v `@intlayer/api` pro programatickou interakci s CMS — načítejte projekty, načítejte slovníky a odesílejte nebo aktualizujte je z vlastního serveru, skriptů nebo CI. Autentizace (OAuth2 `client_credentials`) je spravována a obnovována za vás.
+
+SDK je rozděleno do **dvou samostatných importů**, aby váš bundle obsahoval pouze domény, které skutečně používáte:
+
+1. `createIntlayerCMS` — lehký **autentizátor** uchovávající přihlašovací údaje a spravovaný token (žádný klientský bundle domény není součástí).
+2. `dictionaryEndpoint`, `projectEndpoint`, … — **binery endpointů** pro jednotlivé domény, každý importovaný z vlastní subcesty.
+
+```ts fileName="cms.ts"
+import { createIntlayerCMS } from "@intlayer/api";
+import { dictionaryEndpoint } from "@intlayer/api/dictionary";
+
+const cms = createIntlayerCMS();
+
+// Čtení
+const { data: dictionaries } = await dictionaryEndpoint(cms).getDictionaries();
+
+// Zápis — použijte CMS jako databázi
+await dictionaryEndpoint(cms).pushDictionaries([myDictionary]);
+```
+
+> Zabezpečení: přihlašovací údaje CMS udělují oprávnění k zápisu vašeho obsahu. Autentizátor vytvářejte vždy pouze **na straně serveru** — nikdy neodesílejte `clientId`/`clientSecret` do prohlížeče.
+
+---
+
+## Vlastní hostování
+
+Intlayer v9 poskytuje prvotřídní podporu pro provozování vlastní instance Intlayeru jediným příkazem — bez nutnosti účtu Intlayer Cloud.
+
+```sh
+curl -fsSL https://intlayer.org/install.sh | sh
+```
+
+Instalátor stáhne `docker-compose.yml` a `.env`, automaticky vygeneruje požadovaná tajemství a spustí `docker compose up -d`. Vše — dashboard, API, databáze, objektové úložiště a transakční e-mail — běží lokálně v kontejnerech.
+
+---
+
+## Poznámky k migraci z v8
+
+Pokud provádíte upgrade z v8, vezměte na vědomí, že v9 neobsahuje žádné zlomové změny. Zde jsou však klíčové změny:
+
+- **Kompilátor ve výchozím nastavení zakázán**: `compiler.enabled` nyní výchozí hodnota je `false`. Pokud se spoléháte na extrakci souborů `.content.ts` v době sestavení, nastavte `compiler.enabled: true` v `intlayer.config.ts`.
+- **Plugin Vite**: Kompilátor a proxy pro směrování jazyků jsou nyní součástí `intlayer()`. Pokud jste dříve ručně registrovali `intlayerCompiler()` nebo `intlayerProxy()`, můžete je odstranit — jsou automaticky deduplikovány, takže jejich ponechání je neškodné. Použijte `routing.enableProxy: false` pro vypnutí proxy.
+- **Jazyky a dialekty**: Pokud používáte externí závislosti i18n, přidejte příslušné compat adaptérové pluginy do vaší konfigurace nebo nastavení bundleru pro automatické přepisování importů.
+- **Vlastní selektory**: Při volání `useIntlayer` je druhý parametr nyní vyhrazen pro objekt možností obsahující `{ locale, item, variant }`. Pokud jste dříve předávali řetězec jazyka přímo, stále to lze, ale použití objektu možností je doporučeno pro pokročilé výběry.
+- **React Native**: `react-native-intlayer` nyní znovu exportuje celé API `react-intlayer`. V aplikaci React Native importujte vše z `react-native-intlayer` a odeberte přímou závislost na `react-intlayer`. Stávající importy z `react-intlayer` nadále fungují.
+
+---
+
+## Užitečné odkazy
+
+- [Průvodce balíčky compat adaptérů](https://github.com/aymericzip/intlayer/blob/main/docs/docs/cs/compat/index.md)
+- [Dynamické slovníky - Kolekce a varianty](https://github.com/aymericzip/intlayer/blob/main/docs/docs/cs/dynamic_dictionaries/index.md)
+- [Reference konfigurace](https://github.com/aymericzip/intlayer/blob/main/docs/docs/cs/configuration.md)
+- [Průvodce React Native a Expo](https://github.com/aymericzip/intlayer/blob/main/docs/docs/cs/intlayer_with_react_native+expo.md)
+- [CMS SDK - Programatický přístup s @intlayer/api](https://github.com/aymericzip/intlayer/blob/main/docs/docs/cs/intlayer_CMS.md)
+- [Průvodce vlastním hostováním](https://github.com/aymericzip/intlayer/blob/main/docs/docs/cs/self_hosting.md)