@intlayer/docs 9.1.1 → 9.1.2

package/docs/hi/dynamic_dictionaries/variants.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2026-06-12
-updatedAt: 2026-06-26
+updatedAt: 2026-08-04
 title: वैरिएंट
 description: नामित या संरचित सामग्री विकल्प — A/B परीक्षण, मौसमी बैनर, फ़ीचर-फ़्लैग टेक्स्ट, CMS रिकॉर्ड, उपयोगकर्ता-विशिष्ट सामग्री — घोषित करने और कोड बदले बिना रनटाइम पर उनके बीच स्विच करने के लिए Intlayer सामग्री फ़ाइलों में variant मेटाडेटा फ़ील्ड का उपयोग करें।
 keywords:
@@ -26,6 +26,9 @@ history:
   - version: 9.1.1
     date: 2026-07-31
     changes: "वेरिएंट केवल उन्हीं कुंजियों को घोषित करता है जिन्हें वह ओवरराइड करता है; अघोषित वेरिएंट डिफ़ॉल्ट प्रविष्टि पर वापस आ जाते हैं"
+  - version: 9.1.2
+    date: 2026-08-04
+    changes: "प्रोवाइडर एक परिवेशी `variant` प्रॉप स्वीकार करते हैं; सेलेक्टर एक क्रमित वरीयता शृंखला स्वीकार करते हैं"
 author: aymericzip
 ---
 
