Intlayer कॉन्फ़िगरेशन दस्तावेज़

import { Locales, type IntlayerConfig } from "intlayer";
import { nextjsRewrite } from "intlayer/routing";
import { syncJSON } from "@intlayer/sync-json-plugin";
import { z } from "zod";

/**
 * सभी उपलब्ध विकल्पों के साथ Intlayer कॉन्फ़िगरेशन फ़ाइल का उदाहरण।
 */
const config: IntlayerConfig = {
  /**
   * अंतर्राष्ट्रीयकरण सेटिंग्स कॉन्फ़िगरेशन।
   */
  internationalization: {
    /**
     * एप्लिकेशन में समर्थित लोकेल की सूची।
     * डिफ़ॉल्ट: [Locales.ENGLISH]
     */
    locales: [Locales.ENGLISH, Locales.FRENCH, Locales.SPANISH],

    /**
     * आवश्यक लोकेल की सूची जिन्हें प्रत्येक डिक्शनरी में परिभाषित किया जाना चाहिए।
     * यदि खाली है, तो `strict` मोड में सभी लोकेल आवश्यक हैं।
     * डिफ़ॉल्ट: []
     */
    requiredLocales: [Locales.ENGLISH],

    /**
     * अंतर्राष्ट्रीयकृत कंटेंट के लिए सख्ती का स्तर।
     * - "strict": यदि कोई घोषित लोकेल अनुपस्थित है या घोषित नहीं है, तो त्रुटि उत्पन्न करता है।
     * - "inclusive": यदि घोषित लोकेल अनुपस्थित है, तो चेतावनी देता है।
     * - "loose": किसी भी मौजूदा लोकेल को स्वीकार करता है।
     * डिफ़ॉल्ट: "inclusive"
     */
    strictMode: "inclusive",

    /**
     * अनुरोधित लोकेल नहीं मिलने की स्थिति में फ़ालबैक के रूप में उपयोग किया जाने वाला डिफ़ॉल्ट लोकेल।
     * डिफ़ॉल्ट: Locales.ENGLISH
     */
    defaultLocale: Locales.ENGLISH,
  },

  /**
   * डिक्शनरी संचालन और अनुपस्थित कंटेंट व्यवहार को नियंत्रित करने वाली सेटिंग्स।
   */
  dictionary: {
    /**
     * डिक्शनरी कैसे आयात की जाती है, इसे नियंत्रित करता है।
     * - "static": बिल्ड के दौरान स्थिर आयात।
     * - "dynamic": Suspense का उपयोग करके गतिशील आयात।
     * - "fetch": लाइव सिंक API के माध्यम से गतिशील फ़ेचिंग।
     * डिफ़ॉल्ट: "static"
     */
    importMode: "static",

    /**
     * AI का उपयोग करके अनुपस्थित अनुवादों को स्वचालित रूप से भरने की रणनीति।
     * एक बूलियन या भरे हुए कंटेंट को सहेजने के लिए एक पथ पैटर्न हो सकता है।
     * डिफ़ॉल्ट: true
     */
    fill: true,

    /**
     * डिक्शनरी फ़ाइलों का भौतिक स्थान।
     * - "local": स्थानीय फ़ाइल सिस्टम पर संग्रहीत।
     * - "remote": Intlayer CMS में संग्रहीत।
     * - "hybrid": स्थानीय और Intlayer CMS दोनों में संग्रहीत।
     * - "plugin" (या कोई कस्टम स्ट्रिंग): प्लगइन या कस्टम स्रोत द्वारा प्रदान किया गया।
     * डिफ़ॉल्ट: "local"
     */
    location: "local",

    /**
     * कंटेंट को स्वचालित रूप से रूपांतरित करना है या नहीं (जैसे मार्कडाउन को HTML में)।
     * डिफ़ॉल्ट: false
     */
    contentAutoTransformation: false,
  },

  /**
   * राउटींग और मिडलवेयर कॉन्फ़िगरेशन।
   */
  routing: {
    /**
     * प्रति-लोकेल राउटींग रणनीति।
     * - "prefix-no-default": डिफ़ॉल्ट को छोड़कर सभी लोकेल के लिए प्रीफिक्स (जैसे /dashboard, /fr/dashboard)।
     * - "prefix-all": सभी लोकेल के लिए प्रीफिक्स (जैसे /en/dashboard, /fr/dashboard)।
     * - "no-prefix": URL में कोई लोकेल नहीं।
     * - "search-params": ?locale=... का उपयोग करें
     * डिफ़ॉल्ट: "prefix-no-default"
     */
    mode: "prefix-no-default",

    /**
     * Intlayer लोकेल-रूटिंग प्रॉक्सी (मिडलवेयर) को सक्षम करता है।
     * dev, preview और SSR में लोकेल पहचान, रीडायरेक्ट और रीराइट संभालता है।
     * - अनसेट (auto): dev और preview सर्वर कुकीज़ तथा हेडर में संग्रहित लोकेल को
     *   अनदेखा करके रूटिंग को URL-आधारित रखते हैं। प्रीफ़िक्स अब भी हल होते हैं,
     *   लोकेल अब भी सहेजा जाता है, और Accept-Language पहचान अब भी लागू होती है।
     *   प्रोडक्शन में यह `true` जैसा व्यवहार करता है।
     * - true: हर वातावरण में पूर्ण व्यवहार।
     * - false: कोई लोकेल रूटिंग नहीं।
     * डिफ़ॉल्ट: undefined (auto)
     */
    enableProxy: undefined,

    /**
     * उपयोगकर्ता द्वारा चुने गए लोकेल को कहाँ संग्रहीत करना है।
     * विकल्प: 'cookie', 'localStorage', 'sessionStorage', 'header' या इनका सरणी।
     * डिफ़ॉल्ट: ['cookie', 'header']
     */
    storage: ["cookie", "header"],

    /**
     * एप्लिकेशन URL का बेस पाथ।
     * डिफ़ॉल्ट: ""
     */
    basePath: "",

    /**
     * विशिष्ट लोकेल में पाथ के लिए कस्टम URL पुनर्लेखन नियम।
     */
    rewrite: nextjsRewrite({
      "/[locale]/about": {
        en: "/[locale]/about",
        fr: "/[locale]/a-propos",
      },
    }),

    /**
     * डोमेन-आधारित रूटिंग के लिए लोकेल को डोमेन होस्टनामों से मैप करता है।
     * इन लोकेल के लिए URL पूर्ण (absolute) होंगे (जैसे, https://intlayer.cn/)।
     * डोमेन लोकेल को दर्शाता है, इसलिए पाथ में कोई लोकेल प्रीफिक्स नहीं जोड़ा जाता है।
     * डिफ़ॉल्ट: undefined
     */
    domains: {
      en: "intlayer.org",
      zh: "intlayer.cn",
    },
  },

  /**
   * कंटेंट फ़ाइलों की खोज और प्रक्रिया के लिए सेटिंग्स।
   */
  content: {
    /**
     * डिक्शनरी स्कैन करने के लिए फ़ाइल एक्सटेंशन।
     * डिफ़ॉल्ट: ['.content.ts', '.content.js', '.content.json', आदि]
     */
    fileExtensions: [".content.ts", ".content.js", ".content.json"],

    /**
     * वे निर्देशिकाएँ जहाँ .content फ़ाइलें स्थित हैं।
     * डिफ़ॉल्ट: ["."]
     */
    contentDir: ["src"],

    /**
     * स्रोत कोड निर्देशिका।
     * बिल्ड ऑप्टिमाइज़ेशन और कोड ट्रांसफ़ॉर्मेशन के लिए उपयोग किया जाता है।
     * डिफ़ॉल्ट: ["."]
     */
    codeDir: ["src"],

    /**
     * स्कैनिंग से बाहर किए जाने वाले पैटर्न।
     * डिफ़ॉल्ट: ['node_modules', '.intlayer', आदि]
     */
    excludedPath: ["node_modules"],

    /**
     * विकास के दौरान परिवर्तनों को ट्रैक करना और डिक्शनरी को पुन: उत्पन्न करना है या नहीं।
     * डिफ़ॉल्ट: डेवलपमेंट मोड में true
     */
    watch: true,

    /**
     * नई बनाई गई / अपडेट की गई .content फ़ाइलों को फ़ॉर्मेट करने के लिए कमांड।
     */
    formatCommand: 'npx prettier --write "{{file}}"',
  },

  /**
   * विजुअल एडिटर कॉन्फ़िगरेशन।
   */
  editor: {
    /**
     * विजुअल एडिटर सक्षम है या नहीं।
     * डिफ़ॉल्ट: false
     */
    enabled: true,

    /**
     * ओरिजिन सत्यापन के लिए आपके एप्लिकेशन का URL।
     * डिफ़ॉल्ट: ""
     */
    applicationURL: "http://localhost:3000",

    /**
     * स्थानीय एडिटर सर्वर के लिए पोर्ट।
     * डिफ़ॉल्ट: 8000
     */
    port: 8000,

    /**
     * एडिटर के लिए सार्वजनिक URL।
     * डिफ़ॉल्ट: "http://localhost:8000"
     */
    editorURL: "http://localhost:8000",

    /**
     * Intlayer CMS का URL।
     * डिफ़ॉल्ट: "https://app.intlayer.org"
     */
    cmsURL: "https://app.intlayer.org",

    /**
     * बैकएंड API सर्वर का URL।
     * डिफ़ॉल्ट: "https://back.intlayer.org"
     */
    backendURL: "https://back.intlayer.org",

    /**
     * वास्तविक समय में कंटेंट सिंक सक्षम करना है या नहीं।
     * डिफ़ॉल्ट: false
     */
    liveSync: true,
  },

  /**
   * एनालिटिक्स (analytics) कॉन्फ़िगरेशन।
   */
  analytics: {
    /**
     * क्या एनालिटिक्स संग्रहण सक्षम है (पेज व्यू, कंटेंट एक्सपोज़र, A/B इवेंट्स)।
     * `@intlayer/analytics` इंस्टॉल होना और एट्रिब्यूशन के लिए `editor.clientId` सेट होना आवश्यक है।
     * डिफ़ॉल्ट: true
     */
    enabled: true,

    /**
     * बैकएंड को स्वचालित बैच फ़्लश के बीच मिलीसेकंड।
     * डिफ़ॉल्ट: 20000
     */
    flushInterval: 20000,

    /**
     * रिकॉर्ड करने के लिए सत्रों (sessions) का अंश, 0 (कोई नहीं) से 1 (सभी) तक।
     * डिफ़ॉल्ट: 1
     */
    sampleRate: 1,
  },

  /**
   * AI का उपयोग करके अनुवाद और जनरेशन के लिए सेटिंग्स।
   */
  ai: {
    /**
     * उपयोग किया गया AI प्रदाता।
     * विकल्प: 'openai', 'anthropic', 'mistral', 'deepseek', 'gemini', 'ollama', 'openrouter', 'alibaba', 'fireworks', 'groq', 'huggingface', 'bedrock', 'googlevertex', 'togetherai', 'lmstudio', 'moonshotai'
     * डिफ़ॉल्ट: 'openai'
     */
    provider: "openai",

    /**
     * चुने गए प्रदाता का इस्तेमाल किया गया मॉडल।
     */
    model: "gpt-4o",

    /**
     * प्रदाता की API की।
     */
    apiKey: process.env.OPENAI_API_KEY,

    /**
     * अनुवाद उत्पन्न करते समय AI का मार्गदर्शन करने के लिए वैश्विक संदर्भ।
     */
    applicationContext: "यह यात्रा बुकिंग के लिए एक एप्लिकेशन है।",

    /**
     * AI API के लिए बेस URL।
     */
    baseURL: "http://localhost:3000",

    /**
     * डेटा सीरियलाइज़ेशन
     *
     * विकल्प:
     * - "json": डिफ़ॉल्ट, विश्वसनीय; अधिक टोकन का उपयोग करता है।
     * - "toon": कम टोकन, JSON की तुलना में कम स्थिर।
     *
     * डिफ़ॉल्ट: "json"
     */
    dataSerialization: "json",
  },

  /**
   * बिल्ड और ऑप्टिमाइज़ेशन सेटिंग्स।
   */
  build: {
    /**
     * बिल्ड निष्पादन मोड।
     * - "auto": एप्लिकेशन बिल्ड के दौरान स्वचालित बिल्ड।
     * - "manual": स्पष्ट बिल्ड कमांड की आवश्यकता होती है।
     * डिफ़ॉल्ट: "auto"
     */
    mode: "auto",

    /**
     * अप्रयुक्त डिक्शनरी को हटाकर परिणामी बंडल को ऑप्टिमाइज़ करना है या नहीं।
     * डिफ़ॉल्ट: प्रोडक्शन में true
     */
    optimize: true,

    /**
     * बंडल आकार कम करने के लिए डिक्शनरी को मिनिअफ़ाइ (minify) करना है या नहीं।
     * डिफ़ॉल्ट: true
     */
    minify: true,

    /**
     * डिक्शनरी में अप्रयुक्त कीज़ (unused keys) को हटाना है या नहीं।
     * डिफ़ॉल्ट: true
     */
    prune: true,

    /**
     * प्रति-लोकेल डिक्शनरी चंक्स को उस कोड-स्प्लिट सीमा के अनुसार समूहित करें जो
     * उनका उपयोग करती है, ताकि आलसी रूप से लोड होने वाला पेज अपनी सामग्री एक ही
     * अनुरोध में प्राप्त करे।
     * डिफ़ॉल्ट: true
     *
     * नोट:
     * - केवल `importMode: 'dynamic'` का उपयोग करने वाली डिक्शनरियों पर लागू होता
     *   है।
     */
    chunkGrouping: true,

    /**
     * डिक्शनरी को उस चंक के साथ लोड करें जो उसका उपयोग करता है, बजाय उस चंक के
     * रेंडर होने के बाद उसे प्राप्त करने के। पठन सस्पेंड होने के बजाय समकालिक रूप
     * से रेंडर होते हैं, इसलिए नेविगेशन में अब लोडिंग स्थिति नहीं झलकती।
     * डिफ़ॉल्ट: true
     *
     * नोट:
     * - केवल हल की गई लोकेल की प्रतीक्षा की जाती है, इसलिए पेज केवल वही भाषा
     *   डाउनलोड करता है जो वह दिखाता है।
     */
    dictionariesPreload: true,

    /**
     * जेनरेट की गई डिक्शनरी फ़ाइलों के लिए आउटपुट स्वरूप।
     * डिफ़ॉल्ट: ['cjs', 'esm']
     */
    outputFormat: ["cjs", "esm"],

    /**
     * बिल्ड को TypeScript टाइप्स की जाँच करनी चाहिए या नहीं।
     * डिफ़ॉल्ट: false
     */
    checkTypes: false,
  },

  /**
   * लॉगर कॉन्फ़िगरेशन।
   */
  log: {
    /**
     * लॉग स्तर।
     * - "default": मानक लॉगिंग।
     * - "verbose": विस्तृत डिबग लॉगिंग।
     * - "disabled": कोई लॉगिंग नहीं।
     * डिफ़ॉल्ट: "default"
     */
    mode: "default",

    /**
     * लॉग में सभी संदेशों के लिए प्रीफिक्स।
     * डिफ़ॉल्ट: "[intlayer]"
     */
    prefix: "[intlayer]",
  },

  /**
   * सिस्टम कॉन्फ़िगरेशन (उन्नत उपयोग के मामले)
   */
  system: {
    /**
     * स्थानीयकृत डिक्शनरी संग्रहीत करने के लिए निर्देशिका।
     */
    dictionariesDir: ".intlayer/dictionary",

    /**
     * मॉड्यूल ऑगमेंटेशन (module augmentation) के लिए निर्देशिका।
     */
    moduleAugmentationDir: ".intlayer/types",

    /**
     * बिना मर्ज किए गए डिक्शनरी संग्रहीत करने के लिए निर्देशिका।
     */
    unmergedDictionariesDir: ".intlayer/unmerged_dictionary",

    /**
     * डिक्शनरी टाइप्स संग्रहीत करने के लिए निर्देशिका।
     */
    typesDir: ".intlayer/types",

    /**
     * एप्लिकेशन की मुख्य फ़ाइलें जहाँ रखी जाती हैं।
     */
    mainDir: ".intlayer/main",

    /**
     * संकलित कॉन्फ़िगरेशन फ़ाइलें जहाँ रखी जाती हैं।
     */
    configDir: ".intlayer/config",

    /**
     * कैश फ़ाइलों के लिए निर्देशिका।
     */
    cacheDir: ".intlayer/cache",
  },

  /**
   * कंपाइलर कॉन्फ़िगरेशन (उन्नत उपयोग के मामले)
   */
  compiler: {
    /**
     * कंपाइलर सक्षम करना है या नहीं।
     *
     * - false: कंपाइलर अक्षम करें।
     * - true: कंपाइलर सक्षम करें।
     * - "build-only": तेज़ स्टार्टअप के लिए विकास के दौरान कंपाइलर को छोड़ दें।
     *
     * डिफ़ॉल्ट: false
     */
    enabled: true,

    /**
     * आउटपुट फ़ाइलों के लिए पथ परिभाषित करता है। `outputDir` को प्रतिस्थापित करता है।
     *
     * - `./` पथ घटक निर्देशिका के सापेक्ष हल किए जाते हैं।
     * - `/` पथ प्रोजेक्ट बेस निर्देशिका (`baseDir`) के सापेक्ष हल किए जाते हैं।
     *
     * - पथ में `{{locale}}` चर की उपस्थिति प्रत्येक लोकेल के लिए अलग डिक्शनरी जनरेशन को सक्रिय करती है।
     *
     * उदाहरण:
     * ```ts
     * {
     *   // घटक के बगल में बहुभाषी .content.ts फ़ाइलें बनाएँ
     *   output: ({ fileName, extension }) => `./${fileName}${extension}`,
     *
     *   // output: './{{fileName}}{{extension}}', // टेम्पलेट स्ट्रिंग के माध्यम से समकक्ष
     * }
     * ```
     *
     * ```ts
     * {
     *   // प्रोजेक्ट बेस में लोकेल के अनुसार केंद्रीकृत JSON बनाएँ
     *   output: ({ key, locale }) => `/locales/${locale}/${key}.content.json`,
     *
     *   // output: '/locales/{{locale}}/{{key}}.content.json', // टेम्पलेट स्ट्रिंग के माध्यम से समकक्ष
     * }
     * ```
     *
     * चरों की सूची:
     *   - `fileName`: फ़ाइल का नाम।
     *   - `key`: कंटेंट की।
     *   - `locale`: कंटेंट लोकेल।
     *   - `extension`: फ़ाइल एक्सटेंशन।
     *   - `componentFileName`: घटक फ़ाइल का नाम।
     *   - `componentExtension`: घटक फ़ाइल एक्सटेंशन।
     *   - `format`: डिक्शनरी स्वरूप।
     *   - `componentFormat`: घटक डिक्शनरी स्वरूप।
     *   - `componentDirPath`: घटक निर्देशिका का पथ।
     */
    output: ({ locale, key }) => `compiler/${locale}/${key}.json`,

    /**
     * घटकों को उनके रूपांतरण के बाद सहेजना है या नहीं।
     * इस तरह, एप्लिकेशन रूपांतरण के लिए कंपाइलर को एक बार चलाया जा सकता है और फिर हटाया जा सकता है।
     */
    saveComponents: false,

    /**
     * जेनरेट की गई फ़ाइल में केवल कंटेंट डालें। प्रति लोकेल i18next स्वरूप या ICU MessageFormat JSON आउटपुट के लिए उपयोगी।
     */
    noMetadata: false,

    /**
     * डिक्शनरी की प्रीफिक्स
     */
    dictionaryKeyPrefix: "", // निकाले गए डिक्शनरी कीज़ के लिए वैकल्पिक प्रीफिक्स जोड़ें
  },

  /**
   * डिक्शनरी सामग्री सत्यापन के लिए कस्टम स्कीमा।
   */
  schemas: {
    "my-schema": z.object({
      title: z.string(),
    }),
  },

  /**
   * शब्दकोश कॉन्फ़िगरेशन।
   */
  dictionary: {
    /**
     * यह नियंत्रित करता है कि शब्दकोश कैसे आयात किए जाते हैं।
     * - "static": निर्माण के समय स्थिर रूप से आयातित।
     * - "dynamic": सस्पेंस का उपयोग करके गतिशील रूप से आयातित।
     * - "fetch": लाइव सिंक एपीआई के माध्यम से गतिशील रूप से प्राप्त किया गया।
     */
    importMode: "static",

    /**
     * प्रोजेक्ट में सभी शब्दकोशों के लिए डिफ़ॉल्ट संदेश प्रारूप।
     * - 'intlayer': मूल intlayer प्रारूप (डिफ़ॉल्ट)।
     * - 'icu': ICU संदेश प्रारूप।
     * - 'i18next': i18next प्रारूप।
     * - 'vue-i18n': Vue I18n प्रारूप।
     * - 'po': GNU Gettext PO प्रारूप।
     */
    format: "icu",
  },

  /**
   * प्लगइन्स कॉन्फ़िगरेशन।
   */
  plugins: [
    syncJSON({
      format: "icu",
      source: ({ locale }) => `./messages/${locale}.json`,
    }),
  ],
};

export default config;

routing: {
  mode: "prefix-no-default", // फ़ालबैक रणनीति
  rewrite: nextjsRewrite({
    "/about": {
      en: "/about",
      fr: "/a-propos",
    },
    "/product/[slug]": {
      en: "/product/[slug]",
      fr: "/produit/[slug]",
    },
    "/blog/[category]/[id]": {
      en: "/blog/[category]/[id]",
      fr: "/journal/[category]/[id]",
    },
  }),
}

import { Locales, type IntlayerConfig } from "intlayer";
// intlayer.config.ts
const config: IntlayerConfig = {
  internationalization: {
    locales: ["en", "fr", "es"],
    defaultLocale: "en",
  },
  routing: {
    mode: "prefix-no-default",
    storage: "localStorage",
    basePath: "",
  },
};

export default config;

import { Locales, type IntlayerConfig } from "intlayer";
// intlayer.config.ts
const config: IntlayerConfig = {
  internationalization: {
    locales: ["en", "fr", "es"],
    defaultLocale: "en",
  },
  routing: {
    mode: "prefix-no-default",
    storage: [
      {
        type: "localStorage",
        name: "user-locale",
      },
      {
        type: "cookie",
        name: "user-locale",
        secure: true,
        sameSite: "strict",
        httpOnly: false,
      },
    ],
    basePath: "",
  },
};

export default config;

import { Locales, type IntlayerConfig } from "intlayer";
// intlayer.config.ts
const config: IntlayerConfig = {
  internationalization: {
    locales: ["en", "fr", "es"],
    defaultLocale: "en",
  },
  routing: {
    mode: "search-params",
    storage: "localStorage",
    basePath: "",
  },
};

export default config;

import { Locales, type IntlayerConfig } from "intlayer";
// intlayer.config.ts
const config: IntlayerConfig = {
  internationalization: {
    locales: ["en", "fr", "es"],
    defaultLocale: "en",
  },
  routing: {
    mode: "no-prefix",
    storage: {
      type: "sessionStorage",
      name: "app-locale",
    },
    basePath: "/my-app",
  },
};

export default config;

// intlayer.config.ts
import { nextjsRewrite } from "intlayer/routing";

const config: IntlayerConfig = {
  internationalization: {
    locales: ["en", "fr"],
    defaultLocale: "en",
  },
  routing: {
    mode: "prefix-no-default", // बिना पुनर्लेखन वाले पाथ के लिए फ़ालबैक
    storage: "cookie",
    rewrite: nextjsRewrite({
      "/about": {
        en: "/about",
        fr: "/a-propos",
      },
      "/product/[slug]": {
        en: "/product/[slug]",
        fr: "/produit/[slug]",
      },
      "/blog/[category]/[id]": {
        en: "/blog/[category]/[id]",
        fr: "/journal/[category]/[id]",
      },
    }),
  },
};

export default config;

dictionary: {
  fill: {
    en: "/locales/en/{{key}}.content.json",
    fr: ({ key }) => `/locales/fr/${key}.content.json`,
    es: false,
  },
};