@@ -498,6 +501,176 @@ const content = useIntlayer("product", {
 const content = useIntlayer("product", { variant: { id: "prod_abc" } });
 ```
 
+## परिवेशी वैरिएंट
+
+कुछ वैरिएंट आयाम पूरे सत्र के लिए स्थिर रहते हैं — टेनेंट, विद्यालय का प्रकार, प्लान स्तर। ये एक ही बार हल होते हैं, और किसी भी कॉम्पोनेंट को इन्हें हाथ से पास नहीं करना चाहिए।
+
+> इन्हें इंजेक्ट करने के लिए `useIntlayer` को अपने हुक में न लपेटें। बिल्ड-टाइम अनुकूलन केवल फ्रेमवर्क पैकेज से आयातित शाब्दिक `useIntlayer("key")` कॉल को ही पुनर्लिखित करता है, इसलिए किसी रैपर के पीछे कुछ भी बंडल नहीं होता।
+
+इसके बजाय वैरिएंट को प्रोवाइडर पर एक ही बार घोषित करें, ठीक `locale` की तरह:
+
+<Tabs group="framework">
+  <Tab label="React" value="react">
+    ```tsx fileName="App.tsx" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    import { IntlayerProvider } from "react-intlayer";
+
+    export const App = ({ locale, schoolType }) => (
+      <IntlayerProvider locale={locale} variant={schoolType}>
+        <Hero />
+      </IntlayerProvider>
+    );
+    ```
+
+  </Tab>
+  <Tab label="Next.js" value="nextjs">
+    ```tsx fileName="layout.tsx" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    import { IntlayerServerProvider } from "next-intlayer/server";
+    import { IntlayerClientProvider } from "next-intlayer";
+
+    export default async function Layout({ children, params }) {
+      const { locale } = await params;
+      const schoolType = await getSchoolType();
+
+      return (
+        <IntlayerServerProvider locale={locale} variant={schoolType}>
+          <IntlayerClientProvider locale={locale} variant={schoolType}>
+            {children}
+          </IntlayerClientProvider>
+        </IntlayerServerProvider>
+      );
+    }
+    ```
+
+  </Tab>
+  <Tab label="Vue" value="vue">
+    ```ts fileName="main.ts" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    import { createApp } from "vue";
+    import { installIntlayer } from "vue-intlayer";
+    import App from "./App.vue";
+
+    const app = createApp(App);
+
+    installIntlayer(app, { locale: "en", variant: schoolType });
+
+    app.mount("#app");
+    ```
+
+  </Tab>
+  <Tab label="Svelte" value="svelte">
+    ```svelte fileName="+layout.svelte" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    <script lang="ts">
+    import { setupIntlayer } from "svelte-intlayer";
+
+    export let schoolType: string;
+
+    setupIntlayer("en", schoolType);
+    </script>
+
+    <slot />
+    ```
+
+  </Tab>
+  <Tab label="Preact" value="preact">
+    ```tsx fileName="App.tsx" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    import { IntlayerProvider } from "preact-intlayer";
+
+    export const App = ({ locale, schoolType }) => (
+      <IntlayerProvider locale={locale} variant={schoolType}>
+        <Hero />
+      </IntlayerProvider>
+    );
+    ```
+
+  </Tab>
+  <Tab label="Solid" value="solid">
+    ```tsx fileName="App.tsx" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    import { IntlayerProvider } from "solid-intlayer";
+
+    export const App = (props) => (
+      <IntlayerProvider locale={props.locale} variant={props.schoolType}>
+        <Hero />
+      </IntlayerProvider>
+    );
+    ```
+
+  </Tab>
+  <Tab label="Angular" value="angular">
+    ```typescript fileName="app.config.ts" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    import { ApplicationConfig } from "@angular/core";
+    import { provideIntlayer } from "angular-intlayer";
+
+    export const appConfig: ApplicationConfig = {
+      providers: [provideIntlayer("en", true, schoolType)],
+    };
+    ```
+
+  </Tab>
+  <Tab label="Vanilla JS" value="vanilla">
+    ```javascript fileName="main.js"
+    import { installIntlayer } from "vanilla-intlayer";
+
+    installIntlayer({ locale: "en", variant: schoolType });
+    ```
+
+  </Tab>
+</Tabs>
+
+अब प्रोवाइडर के नीचे प्रत्येक डिक्शनरी पठन उसी वैरिएंट के सापेक्ष हल होता है, और कॉल-स्थल का सेलेक्टर हमेशा जीतता है:
+
+```tsx
+useIntlayer("hero-banner");
+// → प्रोवाइडर का वैरिएंट
+
+useIntlayer("hero-banner", { variant: "summer" });
+// → "summer" — प्रोवाइडर वैरिएंट को प्रतिस्थापित करता है, उसका विस्तार नहीं करता
+```
+
+### रूप
+
+`variant` प्रॉप तीन रूप स्वीकार करता है:
+
+| रूप                                                       | अर्थ                             |
+| --------------------------------------------------------- | -------------------------------- |
+| `variant="school1"`                                       | हर कुंजी के लिए एक नामित वैरिएंट |
+| `variant={["school1", "default"]}`                        | एक क्रमित वरीयता शृंखला          |
+| `variant={{ "hero-banner": "school1", default: "base" }}` | प्रति डिक्शनरी कुंजी एक वैरिएंट  |
+
+#### वरीयता शृंखला
+
+शृंखला को प्रत्येक कुंजी द्वारा घोषित प्रविष्टियों के सापेक्ष बाएँ से दाएँ आज़माया जाता है, और पहली घोषित प्रविष्टि जीतती है। जब कोई भी घोषित न हो, तो निहित डिफ़ॉल्ट प्रविष्टि का उपयोग होता है — ठीक वैसे ही जैसे एकल मान के लिए।
+
+```tsx
+<IntlayerProvider variant={["school1", "school2"]} />
+// `hero-banner` कोई `school1` प्रविष्टि घोषित नहीं करता, पर `school2` घोषित करता है → "school2"
+// वह कुंजी जो दोनों में से कोई घोषित नहीं करती → डिफ़ॉल्ट प्रविष्टि
+```
+
+अतः `["black_friday", "summer"]` का अर्थ है «यदि इस कुंजी के पास black friday है तो वही, अन्यथा summer, अन्यथा डिफ़ॉल्ट»। शृंखलाएँ कॉल-स्थल पर भी स्वीकार्य हैं:
+
+```tsx
+useIntlayer("hero-banner", { variant: ["black_friday", "summer"] });
+```
+
+> ध्यान दें कि यह कंटेंट फ़ाइल के `variant` **फ़ील्ड** द्वारा स्वीकार किए जाने वाले ऐरे का दर्पण प्रतिबिंब है: वहाँ एक ऐरे प्रति तत्व एक प्रविष्टि _घोषित_ करता है, यहाँ वह उन्हें प्राथमिकता क्रम में _उपभोग_ करता है।
+
+#### प्रति-कुंजी मैप
+
+प्रत्येक डिक्शनरी कुंजी को अलग-अलग संबोधित करें। आरक्षित `default` प्रविष्टि उन सभी कुंजियों को कवर करती है जो सूचीबद्ध नहीं हैं:
+
+```tsx
+<IntlayerProvider
+  variant={{
+    "hero-banner": "school1",
+    product: ["school1", "default"],
+    default: "base",
+  }}
+/>
+```
+
+> प्रोवाइडर पर एक सामान्य ऑब्जेक्ट **हमेशा** प्रति-कुंजी मैप के रूप में पढ़ा जाता है, कभी ऑब्जेक्ट वैरिएंट के रूप में नहीं — दोनों संरचनात्मक रूप से समान हैं। किसी ऑब्जेक्ट वैरिएंट को वैश्विक रूप से तय करने के लिए उसे किसी प्रविष्टि के नीचे नेस्ट करें: `variant={{ default: { id: "prod_abc" } }}`।
+
+चूँकि मैप की कुंजियाँ आपकी घोषित डिक्शनरी कुंजियों के विरुद्ध जाँची जाती हैं, कोई टाइपो — या सीधे लिखा गया ऑब्जेक्ट वैरिएंट, जैसे `variant={{ id: "prod_abc" }}` — संकलन-समय त्रुटि है।
+
 ## लोडिंग मोड
 
 ऑब्जेक्ट वैरिएंट अक्सर आलसी रूप से लोड किए जाते हैं। इसे नियंत्रित करने के लिए डिक्शनरी पर `importMode` सेट करें:

package/docs/id/dynamic_dictionaries/variants.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2026-06-12
-updatedAt: 2026-06-26
+updatedAt: 2026-08-04
 title: Varian
 description: Gunakan field metadata variant di file konten Intlayer untuk mendeklarasikan alternatif konten bernama atau terstruktur — pengujian A/B, banner musiman, teks ber-feature flag, record CMS, konten khusus pengguna — dan beralih di antaranya saat runtime tanpa perubahan kode.
 keywords:
@@ -26,6 +26,9 @@ history:
   - version: 9.1.1
     date: 2026-07-31
     changes: "Varian hanya mendeklarasikan kunci yang ditimpanya; varian yang tidak dideklarasikan akan kembali ke entri default"
+  - version: 9.1.2
+    date: 2026-08-04
+    changes: "Provider menerima prop `variant` ambien; selektor menerima rantai preferensi terurut"
 author: aymericzip
 ---
 
@@ -498,6 +501,176 @@ const content = useIntlayer("product", {
 const content = useIntlayer("product", { variant: { id: "prod_abc" } });
 ```
 
+## Varian ambien
+
+Beberapa dimensi varian tetap sepanjang satu sesi — tenant, jenis sekolah, tingkat paket. Semuanya diselesaikan sekali, dan tidak ada komponen yang perlu meneruskannya secara manual.
+
+> Jangan membungkus `useIntlayer` dalam hook Anda sendiri untuk menyuntikkannya. Optimasi saat build hanya menulis ulang pemanggilan literal `useIntlayer("key")` yang diimpor dari paket framework, sehingga apa pun di balik pembungkus tidak akan ikut dibundel.
+
+Sebagai gantinya, deklarasikan varian sekali pada provider, persis seperti `locale`:
+
+<Tabs group="framework">
+  <Tab label="React" value="react">
+    ```tsx fileName="App.tsx" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    import { IntlayerProvider } from "react-intlayer";
+
+    export const App = ({ locale, schoolType }) => (
+      <IntlayerProvider locale={locale} variant={schoolType}>
+        <Hero />
+      </IntlayerProvider>
+    );
+    ```
+
+  </Tab>
+  <Tab label="Next.js" value="nextjs">
+    ```tsx fileName="layout.tsx" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    import { IntlayerServerProvider } from "next-intlayer/server";
+    import { IntlayerClientProvider } from "next-intlayer";
+
+    export default async function Layout({ children, params }) {
+      const { locale } = await params;
+      const schoolType = await getSchoolType();
+
+      return (
+        <IntlayerServerProvider locale={locale} variant={schoolType}>
+          <IntlayerClientProvider locale={locale} variant={schoolType}>
+            {children}
+          </IntlayerClientProvider>
+        </IntlayerServerProvider>
+      );
+    }
+    ```
+
+  </Tab>
+  <Tab label="Vue" value="vue">
+    ```ts fileName="main.ts" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    import { createApp } from "vue";
+    import { installIntlayer } from "vue-intlayer";
+    import App from "./App.vue";
+
+    const app = createApp(App);
+
+    installIntlayer(app, { locale: "en", variant: schoolType });
+
+    app.mount("#app");
+    ```
+
+  </Tab>
+  <Tab label="Svelte" value="svelte">
+    ```svelte fileName="+layout.svelte" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    <script lang="ts">
+    import { setupIntlayer } from "svelte-intlayer";
+
+    export let schoolType: string;
+
+    setupIntlayer("en", schoolType);
+    </script>
+
+    <slot />
+    ```
+
+  </Tab>
+  <Tab label="Preact" value="preact">
+    ```tsx fileName="App.tsx" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    import { IntlayerProvider } from "preact-intlayer";
+
+    export const App = ({ locale, schoolType }) => (
+      <IntlayerProvider locale={locale} variant={schoolType}>
+        <Hero />
+      </IntlayerProvider>
+    );
+    ```
+
+  </Tab>
+  <Tab label="Solid" value="solid">
+    ```tsx fileName="App.tsx" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    import { IntlayerProvider } from "solid-intlayer";
+
+    export const App = (props) => (
+      <IntlayerProvider locale={props.locale} variant={props.schoolType}>
+        <Hero />
+      </IntlayerProvider>
+    );
+    ```
+
+  </Tab>
+  <Tab label="Angular" value="angular">
+    ```typescript fileName="app.config.ts" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    import { ApplicationConfig } from "@angular/core";
+    import { provideIntlayer } from "angular-intlayer";
+
+    export const appConfig: ApplicationConfig = {
+      providers: [provideIntlayer("en", true, schoolType)],
+    };
+    ```
+
+  </Tab>
+  <Tab label="Vanilla JS" value="vanilla">
+    ```javascript fileName="main.js"
+    import { installIntlayer } from "vanilla-intlayer";
+
+    installIntlayer({ locale: "en", variant: schoolType });
+    ```
+
+  </Tab>
+</Tabs>
+
+Setiap pembacaan kamus di bawah provider kini diselesaikan terhadap varian tersebut, dan selektor di titik pemanggilan selalu menang:
+
+```tsx
+useIntlayer("hero-banner");
+// → varian dari provider
+
+useIntlayer("hero-banner", { variant: "summer" });
+// → "summer" — menggantikan varian provider, bukan memperluasnya
+```
+
+### Bentuk
+
+Prop `variant` menerima tiga bentuk:
+
+| Bentuk                                                    | Arti                                   |
+| --------------------------------------------------------- | -------------------------------------- |
+| `variant="school1"`                                       | satu varian bernama untuk setiap kunci |
+| `variant={["school1", "default"]}`                        | rantai preferensi terurut              |
+| `variant={{ "hero-banner": "school1", default: "base" }}` | satu varian per kunci kamus            |
+
+#### Rantai preferensi
+
+Rantai dicoba dari kiri ke kanan terhadap entri yang dideklarasikan setiap kunci, dan yang pertama dideklarasikan menang. Bila tidak ada yang dideklarasikan, entri default implisit digunakan — persis seperti untuk nilai tunggal.
+
+```tsx
+<IntlayerProvider variant={["school1", "school2"]} />
+// `hero-banner` tidak mendeklarasikan entri `school1` tetapi mendeklarasikan `school2` → "school2"
+// kunci yang tidak mendeklarasikan keduanya → entri default
+```
+
+Jadi `["black_friday", "summer"]` dibaca sebagai «black friday jika kunci ini memilikinya, jika tidak summer, jika tidak default». Rantai juga diterima di titik pemanggilan:
+
+```tsx
+useIntlayer("hero-banner", { variant: ["black_friday", "summer"] });
+```
+
+> Perhatikan bahwa ini adalah kebalikan dari array yang diterima oleh **field** `variant` pada berkas konten: di sana array _mendeklarasikan_ satu entri per elemen, di sini ia _mengonsumsi_ entri tersebut sesuai urutan prioritas.
+
+#### Peta per kunci
+
+Alamatkan setiap kunci kamus secara terpisah. Entri `default` yang dicadangkan mencakup semua kunci yang tidak terdaftar:
+
+```tsx
+<IntlayerProvider
+  variant={{
+    "hero-banner": "school1",
+    product: ["school1", "default"],
+    default: "base",
+  }}
+/>
+```
+
+> Pada provider, objek biasa **selalu** dibaca sebagai peta per kunci, bukan sebagai varian objek — keduanya identik secara struktural. Untuk menetapkan varian objek secara global, sarangkan di bawah sebuah entri: `variant={{ default: { id: "prod_abc" } }}`.
+
+Karena kunci pada peta diperiksa terhadap kunci kamus yang Anda deklarasikan, salah ketik — atau varian objek yang ditulis langsung, seperti `variant={{ id: "prod_abc" }}` — adalah galat saat kompilasi.
+
 ## Mode pemuatan
 
 Varian objek sering dimuat secara malas. Atur `importMode` pada kamus untuk mengendalikannya:

package/docs/it/dynamic_dictionaries/variants.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2026-06-12
-updatedAt: 2026-06-26
+updatedAt: 2026-08-04
 title: Varianti
 description: Usa il campo di metadati variant nei file di contenuto Intlayer per dichiarare alternative di contenuto con nome o strutturate — test A/B, banner stagionali, testo con feature flag, record di CMS, contenuti specifici per utente — e passare dall'una all'altra a runtime senza modifiche al codice.
 keywords:
@@ -26,6 +26,9 @@ history:
   - version: 9.1.1
     date: 2026-07-31
     changes: "Una variante dichiara solo le chiavi che sovrascrive; le varianti non dichiarate ricadono sulla voce predefinita"
+  - version: 9.1.2
+    date: 2026-08-04
+    changes: "I provider accettano una prop `variant` ambientale; i selettori accettano una catena di preferenza ordinata"
 author: aymericzip
 ---
 
@@ -498,6 +501,176 @@ const content = useIntlayer("product", {
 const content = useIntlayer("product", { variant: { id: "prod_abc" } });
 ```
 
+## Variante ambientale
+
+Alcune dimensioni di variante sono fisse per un'intera sessione: il tenant, il tipo di istituto, il livello di piano. Vengono risolte una sola volta e nessun componente dovrebbe doverle passare a mano.
+
+> Non incapsulare `useIntlayer` in un hook personalizzato per iniettarle. L'ottimizzazione in fase di build riscrive solo una chiamata letterale `useIntlayer("key")` importata dal pacchetto del framework, quindi nulla dietro un wrapper finisce nel bundle.
+
+Dichiara invece la variante una sola volta sul provider, esattamente come `locale`:
+
+<Tabs group="framework">
+  <Tab label="React" value="react">
+    ```tsx fileName="App.tsx" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    import { IntlayerProvider } from "react-intlayer";
+
+    export const App = ({ locale, schoolType }) => (
+      <IntlayerProvider locale={locale} variant={schoolType}>
+        <Hero />
+      </IntlayerProvider>
+    );
+    ```
+
+  </Tab>
+  <Tab label="Next.js" value="nextjs">
+    ```tsx fileName="layout.tsx" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    import { IntlayerServerProvider } from "next-intlayer/server";
+    import { IntlayerClientProvider } from "next-intlayer";
+
+    export default async function Layout({ children, params }) {
+      const { locale } = await params;
+      const schoolType = await getSchoolType();
+
+      return (
+        <IntlayerServerProvider locale={locale} variant={schoolType}>
+          <IntlayerClientProvider locale={locale} variant={schoolType}>
+            {children}
+          </IntlayerClientProvider>
+        </IntlayerServerProvider>
+      );
+    }
+    ```
+
+  </Tab>
+  <Tab label="Vue" value="vue">
+    ```ts fileName="main.ts" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    import { createApp } from "vue";
+    import { installIntlayer } from "vue-intlayer";
+    import App from "./App.vue";
+
+    const app = createApp(App);
+
+    installIntlayer(app, { locale: "en", variant: schoolType });
+
+    app.mount("#app");
+    ```
+
+  </Tab>
+  <Tab label="Svelte" value="svelte">
+    ```svelte fileName="+layout.svelte" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    <script lang="ts">
+    import { setupIntlayer } from "svelte-intlayer";
+
+    export let schoolType: string;
+
+    setupIntlayer("en", schoolType);
+    </script>
+
+    <slot />
+    ```
+
+  </Tab>
+  <Tab label="Preact" value="preact">
+    ```tsx fileName="App.tsx" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    import { IntlayerProvider } from "preact-intlayer";
+
+    export const App = ({ locale, schoolType }) => (
+      <IntlayerProvider locale={locale} variant={schoolType}>
+        <Hero />
+      </IntlayerProvider>
+    );
+    ```
+
+  </Tab>
+  <Tab label="Solid" value="solid">
+    ```tsx fileName="App.tsx" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    import { IntlayerProvider } from "solid-intlayer";
+
+    export const App = (props) => (
+      <IntlayerProvider locale={props.locale} variant={props.schoolType}>
+        <Hero />
+      </IntlayerProvider>
+    );
+    ```
+
+  </Tab>
+  <Tab label="Angular" value="angular">
+    ```typescript fileName="app.config.ts" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    import { ApplicationConfig } from "@angular/core";
+    import { provideIntlayer } from "angular-intlayer";
+
+    export const appConfig: ApplicationConfig = {
+      providers: [provideIntlayer("en", true, schoolType)],
+    };
+    ```
+
+  </Tab>
+  <Tab label="Vanilla JS" value="vanilla">
+    ```javascript fileName="main.js"
+    import { installIntlayer } from "vanilla-intlayer";
+
+    installIntlayer({ locale: "en", variant: schoolType });
+    ```
+
+  </Tab>
+</Tabs>
+
+Ogni lettura di dizionario sotto il provider si risolve ora con quella variante, e un selettore nel punto di chiamata vince sempre:
+
+```tsx
+useIntlayer("hero-banner");
+// → la variante del provider
+
+useIntlayer("hero-banner", { variant: "summer" });
+// → "summer" — sostituisce la variante del provider, non la estende
+```
+
+### Forme
+
+La prop `variant` accetta tre forme:
+
+| Forma                                                     | Significato                             |
+| --------------------------------------------------------- | --------------------------------------- |
+| `variant="school1"`                                       | una variante denominata per ogni chiave |
+| `variant={["school1", "default"]}`                        | una catena di preferenza ordinata       |
+| `variant={{ "hero-banner": "school1", default: "base" }}` | una variante per chiave di dizionario   |
+
+#### Catena di preferenza
+
+Una catena viene percorsa da sinistra a destra tra le voci dichiarate da ciascuna chiave e vince la prima dichiarata. Quando nessuna è dichiarata, si usa la voce predefinita implicita, esattamente come per un valore singolo.
+
+```tsx
+<IntlayerProvider variant={["school1", "school2"]} />
+// `hero-banner` non dichiara una voce `school1` ma dichiara `school2` → "school2"
+// una chiave che non dichiara nessuna delle due → la voce predefinita
+```
+
+Quindi `["black_friday", "summer"]` si legge come «black friday se questa chiave ne ha una, altrimenti summer, altrimenti predefinita». Le catene sono accettate anche nel punto di chiamata:
+
+```tsx
+useIntlayer("hero-banner", { variant: ["black_friday", "summer"] });
+```
+
+> Nota che questa è l'immagine speculare dell'array accettato dal **campo** `variant` di un file di contenuto: lì un array _dichiara_ una voce per elemento, qui le _consuma_ in ordine di priorità.
+
+#### Mappa per chiave
+
+Indirizza ogni chiave di dizionario separatamente. La voce riservata `default` copre tutte le chiavi non elencate:
+
+```tsx
+<IntlayerProvider
+  variant={{
+    "hero-banner": "school1",
+    product: ["school1", "default"],
+    default: "base",
+  }}
+/>
+```
+
+> Su un provider un oggetto semplice è **sempre** letto come mappa per chiave, mai come variante oggetto: le due sono strutturalmente identiche. Per fissare una variante oggetto a livello globale, annidala sotto una voce: `variant={{ default: { id: "prod_abc" } }}`.
+
+Poiché le chiavi della mappa sono verificate rispetto alle chiavi di dizionario dichiarate, un refuso — o una variante oggetto scritta direttamente, come `variant={{ id: "prod_abc" }}` — è un errore di compilazione.
+
 ## Modalità di caricamento
 
 Le varianti oggetto sono spesso caricate in modo differito. Imposta `importMode` sul dizionario per controllarlo: