react-intlayer 9.3.0 → 9.3.2

package/dist/cjs/server/format/useCurrency.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useCurrency.cjs","names":["getServerContext","IntlayerServerContext"],"sources":["../../../../src/server/format/useCurrency.ts"],"sourcesContent":["import { currency } from '@intlayer/core/formatters';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { IntlayerServerContext } from '../IntlayerServerProvider';\nimport { getServerContext } from '../serverContext';\n\n/**\n * React client hook that provides a currency formatter\n * bound to the current application locale.\n *\n * @example\n * ```tsx\n * const formatCurrency = useCurrency();\n *\n * formatCurrency(1500, { currency: \"USD\" });\n * // \"$1,500.00\"\n *\n * formatCurrency(1500, { currency: \"EUR\", locale: \"de-DE\" });\n * // \"1.500,00 €\"\n *\n * formatCurrency(9876543.21, {\n *   currency: \"JPY\",\n *   fractionDigits: 0,\n * });\n * // \"¥9,876,543\"\n * ```\n */\nexport const useCurrency = () => {\n  const locale = getServerContext<LocalesValues>(IntlayerServerContext);\n\n  return (...args: Parameters<typeof currency>) =>\n    currency(args[0], {\n      ...args[1],\n      locale: args[1]?.locale ?? locale,\n    });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,MAAa,oBAAoB;CAC/B,MAAM,SAASA,8CAAgCC,2DAAqB;CAEpE,QAAQ,GAAG,iDACA,KAAK,IAAI;EAChB,GAAG,KAAK;EACR,QAAQ,KAAK,EAAE,EAAE,UAAU;CAC7B,CAAC;AACL"}
+{"version":3,"file":"useCurrency.cjs","names":["getServerContext","IntlayerServerContext","currency"],"sources":["../../../../src/server/format/useCurrency.ts"],"sourcesContent":["import { currency } from '@intlayer/core/formatters';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { IntlayerServerContext } from '../IntlayerServerProvider';\nimport { getServerContext } from '../serverContext';\n\n/**\n * React client hook that provides a currency formatter\n * bound to the current application locale.\n *\n * @example\n * ```tsx\n * const formatCurrency = useCurrency();\n *\n * formatCurrency(1500, { currency: \"USD\" });\n * // \"$1,500.00\"\n *\n * formatCurrency(1500, { currency: \"EUR\", locale: \"de-DE\" });\n * // \"1.500,00 €\"\n *\n * formatCurrency(9876543.21, {\n *   currency: \"JPY\",\n *   fractionDigits: 0,\n * });\n * // \"¥9,876,543\"\n * ```\n */\nexport const useCurrency = () => {\n  const locale = getServerContext<LocalesValues>(IntlayerServerContext);\n\n  return (...args: Parameters<typeof currency>) =>\n    currency(args[0], {\n      ...args[1],\n      locale: args[1]?.locale ?? locale,\n    });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,MAAa,oBAAoB;CAC/B,MAAM,SAASA,8CAAgCC,2DAAqB;CAEpE,QAAQ,GAAG,aACTC,oCAAS,KAAK,IAAI;EAChB,GAAG,KAAK;EACR,QAAQ,KAAK,EAAE,EAAE,UAAU;CAC7B,CAAC;AACL"}

package/dist/cjs/server/format/useDate.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useDate.cjs","names":["getServerContext","IntlayerServerContext"],"sources":["../../../../src/server/format/useDate.ts"],"sourcesContent":["import { date } from '@intlayer/core/formatters';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { IntlayerServerContext } from '../IntlayerServerProvider';\nimport { getServerContext } from '../serverContext';\n\n/**\n * React client hook that provides a localized date/time formatter\n * bound to the current application locale.\n *\n * @returns {(date: Date | string | number, options?: DateProps) => string}\n * A function to format dates or timestamps into localized date/time strings.\n *\n * @example\n * ```tsx\n * const formatDate = useDate();\n *\n * formatDate(new Date(\"2025-01-01\"));\n * // \"Jan 1, 2025\"\n *\n * formatDate(\"2025-01-01T15:30:00Z\", {\n *   dateStyle: \"full\",\n *   timeStyle: \"short\",\n * });\n * // \"Wednesday, January 1, 2025 at 3:30 PM\"\n *\n * formatDate(1735689600000, { locale: \"fr-FR\", dateStyle: \"long\" });\n * // \"1 janvier 2025\"\n * ```\n *\n * @see createDate\n */\nexport const useDate = () => {\n  const locale = getServerContext<LocalesValues>(IntlayerServerContext);\n\n  return (...args: Parameters<typeof date>) =>\n    date(args[0], {\n      ...args[1],\n      locale: args[1]?.locale ?? locale,\n    });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,MAAa,gBAAgB;CAC3B,MAAM,SAASA,8CAAgCC,2DAAqB;CAEpE,QAAQ,GAAG,6CACJ,KAAK,IAAI;EACZ,GAAG,KAAK;EACR,QAAQ,KAAK,EAAE,EAAE,UAAU;CAC7B,CAAC;AACL"}
+{"version":3,"file":"useDate.cjs","names":["getServerContext","IntlayerServerContext","date"],"sources":["../../../../src/server/format/useDate.ts"],"sourcesContent":["import { date } from '@intlayer/core/formatters';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { IntlayerServerContext } from '../IntlayerServerProvider';\nimport { getServerContext } from '../serverContext';\n\n/**\n * React client hook that provides a localized date/time formatter\n * bound to the current application locale.\n *\n * @returns {(date: Date | string | number, options?: DateProps) => string}\n * A function to format dates or timestamps into localized date/time strings.\n *\n * @example\n * ```tsx\n * const formatDate = useDate();\n *\n * formatDate(new Date(\"2025-01-01\"));\n * // \"Jan 1, 2025\"\n *\n * formatDate(\"2025-01-01T15:30:00Z\", {\n *   dateStyle: \"full\",\n *   timeStyle: \"short\",\n * });\n * // \"Wednesday, January 1, 2025 at 3:30 PM\"\n *\n * formatDate(1735689600000, { locale: \"fr-FR\", dateStyle: \"long\" });\n * // \"1 janvier 2025\"\n * ```\n *\n * @see createDate\n */\nexport const useDate = () => {\n  const locale = getServerContext<LocalesValues>(IntlayerServerContext);\n\n  return (...args: Parameters<typeof date>) =>\n    date(args[0], {\n      ...args[1],\n      locale: args[1]?.locale ?? locale,\n    });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,MAAa,gBAAgB;CAC3B,MAAM,SAASA,8CAAgCC,2DAAqB;CAEpE,QAAQ,GAAG,aACTC,gCAAK,KAAK,IAAI;EACZ,GAAG,KAAK;EACR,QAAQ,KAAK,EAAE,EAAE,UAAU;CAC7B,CAAC;AACL"}

package/dist/cjs/server/format/useIntl.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useIntl.cjs","names":["getServerContext","IntlayerServerContext","internationalization"],"sources":["../../../../src/server/format/useIntl.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport { bindIntl, type WrappedIntl } from '@intlayer/core/formatters';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { IntlayerServerContext } from '../IntlayerServerProvider';\nimport { getServerContext } from '../serverContext';\n\n/**\n * React client hook that provides a locale-bound `Intl` object.\n *\n * It acts exactly like the native `Intl` object, but acts as a proxy to:\n * 1. Inject the current locale automatically if none is provided.\n * 2. Use the performance-optimized `CachedIntl` under the hood.\n *\n * @example\n * ```tsx\n * const intl = useIntl(); // uses context locale\n *\n * // Standard API, but no need to pass 'en-US' as the first argument\n * const formatted = new intl.NumberFormat({\n * style: 'currency',\n * currency: 'USD'\n * }).format(123.45);\n * ```\n *\n * @example\n * ```tsx\n * const intl = useIntl();\n *\n * // You can still override the locale if needed\n * const date = new intl.DateTimeFormat({ locale: 'fr-FR' }).format(new Date());\n * // or\n * const date2 = new intl.DateTimeFormat('fr-FR').format(new Date());\n * ```\n */\nexport const useIntl = (locale?: LocalesValues): WrappedIntl => {\n  const currentLocale = getServerContext<LocalesValues>(IntlayerServerContext);\n\n  return bindIntl(\n    locale ?? currentLocale ?? internationalization?.defaultLocale\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,MAAa,WAAW,WAAwC;CAC9D,MAAM,gBAAgBA,8CAAgCC,2DAAqB;CAE3E,+CACE,UAAU,iBAAiBC,6CAAsB,aACnD;AACF"}
+{"version":3,"file":"useIntl.cjs","names":["getServerContext","IntlayerServerContext","bindIntl","internationalization"],"sources":["../../../../src/server/format/useIntl.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport { bindIntl, type WrappedIntl } from '@intlayer/core/formatters';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { IntlayerServerContext } from '../IntlayerServerProvider';\nimport { getServerContext } from '../serverContext';\n\n/**\n * React client hook that provides a locale-bound `Intl` object.\n *\n * It acts exactly like the native `Intl` object, but acts as a proxy to:\n * 1. Inject the current locale automatically if none is provided.\n * 2. Use the performance-optimized `CachedIntl` under the hood.\n *\n * @example\n * ```tsx\n * const intl = useIntl(); // uses context locale\n *\n * // Standard API, but no need to pass 'en-US' as the first argument\n * const formatted = new intl.NumberFormat({\n * style: 'currency',\n * currency: 'USD'\n * }).format(123.45);\n * ```\n *\n * @example\n * ```tsx\n * const intl = useIntl();\n *\n * // You can still override the locale if needed\n * const date = new intl.DateTimeFormat({ locale: 'fr-FR' }).format(new Date());\n * // or\n * const date2 = new intl.DateTimeFormat('fr-FR').format(new Date());\n * ```\n */\nexport const useIntl = (locale?: LocalesValues): WrappedIntl => {\n  const currentLocale = getServerContext<LocalesValues>(IntlayerServerContext);\n\n  return bindIntl(\n    locale ?? currentLocale ?? internationalization?.defaultLocale\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,MAAa,WAAW,WAAwC;CAC9D,MAAM,gBAAgBA,8CAAgCC,2DAAqB;CAE3E,WAAOC,oCACL,UAAU,iBAAiBC,6CAAsB,aACnD;AACF"}

package/dist/cjs/server/format/useList.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useList.cjs","names":["getServerContext","IntlayerServerContext"],"sources":["../../../../src/server/format/useList.ts"],"sourcesContent":["import { list } from '@intlayer/core/formatters';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { IntlayerServerContext } from '../IntlayerServerProvider';\nimport { getServerContext } from '../serverContext';\n\n/**\n * React server hook that provides a list formatter\n * bound to the current application locale.\n *\n * @example\n * ```tsx\n * const formatList = useList();\n *\n * formatList(['apple', 'banana', 'orange']);\n * // \"apple, banana, and orange\"\n *\n * formatList(['red', 'green', 'blue'], { type: 'disjunction' });\n * // \"red, green, or blue\"\n *\n * formatList([1, 2, 3], { type: 'unit', locale: 'de-DE' });\n * // \"1, 2 und 3\"\n * ```\n */\nexport const useList = () => {\n  const locale = getServerContext<LocalesValues>(IntlayerServerContext);\n\n  return (...args: Parameters<typeof list>) =>\n    list(args[0], {\n      ...args[1],\n      locale: args[1]?.locale ?? locale,\n    });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAuBA,MAAa,gBAAgB;CAC3B,MAAM,SAASA,8CAAgCC,2DAAqB;CAEpE,QAAQ,GAAG,6CACJ,KAAK,IAAI;EACZ,GAAG,KAAK;EACR,QAAQ,KAAK,EAAE,EAAE,UAAU;CAC7B,CAAC;AACL"}
+{"version":3,"file":"useList.cjs","names":["getServerContext","IntlayerServerContext","list"],"sources":["../../../../src/server/format/useList.ts"],"sourcesContent":["import { list } from '@intlayer/core/formatters';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { IntlayerServerContext } from '../IntlayerServerProvider';\nimport { getServerContext } from '../serverContext';\n\n/**\n * React server hook that provides a list formatter\n * bound to the current application locale.\n *\n * @example\n * ```tsx\n * const formatList = useList();\n *\n * formatList(['apple', 'banana', 'orange']);\n * // \"apple, banana, and orange\"\n *\n * formatList(['red', 'green', 'blue'], { type: 'disjunction' });\n * // \"red, green, or blue\"\n *\n * formatList([1, 2, 3], { type: 'unit', locale: 'de-DE' });\n * // \"1, 2 und 3\"\n * ```\n */\nexport const useList = () => {\n  const locale = getServerContext<LocalesValues>(IntlayerServerContext);\n\n  return (...args: Parameters<typeof list>) =>\n    list(args[0], {\n      ...args[1],\n      locale: args[1]?.locale ?? locale,\n    });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAuBA,MAAa,gBAAgB;CAC3B,MAAM,SAASA,8CAAgCC,2DAAqB;CAEpE,QAAQ,GAAG,aACTC,gCAAK,KAAK,IAAI;EACZ,GAAG,KAAK;EACR,QAAQ,KAAK,EAAE,EAAE,UAAU;CAC7B,CAAC;AACL"}

package/dist/cjs/server/format/useNumber.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useNumber.cjs","names":["getServerContext","IntlayerServerContext"],"sources":["../../../../src/server/format/useNumber.ts"],"sourcesContent":["import { number } from '@intlayer/core/formatters';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { IntlayerServerContext } from '../IntlayerServerProvider';\nimport { getServerContext } from '../serverContext';\n\n/**\n * React client hook that provides a localized number formatter.\n *\n * Uses the current locale from {@link useLocaleBase} and returns\n * a function that can be used to format numbers consistently\n * according to the user's locale.\n *\n * @example\n * ```tsx\n * const formatNumber = useNumber();\n *\n * formatNumber(12345);\n * // e.g. \"12,345\" (en-US)\n * // e.g. \"12 345\" (fr-FR)\n *\n * formatNumber(0.75, { style: \"percent\" });\n * // e.g. \"75%\"\n * ```\n *\n * @returns {(value: string | number, options?: import(\"../createNumber\").NumberProps) => string}\n * A number formatting function bound to the active locale.\n */\nexport const useNumber = () => {\n  const locale = getServerContext<LocalesValues>(IntlayerServerContext);\n\n  return (...args: Parameters<typeof number>) =>\n    number(args[0], {\n      ...args[1],\n      locale: args[1]?.locale ?? locale,\n    });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,MAAa,kBAAkB;CAC7B,MAAM,SAASA,8CAAgCC,2DAAqB;CAEpE,QAAQ,GAAG,+CACF,KAAK,IAAI;EACd,GAAG,KAAK;EACR,QAAQ,KAAK,EAAE,EAAE,UAAU;CAC7B,CAAC;AACL"}
+{"version":3,"file":"useNumber.cjs","names":["getServerContext","IntlayerServerContext","number"],"sources":["../../../../src/server/format/useNumber.ts"],"sourcesContent":["import { number } from '@intlayer/core/formatters';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { IntlayerServerContext } from '../IntlayerServerProvider';\nimport { getServerContext } from '../serverContext';\n\n/**\n * React client hook that provides a localized number formatter.\n *\n * Uses the current locale from {@link useLocaleBase} and returns\n * a function that can be used to format numbers consistently\n * according to the user's locale.\n *\n * @example\n * ```tsx\n * const formatNumber = useNumber();\n *\n * formatNumber(12345);\n * // e.g. \"12,345\" (en-US)\n * // e.g. \"12 345\" (fr-FR)\n *\n * formatNumber(0.75, { style: \"percent\" });\n * // e.g. \"75%\"\n * ```\n *\n * @returns {(value: string | number, options?: import(\"../createNumber\").NumberProps) => string}\n * A number formatting function bound to the active locale.\n */\nexport const useNumber = () => {\n  const locale = getServerContext<LocalesValues>(IntlayerServerContext);\n\n  return (...args: Parameters<typeof number>) =>\n    number(args[0], {\n      ...args[1],\n      locale: args[1]?.locale ?? locale,\n    });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,MAAa,kBAAkB;CAC7B,MAAM,SAASA,8CAAgCC,2DAAqB;CAEpE,QAAQ,GAAG,aACTC,kCAAO,KAAK,IAAI;EACd,GAAG,KAAK;EACR,QAAQ,KAAK,EAAE,EAAE,UAAU;CAC7B,CAAC;AACL"}

package/dist/cjs/server/format/usePercentage.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"usePercentage.cjs","names":["getServerContext","IntlayerServerContext"],"sources":["../../../../src/server/format/usePercentage.ts"],"sourcesContent":["import { percentage } from '@intlayer/core/formatters';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { IntlayerServerContext } from '../IntlayerServerProvider';\nimport { getServerContext } from '../serverContext';\n\n/**\n * React hook to provide a percentage formatter function\n * based on the current application locale.\n *\n * This hook retrieves the active locale using {@link useLocaleBase}\n * and memoizes a `createPercentage` instance for that locale.\n *\n * @example\n * ```tsx\n * const formatPercentage = usePercentage();\n *\n * const result = formatPercentage(0.875, { maximumFractionDigits: 1 });\n * // \"87.5%\" (depending on locale)\n * ```\n *\n * @returns {(value: string | number, options?: Omit<PercentageOptions, \"value\">) => string}\n * A function that formats numbers or numeric strings into localized percentages.\n */\nexport const usePercentage = () => {\n  const locale = getServerContext<LocalesValues>(IntlayerServerContext);\n\n  return (...args: Parameters<typeof percentage>) =>\n    percentage(args[0], {\n      ...args[1],\n      locale: args[1]?.locale ?? locale,\n    });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAuBA,MAAa,sBAAsB;CACjC,MAAM,SAASA,8CAAgCC,2DAAqB;CAEpE,QAAQ,GAAG,mDACE,KAAK,IAAI;EAClB,GAAG,KAAK;EACR,QAAQ,KAAK,EAAE,EAAE,UAAU;CAC7B,CAAC;AACL"}
+{"version":3,"file":"usePercentage.cjs","names":["getServerContext","IntlayerServerContext","percentage"],"sources":["../../../../src/server/format/usePercentage.ts"],"sourcesContent":["import { percentage } from '@intlayer/core/formatters';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { IntlayerServerContext } from '../IntlayerServerProvider';\nimport { getServerContext } from '../serverContext';\n\n/**\n * React hook to provide a percentage formatter function\n * based on the current application locale.\n *\n * This hook retrieves the active locale using {@link useLocaleBase}\n * and memoizes a `createPercentage` instance for that locale.\n *\n * @example\n * ```tsx\n * const formatPercentage = usePercentage();\n *\n * const result = formatPercentage(0.875, { maximumFractionDigits: 1 });\n * // \"87.5%\" (depending on locale)\n * ```\n *\n * @returns {(value: string | number, options?: Omit<PercentageOptions, \"value\">) => string}\n * A function that formats numbers or numeric strings into localized percentages.\n */\nexport const usePercentage = () => {\n  const locale = getServerContext<LocalesValues>(IntlayerServerContext);\n\n  return (...args: Parameters<typeof percentage>) =>\n    percentage(args[0], {\n      ...args[1],\n      locale: args[1]?.locale ?? locale,\n    });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAuBA,MAAa,sBAAsB;CACjC,MAAM,SAASA,8CAAgCC,2DAAqB;CAEpE,QAAQ,GAAG,aACTC,sCAAW,KAAK,IAAI;EAClB,GAAG,KAAK;EACR,QAAQ,KAAK,EAAE,EAAE,UAAU;CAC7B,CAAC;AACL"}

package/dist/cjs/server/format/useRelativeTime.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useRelativeTime.cjs","names":["getServerContext","IntlayerServerContext"],"sources":["../../../../src/server/format/useRelativeTime.ts"],"sourcesContent":["import { relativeTime } from '@intlayer/core/formatters';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { IntlayerServerContext } from '../IntlayerServerProvider';\nimport { getServerContext } from '../serverContext';\n\n/**\n * Client-side React hook for accessing a localized relative time formatter.\n *\n * This hook:\n * - Reads the current locale from {@link useLocaleBase}.\n * - Creates a new relative time formatter with {@link createRelativeTime}.\n * - Returns a function that can format time differences into localized strings.\n *\n * Example:\n * ```tsx\n * const relativeTime = useRelativeTime();\n * const formatted = relativeTime(new Date(\"2024-08-01\"), new Date());\n * // e.g., \"2 weeks ago\"\n * ```\n *\n * @returns {ReturnType<typeof createRelativeTime>} A relative time formatting function\n *          bound to the current client locale.\n */\nexport const useRelativeTime = () => {\n  const locale = getServerContext<LocalesValues>(IntlayerServerContext);\n\n  return (...args: Parameters<typeof relativeTime>) =>\n    relativeTime(args[0], args[1] ?? new Date(), {\n      ...args[2],\n      locale: args[2]?.locale ?? locale,\n    });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAuBA,MAAa,wBAAwB;CACnC,MAAM,SAASA,8CAAgCC,2DAAqB;CAEpE,QAAQ,GAAG,qDACI,KAAK,IAAI,KAAK,sBAAM,IAAI,KAAK,GAAG;EAC3C,GAAG,KAAK;EACR,QAAQ,KAAK,EAAE,EAAE,UAAU;CAC7B,CAAC;AACL"}
+{"version":3,"file":"useRelativeTime.cjs","names":["getServerContext","IntlayerServerContext","relativeTime"],"sources":["../../../../src/server/format/useRelativeTime.ts"],"sourcesContent":["import { relativeTime } from '@intlayer/core/formatters';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { IntlayerServerContext } from '../IntlayerServerProvider';\nimport { getServerContext } from '../serverContext';\n\n/**\n * Client-side React hook for accessing a localized relative time formatter.\n *\n * This hook:\n * - Reads the current locale from {@link useLocaleBase}.\n * - Creates a new relative time formatter with {@link createRelativeTime}.\n * - Returns a function that can format time differences into localized strings.\n *\n * Example:\n * ```tsx\n * const relativeTime = useRelativeTime();\n * const formatted = relativeTime(new Date(\"2024-08-01\"), new Date());\n * // e.g., \"2 weeks ago\"\n * ```\n *\n * @returns {ReturnType<typeof createRelativeTime>} A relative time formatting function\n *          bound to the current client locale.\n */\nexport const useRelativeTime = () => {\n  const locale = getServerContext<LocalesValues>(IntlayerServerContext);\n\n  return (...args: Parameters<typeof relativeTime>) =>\n    relativeTime(args[0], args[1] ?? new Date(), {\n      ...args[2],\n      locale: args[2]?.locale ?? locale,\n    });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAuBA,MAAa,wBAAwB;CACnC,MAAM,SAASA,8CAAgCC,2DAAqB;CAEpE,QAAQ,GAAG,aACTC,wCAAa,KAAK,IAAI,KAAK,sBAAM,IAAI,KAAK,GAAG;EAC3C,GAAG,KAAK;EACR,QAAQ,KAAK,EAAE,EAAE,UAAU;CAC7B,CAAC;AACL"}

package/dist/cjs/server/format/useUnit.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useUnit.cjs","names":["getServerContext","IntlayerServerContext"],"sources":["../../../../src/server/format/useUnit.ts"],"sourcesContent":["import { units } from '@intlayer/core/formatters';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { IntlayerServerContext } from '../IntlayerServerProvider';\nimport { getServerContext } from '../serverContext';\n\n/**\n * React hook that provides a unit formatting function\n * based on the current locale from {@link useLocaleBase}.\n *\n * This hook wraps {@link createUnit} to return a formatter\n * that can convert values into human-readable localized units\n * (e.g., \"10 km\", \"5 lbs\").\n *\n * @example\n * ```tsx\n * const formatUnit = useUnit();\n * const distance = formatUnit(10, { unit: \"kilometer\" });\n * // \"10 km\" (depending on locale)\n * ```\n *\n * @returns {Function} A unit formatting function that accepts a value and optional formatting options.\n */\nexport const useUnit = () => {\n  const locale = getServerContext<LocalesValues>(IntlayerServerContext);\n\n  return (...args: Parameters<typeof units>) =>\n    units(args[0], {\n      ...args[1],\n      locale: args[1]?.locale ?? locale,\n    });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAsBA,MAAa,gBAAgB;CAC3B,MAAM,SAASA,8CAAgCC,2DAAqB;CAEpE,QAAQ,GAAG,8CACH,KAAK,IAAI;EACb,GAAG,KAAK;EACR,QAAQ,KAAK,EAAE,EAAE,UAAU;CAC7B,CAAC;AACL"}
+{"version":3,"file":"useUnit.cjs","names":["getServerContext","IntlayerServerContext","units"],"sources":["../../../../src/server/format/useUnit.ts"],"sourcesContent":["import { units } from '@intlayer/core/formatters';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { IntlayerServerContext } from '../IntlayerServerProvider';\nimport { getServerContext } from '../serverContext';\n\n/**\n * React hook that provides a unit formatting function\n * based on the current locale from {@link useLocaleBase}.\n *\n * This hook wraps {@link createUnit} to return a formatter\n * that can convert values into human-readable localized units\n * (e.g., \"10 km\", \"5 lbs\").\n *\n * @example\n * ```tsx\n * const formatUnit = useUnit();\n * const distance = formatUnit(10, { unit: \"kilometer\" });\n * // \"10 km\" (depending on locale)\n * ```\n *\n * @returns {Function} A unit formatting function that accepts a value and optional formatting options.\n */\nexport const useUnit = () => {\n  const locale = getServerContext<LocalesValues>(IntlayerServerContext);\n\n  return (...args: Parameters<typeof units>) =>\n    units(args[0], {\n      ...args[1],\n      locale: args[1]?.locale ?? locale,\n    });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAsBA,MAAa,gBAAgB;CAC3B,MAAM,SAASA,8CAAgCC,2DAAqB;CAEpE,QAAQ,GAAG,aACTC,iCAAM,KAAK,IAAI;EACb,GAAG,KAAK;EACR,QAAQ,KAAK,EAAE,EAAE,UAAU;CAC7B,CAAC;AACL"}

package/dist/cjs/server/t.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"t.cjs","names":["getServerContext","IntlayerServerContext"],"sources":["../../../src/server/t.ts"],"sourcesContent":["import { getTranslation } from '@intlayer/core/interpreter';\nimport type {\n  DeclaredLocales,\n  LocalesValues,\n  StrictModeLocaleMap,\n} from '@intlayer/types/module_augmentation';\nimport { IntlayerServerContext } from './IntlayerServerProvider';\nimport { getServerContext } from './serverContext';\n\n/**\n * On the server side, hook to get the translation content based on the locale\n *\n * If not locale found, it will return the content related to the default locale.\n *\n * Return either the content editor, or the content itself depending on the configuration.\n *\n * Usage:\n *\n * ```ts\n * const content = t<string>({\n *   en: 'Hello',\n *   fr: 'Bonjour',\n * }, 'fr');\n * // 'Bonjour'\n * ```\n *\n * Using TypeScript:\n * - this function will require each locale to be defined if defined in the project configuration.\n * - If a locale is missing, it will make each existing locale optional and raise an error if the locale is not found.\n */\nexport const t = <Content = string, L extends LocalesValues = DeclaredLocales>(\n  multilangContent: StrictModeLocaleMap<Content>,\n  locale?: L\n) => {\n  const currentLocale = getServerContext<LocalesValues>(IntlayerServerContext);\n  const localeTarget = locale ?? (currentLocale as LocalesValues);\n\n  return getTranslation<Content>(multilangContent, localeTarget);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,MAAa,KACX,kBACA,WACG;CACH,MAAM,gBAAgBA,8CAAgCC,2DAAqB;CAG3E,sDAA+B,kBAFV,UAAW,aAE6B;AAC/D"}
+{"version":3,"file":"t.cjs","names":["getServerContext","IntlayerServerContext","getTranslation"],"sources":["../../../src/server/t.ts"],"sourcesContent":["import { getTranslation } from '@intlayer/core/interpreter';\nimport type {\n  DeclaredLocales,\n  LocalesValues,\n  StrictModeLocaleMap,\n} from '@intlayer/types/module_augmentation';\nimport { IntlayerServerContext } from './IntlayerServerProvider';\nimport { getServerContext } from './serverContext';\n\n/**\n * On the server side, hook to get the translation content based on the locale\n *\n * If not locale found, it will return the content related to the default locale.\n *\n * Return either the content editor, or the content itself depending on the configuration.\n *\n * Usage:\n *\n * ```ts\n * const content = t<string>({\n *   en: 'Hello',\n *   fr: 'Bonjour',\n * }, 'fr');\n * // 'Bonjour'\n * ```\n *\n * Using TypeScript:\n * - this function will require each locale to be defined if defined in the project configuration.\n * - If a locale is missing, it will make each existing locale optional and raise an error if the locale is not found.\n */\nexport const t = <Content = string, L extends LocalesValues = DeclaredLocales>(\n  multilangContent: StrictModeLocaleMap<Content>,\n  locale?: L\n) => {\n  const currentLocale = getServerContext<LocalesValues>(IntlayerServerContext);\n  const localeTarget = locale ?? (currentLocale as LocalesValues);\n\n  return getTranslation<Content>(multilangContent, localeTarget);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,MAAa,KACX,kBACA,WACG;CACH,MAAM,gBAAgBA,8CAAgCC,2DAAqB;CAG3E,WAAOC,2CAAwB,kBAFV,UAAW,aAE6B;AAC/D"}

package/dist/cjs/server/useDictionary.cjs

@@ -14,12 +14,15 @@ let _intlayer_core_dictionaryManipulator = require("@intlayer/core/dictionaryMan
 */
 const useDictionary = (dictionary, localeOrSelector, fallbackLocale) => {
 	const contextLocale = require_server_serverContext.getServerContext(require_server_IntlayerServerProvider.IntlayerServerContext) ?? fallbackLocale;
-	if (process.env.INTLAYER_DICTIONARY_SELECTOR !== "false") return require_getDictionary.getDictionary(dictionary, (0, _intlayer_core_dictionaryManipulator.resolveDictionaryArgument)({
-		localeOrSelector,
-		contextLocale,
-		contextVariant: require_server_serverContext.getServerContext(require_server_IntlayerServerProvider.IntlayerServerVariantContext),
-		dictionaryKey: dictionary.key
-	}));
+	if (process.env.INTLAYER_DICTIONARY_SELECTOR !== "false") {
+		const contextVariant = require_server_serverContext.getServerContext(require_server_IntlayerServerProvider.IntlayerServerVariantContext);
+		return require_getDictionary.getDictionary(dictionary, (0, _intlayer_core_dictionaryManipulator.resolveDictionaryArgument)({
+			localeOrSelector,
+			contextLocale,
+			contextVariant,
+			dictionaryKey: dictionary.key
+		}));
+	}
 	return require_getDictionary.getDictionary(dictionary, localeOrSelector ?? contextLocale);
 };
 

package/dist/cjs/server/useDictionary.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useDictionary.cjs","names":["getServerContext","IntlayerServerContext","getDictionary","IntlayerServerVariantContext"],"sources":["../../../src/server/useDictionary.ts"],"sourcesContent":["import { resolveDictionaryArgument } from '@intlayer/core/dictionaryManipulator';\nimport type {\n  Dictionary,\n  DictionarySelectorForGroup,\n  QualifiedDictionaryGroup,\n} from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  LocalesValues,\n  ProviderVariant,\n} from '@intlayer/types/module_augmentation';\nimport { getDictionary } from '../getDictionary';\nimport {\n  IntlayerServerContext,\n  IntlayerServerVariantContext,\n} from './IntlayerServerProvider';\nimport { getServerContext } from './serverContext';\n\n/**\n * On the server side, Hook that transform a dictionary (or qualified\n * dictionary group) and return the content\n *\n * If the locale is not provided (directly or through the selector), it will\n * use the locale from the server context\n */\nexport const useDictionary = <\n  const T extends Dictionary | QualifiedDictionaryGroup,\n  const A extends\n    | LocalesValues\n    | DictionarySelectorForGroup<T> = DeclaredLocales,\n>(\n  dictionary: T,\n  localeOrSelector?: A,\n  fallbackLocale?: DeclaredLocales\n) => {\n  const contextLocale =\n    getServerContext<LocalesValues>(IntlayerServerContext) ?? fallbackLocale;\n\n  if (process.env.INTLAYER_DICTIONARY_SELECTOR !== 'false') {\n    const contextVariant = getServerContext<ProviderVariant>(\n      IntlayerServerVariantContext\n    );\n\n    return getDictionary<T, A>(\n      dictionary,\n      resolveDictionaryArgument({\n        localeOrSelector,\n        contextLocale,\n        contextVariant,\n        dictionaryKey: dictionary.key,\n      }) as A\n    );\n  }\n\n  const localeTarget = (localeOrSelector ?? contextLocale) as A;\n\n  return getDictionary<T, A>(dictionary, localeTarget);\n};\n"],"mappings":";;;;;;;;;;;;;;AAyBA,MAAa,iBAMX,YACA,kBACA,mBACG;CACH,MAAM,gBACJA,8CAAgCC,2DAAqB,KAAK;CAE5D,IAAI,QAAQ,IAAI,iCAAiC,SAK/C,OAAOC,oCACL,gFAC0B;EACxB;EACA;EACA,gBATmBF,8CACrBG,kEAQe;EACb,eAAe,WAAW;CAC5B,CAAC,CACH;CAKF,OAAOD,oCAAoB,YAFL,oBAAoB,aAES;AACrD"}
+{"version":3,"file":"useDictionary.cjs","names":["getServerContext","IntlayerServerContext","IntlayerServerVariantContext","getDictionary","resolveDictionaryArgument"],"sources":["../../../src/server/useDictionary.ts"],"sourcesContent":["import { resolveDictionaryArgument } from '@intlayer/core/dictionaryManipulator';\nimport type {\n  Dictionary,\n  DictionarySelectorForGroup,\n  QualifiedDictionaryGroup,\n} from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  LocalesValues,\n  ProviderVariant,\n} from '@intlayer/types/module_augmentation';\nimport { getDictionary } from '../getDictionary';\nimport {\n  IntlayerServerContext,\n  IntlayerServerVariantContext,\n} from './IntlayerServerProvider';\nimport { getServerContext } from './serverContext';\n\n/**\n * On the server side, Hook that transform a dictionary (or qualified\n * dictionary group) and return the content\n *\n * If the locale is not provided (directly or through the selector), it will\n * use the locale from the server context\n */\nexport const useDictionary = <\n  const T extends Dictionary | QualifiedDictionaryGroup,\n  const A extends\n    | LocalesValues\n    | DictionarySelectorForGroup<T> = DeclaredLocales,\n>(\n  dictionary: T,\n  localeOrSelector?: A,\n  fallbackLocale?: DeclaredLocales\n) => {\n  const contextLocale =\n    getServerContext<LocalesValues>(IntlayerServerContext) ?? fallbackLocale;\n\n  if (process.env.INTLAYER_DICTIONARY_SELECTOR !== 'false') {\n    const contextVariant = getServerContext<ProviderVariant>(\n      IntlayerServerVariantContext\n    );\n\n    return getDictionary<T, A>(\n      dictionary,\n      resolveDictionaryArgument({\n        localeOrSelector,\n        contextLocale,\n        contextVariant,\n        dictionaryKey: dictionary.key,\n      }) as A\n    );\n  }\n\n  const localeTarget = (localeOrSelector ?? contextLocale) as A;\n\n  return getDictionary<T, A>(dictionary, localeTarget);\n};\n"],"mappings":";;;;;;;;;;;;;;AAyBA,MAAa,iBAMX,YACA,kBACA,mBACG;CACH,MAAM,gBACJA,8CAAgCC,2DAAqB,KAAK;CAE5D,IAAI,QAAQ,IAAI,iCAAiC,SAAS;EACxD,MAAM,iBAAiBD,8CACrBE,kEACF;EAEA,OAAOC,oCACL,gBACAC,gEAA0B;GACxB;GACA;GACA;GACA,eAAe,WAAW;EAC5B,CAAC,CACH;CACF;CAIA,OAAOD,oCAAoB,YAFL,oBAAoB,aAES;AACrD"}

package/dist/cjs/server/useDictionaryAsync.cjs

@@ -12,7 +12,8 @@ let _intlayer_config_built = require("@intlayer/config/built");
 */
 const useDictionaryAsync = async (dictionaryPromise, locale, fallbackLocale) => {
 	const localeTarget = locale ?? require_server_serverContext.getServerContext(require_server_IntlayerServerProvider.IntlayerServerContext) ?? fallbackLocale ?? _intlayer_config_built.internationalization.defaultLocale;
-	return require_server_useDictionary.useDictionary(await dictionaryPromise[localeTarget]?.(), localeTarget);
+	const dictionary = await dictionaryPromise[localeTarget]?.();
+	return require_server_useDictionary.useDictionary(dictionary, localeTarget);
 };
 
 //#endregion

package/dist/cjs/server/useDictionaryAsync.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useDictionaryAsync.cjs","names":["getServerContext","IntlayerServerContext","internationalization","useDictionary"],"sources":["../../../src/server/useDictionaryAsync.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  LocalesValues,\n  StrictModeLocaleMap,\n} from '@intlayer/types/module_augmentation';\nimport { IntlayerServerContext } from './IntlayerServerProvider';\nimport { getServerContext } from './serverContext';\nimport { useDictionary } from './useDictionary';\n\n/**\n * On the server side, Hook that transform a dictionary and return the content\n *\n * If the locale is not provided, it will use the locale from the server context\n */\nexport const useDictionaryAsync = async <\n  const T extends Dictionary,\n  const L extends LocalesValues = DeclaredLocales,\n>(\n  dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>,\n  locale?: L,\n  fallbackLocale?: DeclaredLocales\n) => {\n  const localeTarget =\n    locale ??\n    getServerContext<LocalesValues>(IntlayerServerContext) ??\n    fallbackLocale ??\n    internationalization.defaultLocale;\n\n  const dictionary = await (dictionaryPromise as any)[localeTarget]?.();\n\n  return useDictionary<T, L>(dictionary, localeTarget as L);\n};\n"],"mappings":";;;;;;;;;;;;AAgBA,MAAa,qBAAqB,OAIhC,mBACA,QACA,mBACG;CACH,MAAM,eACJ,UACAA,8CAAgCC,2DAAqB,KACrD,kBACAC,4CAAqB;CAIvB,OAAOC,2CAAoB,MAFD,kBAA0B,aAAa,GAAG,GAE7B,YAAiB;AAC1D"}
+{"version":3,"file":"useDictionaryAsync.cjs","names":["getServerContext","IntlayerServerContext","internationalization","useDictionary"],"sources":["../../../src/server/useDictionaryAsync.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  LocalesValues,\n  StrictModeLocaleMap,\n} from '@intlayer/types/module_augmentation';\nimport { IntlayerServerContext } from './IntlayerServerProvider';\nimport { getServerContext } from './serverContext';\nimport { useDictionary } from './useDictionary';\n\n/**\n * On the server side, Hook that transform a dictionary and return the content\n *\n * If the locale is not provided, it will use the locale from the server context\n */\nexport const useDictionaryAsync = async <\n  const T extends Dictionary,\n  const L extends LocalesValues = DeclaredLocales,\n>(\n  dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>,\n  locale?: L,\n  fallbackLocale?: DeclaredLocales\n) => {\n  const localeTarget =\n    locale ??\n    getServerContext<LocalesValues>(IntlayerServerContext) ??\n    fallbackLocale ??\n    internationalization.defaultLocale;\n\n  const dictionary = await (dictionaryPromise as any)[localeTarget]?.();\n\n  return useDictionary<T, L>(dictionary, localeTarget as L);\n};\n"],"mappings":";;;;;;;;;;;;AAgBA,MAAa,qBAAqB,OAIhC,mBACA,QACA,mBACG;CACH,MAAM,eACJ,UACAA,8CAAgCC,2DAAqB,KACrD,kBACAC,4CAAqB;CAEvB,MAAM,aAAa,MAAO,kBAA0B,aAAa,GAAG;CAEpE,OAAOC,2CAAoB,YAAY,YAAiB;AAC1D"}

package/dist/cjs/server/useDictionaryDynamic.cjs

@@ -39,7 +39,8 @@ const useDictionaryDynamic = (dictionaryPromise, key, localeOrSelector, fallback
 		transform: (dictionary) => require_getDictionary.getDictionary(dictionary, localeTarget)
 	});
 	const plainLoaders = dictionaryPromise;
-	return require_getDictionary.getDictionary(require_server_useLoadDynamic.useLoadDynamic(`${String(key)}.${localeTarget}`, plainLoaders[localeTarget]?.()), localeTarget);
+	const dictionary = require_server_useLoadDynamic.useLoadDynamic(`${String(key)}.${localeTarget}`, plainLoaders[localeTarget]?.());
+	return require_getDictionary.getDictionary(dictionary, localeTarget);
 };
 
 //#endregion

package/dist/cjs/server/useDictionaryDynamic.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useDictionaryDynamic.cjs","names":["getServerContext","IntlayerServerContext","IntlayerServerVariantContext","internationalization","loadDynamicChunk","getDictionary"],"sources":["../../../src/server/useDictionaryDynamic.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport {\n  isQualifiedDynamicLoaderMap,\n  parseDictionarySelector,\n  type QualifiedDynamicLoaderMap,\n  resolveDictionaryArgument,\n  resolveQualifiedDynamicContent,\n} from '@intlayer/core/dictionaryManipulator';\nimport type {\n  Dictionary,\n  DictionarySelector,\n} from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  LocalesValues,\n  ProviderVariant,\n  StrictModeLocaleMap,\n} from '@intlayer/types/module_augmentation';\nimport { getDictionary } from '../getDictionary';\nimport {\n  IntlayerServerContext,\n  IntlayerServerVariantContext,\n} from './IntlayerServerProvider';\nimport { getServerContext } from './serverContext';\n// `useLoadDynamic` wraps `react.use`, which may be called in loops /\n// conditionally — aliased to a non-hook name so a collection can load several\n// chunks at once.\nimport { useLoadDynamic as loadDynamicChunk } from './useLoadDynamic';\n\n/**\n * Server-side hook that lazily loads a dictionary and returns its content.\n *\n * The dictionary entry is either a plain dynamic loader map\n * (`locale → loader`) or a qualified one (`locale → qualifierId → loader`,\n * tagged with the qualifier dimension). For qualified maps, only the chunk(s)\n * the selector targets are loaded; the resolution mirrors static mode.\n *\n * If the locale is not provided (directly or through the selector), the server\n * context locale is used.\n */\nexport const useDictionaryDynamic = <\n  const T extends Dictionary,\n  const A extends LocalesValues | DictionarySelector = DeclaredLocales,\n>(\n  dictionaryPromise:\n    | StrictModeLocaleMap<() => Promise<T>>\n    | QualifiedDynamicLoaderMap,\n  key: string,\n  localeOrSelector?: A,\n  fallbackLocale?: DeclaredLocales\n) => {\n  const contextLocale = getServerContext<LocalesValues>(IntlayerServerContext);\n\n  const { locale: selectorLocale, selector } =\n    process.env.INTLAYER_DICTIONARY_SELECTOR !== 'false'\n      ? parseDictionarySelector<LocalesValues>(\n          // Layers the request's ambient variant under the call-site argument\n          // before the chunk walk, so only the targeted chunk is loaded.\n          resolveDictionaryArgument({\n            localeOrSelector,\n            contextLocale,\n            contextVariant: getServerContext<ProviderVariant>(\n              IntlayerServerVariantContext\n            ),\n            dictionaryKey: String(key),\n          })\n        )\n      : {\n          locale: localeOrSelector as LocalesValues | undefined,\n          selector: undefined,\n        };\n\n  const localeTarget =\n    selectorLocale ??\n    contextLocale ??\n    fallbackLocale ??\n    internationalization.defaultLocale;\n\n  if (\n    process.env.INTLAYER_DICTIONARY_SELECTOR !== 'false' &&\n    isQualifiedDynamicLoaderMap(dictionaryPromise)\n  ) {\n    return resolveQualifiedDynamicContent({\n      loaderMap: dictionaryPromise,\n      key: String(key),\n      locale: localeTarget,\n      selector,\n      loadChunk: (cacheKey, promise) => loadDynamicChunk(cacheKey, promise),\n      transform: (dictionary) => getDictionary(dictionary, localeTarget),\n    });\n  }\n\n  const plainLoaders = dictionaryPromise as StrictModeLocaleMap<\n    () => Promise<T>\n  >;\n\n  const dictionary = loadDynamicChunk<T>(\n    `${String(key)}.${localeTarget}`,\n    plainLoaders[localeTarget as keyof typeof plainLoaders]?.() as Promise<T>\n  );\n\n  return getDictionary(dictionary, localeTarget);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAwCA,MAAa,wBAIX,mBAGA,KACA,kBACA,mBACG;CACH,MAAM,gBAAgBA,8CAAgCC,2DAAqB;CAE3E,MAAM,EAAE,QAAQ,gBAAgB,aAC9B,QAAQ,IAAI,iCAAiC,gJAIb;EACxB;EACA;EACA,gBAAgBD,8CACdE,kEACF;EACA,eAAe,OAAO,GAAG;CAC3B,CAAC,CACH,IACA;EACE,QAAQ;EACR,UAAU;CACZ;CAEN,MAAM,eACJ,kBACA,iBACA,kBACAC,4CAAqB;CAEvB,IACE,QAAQ,IAAI,iCAAiC,iFACjB,iBAAiB,GAE7C,gFAAsC;EACpC,WAAW;EACX,KAAK,OAAO,GAAG;EACf,QAAQ;EACR;EACA,YAAY,UAAU,YAAYC,6CAAiB,UAAU,OAAO;EACpE,YAAY,eAAeC,oCAAc,YAAY,YAAY;CACnE,CAAC;CAGH,MAAM,eAAe;CASrB,OAAOA,oCALYD,6CACjB,GAAG,OAAO,GAAG,EAAE,GAAG,gBAClB,aAAa,aAA0C,GAAG,CAG9B,GAAG,YAAY;AAC/C"}
+{"version":3,"file":"useDictionaryDynamic.cjs","names":["getServerContext","IntlayerServerContext","parseDictionarySelector","resolveDictionaryArgument","IntlayerServerVariantContext","internationalization","isQualifiedDynamicLoaderMap","resolveQualifiedDynamicContent","loadDynamicChunk","getDictionary"],"sources":["../../../src/server/useDictionaryDynamic.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport {\n  isQualifiedDynamicLoaderMap,\n  parseDictionarySelector,\n  type QualifiedDynamicLoaderMap,\n  resolveDictionaryArgument,\n  resolveQualifiedDynamicContent,\n} from '@intlayer/core/dictionaryManipulator';\nimport type {\n  Dictionary,\n  DictionarySelector,\n} from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  LocalesValues,\n  ProviderVariant,\n  StrictModeLocaleMap,\n} from '@intlayer/types/module_augmentation';\nimport { getDictionary } from '../getDictionary';\nimport {\n  IntlayerServerContext,\n  IntlayerServerVariantContext,\n} from './IntlayerServerProvider';\nimport { getServerContext } from './serverContext';\n// `useLoadDynamic` wraps `react.use`, which may be called in loops /\n// conditionally — aliased to a non-hook name so a collection can load several\n// chunks at once.\nimport { useLoadDynamic as loadDynamicChunk } from './useLoadDynamic';\n\n/**\n * Server-side hook that lazily loads a dictionary and returns its content.\n *\n * The dictionary entry is either a plain dynamic loader map\n * (`locale → loader`) or a qualified one (`locale → qualifierId → loader`,\n * tagged with the qualifier dimension). For qualified maps, only the chunk(s)\n * the selector targets are loaded; the resolution mirrors static mode.\n *\n * If the locale is not provided (directly or through the selector), the server\n * context locale is used.\n */\nexport const useDictionaryDynamic = <\n  const T extends Dictionary,\n  const A extends LocalesValues | DictionarySelector = DeclaredLocales,\n>(\n  dictionaryPromise:\n    | StrictModeLocaleMap<() => Promise<T>>\n    | QualifiedDynamicLoaderMap,\n  key: string,\n  localeOrSelector?: A,\n  fallbackLocale?: DeclaredLocales\n) => {\n  const contextLocale = getServerContext<LocalesValues>(IntlayerServerContext);\n\n  const { locale: selectorLocale, selector } =\n    process.env.INTLAYER_DICTIONARY_SELECTOR !== 'false'\n      ? parseDictionarySelector<LocalesValues>(\n          // Layers the request's ambient variant under the call-site argument\n          // before the chunk walk, so only the targeted chunk is loaded.\n          resolveDictionaryArgument({\n            localeOrSelector,\n            contextLocale,\n            contextVariant: getServerContext<ProviderVariant>(\n              IntlayerServerVariantContext\n            ),\n            dictionaryKey: String(key),\n          })\n        )\n      : {\n          locale: localeOrSelector as LocalesValues | undefined,\n          selector: undefined,\n        };\n\n  const localeTarget =\n    selectorLocale ??\n    contextLocale ??\n    fallbackLocale ??\n    internationalization.defaultLocale;\n\n  if (\n    process.env.INTLAYER_DICTIONARY_SELECTOR !== 'false' &&\n    isQualifiedDynamicLoaderMap(dictionaryPromise)\n  ) {\n    return resolveQualifiedDynamicContent({\n      loaderMap: dictionaryPromise,\n      key: String(key),\n      locale: localeTarget,\n      selector,\n      loadChunk: (cacheKey, promise) => loadDynamicChunk(cacheKey, promise),\n      transform: (dictionary) => getDictionary(dictionary, localeTarget),\n    });\n  }\n\n  const plainLoaders = dictionaryPromise as StrictModeLocaleMap<\n    () => Promise<T>\n  >;\n\n  const dictionary = loadDynamicChunk<T>(\n    `${String(key)}.${localeTarget}`,\n    plainLoaders[localeTarget as keyof typeof plainLoaders]?.() as Promise<T>\n  );\n\n  return getDictionary(dictionary, localeTarget);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAwCA,MAAa,wBAIX,mBAGA,KACA,kBACA,mBACG;CACH,MAAM,gBAAgBA,8CAAgCC,2DAAqB;CAE3E,MAAM,EAAE,QAAQ,gBAAgB,aAC9B,QAAQ,IAAI,iCAAiC,cACzCC,kEAGEC,gEAA0B;EACxB;EACA;EACA,gBAAgBH,8CACdI,kEACF;EACA,eAAe,OAAO,GAAG;CAC3B,CAAC,CACH,IACA;EACE,QAAQ;EACR,UAAU;CACZ;CAEN,MAAM,eACJ,kBACA,iBACA,kBACAC,4CAAqB;CAEvB,IACE,QAAQ,IAAI,iCAAiC,eAC7CC,kEAA4B,iBAAiB,GAE7C,WAAOC,qEAA+B;EACpC,WAAW;EACX,KAAK,OAAO,GAAG;EACf,QAAQ;EACR;EACA,YAAY,UAAU,YAAYC,6CAAiB,UAAU,OAAO;EACpE,YAAY,eAAeC,oCAAc,YAAY,YAAY;CACnE,CAAC;CAGH,MAAM,eAAe;CAIrB,MAAM,aAAaD,6CACjB,GAAG,OAAO,GAAG,EAAE,GAAG,gBAClB,aAAa,aAA0C,GAAG,CAC5D;CAEA,OAAOC,oCAAc,YAAY,YAAY;AAC/C"}

package/dist/cjs/server/useI18n.cjs

@@ -20,7 +20,8 @@ const require_server_IntlayerServerProvider = require('./IntlayerServerProvider.
 * ```
 */
 const useI18n = (namespace, locale) => {
-	const dictionaryContent = require_getIntlayer.getIntlayer(namespace, locale ?? require_server_serverContext.getServerContext(require_server_IntlayerServerProvider.IntlayerServerContext));
+	const localeTarget = locale ?? require_server_serverContext.getServerContext(require_server_IntlayerServerProvider.IntlayerServerContext);
+	const dictionaryContent = require_getIntlayer.getIntlayer(namespace, localeTarget);
 	const t = (path) => {
 		if (!path) return dictionaryContent;
 		const pathArray = path.split(".");

package/dist/cjs/server/useI18n.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useI18n.cjs","names":["getIntlayer","getServerContext","IntlayerServerContext"],"sources":["../../../src/server/useI18n.ts"],"sourcesContent":["import type { ValidDotPathsFor } from '@intlayer/core/transpiler';\nimport type { GetSubPath } from '@intlayer/types/dictionary';\nimport type {\n  DictionaryKeys,\n  DictionaryRegistryContent,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { getIntlayer } from '../getIntlayer';\nimport type { DeepTransformContent } from '../plugins';\nimport { IntlayerServerContext } from './IntlayerServerProvider';\nimport { getServerContext } from './serverContext';\n\n/**\n * Hook that provides a translation function `t()` for accessing nested content by key.\n * This hook mimics the pattern found in libraries like i18next, next-intl, and vue-i18n.\n *\n * @param namespace - The dictionary key to scope translations to\n * @param locale - Optional locale override. If not provided, uses the current context locale\n * @returns A translation function `t(key)` that returns the translated content for the given key\n *\n * @example\n * ```tsx\n * const t = useI18n('IndexPage');\n * const title = t('title'); // Returns translated string for 'IndexPage.title'\n * const nestedContent = t('section.subtitle'); // Returns 'IndexPage.section.subtitle'\n * ```\n */\nexport const useI18n = <T extends DictionaryKeys>(\n  namespace: T,\n  locale?: LocalesValues\n) => {\n  const localeTarget =\n    locale ?? getServerContext<LocalesValues>(IntlayerServerContext);\n\n  // Get the dictionary content for the namespace\n  const dictionaryContent = getIntlayer(namespace, localeTarget);\n\n  // Return the translation function\n  // @ts-ignore Type instantiation is excessively deep and possibly infinite\n  const t = <P extends ValidDotPathsFor<T>>(\n    path: P\n  ): GetSubPath<DeepTransformContent<DictionaryRegistryContent<T>>, P> => {\n    if (!path) {\n      return dictionaryContent as any;\n    }\n\n    const pathArray = (path as string).split('.');\n    let current: any = dictionaryContent;\n\n    for (const key of pathArray) {\n      current = current?.[key];\n      if (current === undefined) {\n        // Return the whole dictionary as fallback if path is not found\n        return dictionaryContent as any;\n      }\n    }\n\n    return current;\n  };\n\n  return t;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AA2BA,MAAa,WACX,WACA,WACG;CAKH,MAAM,oBAAoBA,gCAAY,WAHpC,UAAUC,8CAAgCC,2DAAqB,CAGJ;CAI7D,MAAM,KACJ,SACsE;EACtE,IAAI,CAAC,MACH,OAAO;EAGT,MAAM,YAAa,KAAgB,MAAM,GAAG;EAC5C,IAAI,UAAe;EAEnB,KAAK,MAAM,OAAO,WAAW;GAC3B,UAAU,UAAU;GACpB,IAAI,YAAY,QAEd,OAAO;EAEX;EAEA,OAAO;CACT;CAEA,OAAO;AACT"}
+{"version":3,"file":"useI18n.cjs","names":["getServerContext","IntlayerServerContext","getIntlayer"],"sources":["../../../src/server/useI18n.ts"],"sourcesContent":["import type { ValidDotPathsFor } from '@intlayer/core/transpiler';\nimport type { GetSubPath } from '@intlayer/types/dictionary';\nimport type {\n  DictionaryKeys,\n  DictionaryRegistryContent,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { getIntlayer } from '../getIntlayer';\nimport type { DeepTransformContent } from '../plugins';\nimport { IntlayerServerContext } from './IntlayerServerProvider';\nimport { getServerContext } from './serverContext';\n\n/**\n * Hook that provides a translation function `t()` for accessing nested content by key.\n * This hook mimics the pattern found in libraries like i18next, next-intl, and vue-i18n.\n *\n * @param namespace - The dictionary key to scope translations to\n * @param locale - Optional locale override. If not provided, uses the current context locale\n * @returns A translation function `t(key)` that returns the translated content for the given key\n *\n * @example\n * ```tsx\n * const t = useI18n('IndexPage');\n * const title = t('title'); // Returns translated string for 'IndexPage.title'\n * const nestedContent = t('section.subtitle'); // Returns 'IndexPage.section.subtitle'\n * ```\n */\nexport const useI18n = <T extends DictionaryKeys>(\n  namespace: T,\n  locale?: LocalesValues\n) => {\n  const localeTarget =\n    locale ?? getServerContext<LocalesValues>(IntlayerServerContext);\n\n  // Get the dictionary content for the namespace\n  const dictionaryContent = getIntlayer(namespace, localeTarget);\n\n  // Return the translation function\n  // @ts-ignore Type instantiation is excessively deep and possibly infinite\n  const t = <P extends ValidDotPathsFor<T>>(\n    path: P\n  ): GetSubPath<DeepTransformContent<DictionaryRegistryContent<T>>, P> => {\n    if (!path) {\n      return dictionaryContent as any;\n    }\n\n    const pathArray = (path as string).split('.');\n    let current: any = dictionaryContent;\n\n    for (const key of pathArray) {\n      current = current?.[key];\n      if (current === undefined) {\n        // Return the whole dictionary as fallback if path is not found\n        return dictionaryContent as any;\n      }\n    }\n\n    return current;\n  };\n\n  return t;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AA2BA,MAAa,WACX,WACA,WACG;CACH,MAAM,eACJ,UAAUA,8CAAgCC,2DAAqB;CAGjE,MAAM,oBAAoBC,gCAAY,WAAW,YAAY;CAI7D,MAAM,KACJ,SACsE;EACtE,IAAI,CAAC,MACH,OAAO;EAGT,MAAM,YAAa,KAAgB,MAAM,GAAG;EAC5C,IAAI,UAAe;EAEnB,KAAK,MAAM,OAAO,WAAW;GAC3B,UAAU,UAAU;GACpB,IAAI,YAAY,QAEd,OAAO;EAEX;EAEA,OAAO;CACT;CAEA,OAAO;AACT"}

package/dist/cjs/server/useIntlayer.cjs

@@ -15,12 +15,15 @@ let _intlayer_core_dictionaryManipulator = require("@intlayer/core/dictionaryMan
 */
 const useIntlayer = (key, localeOrSelector, fallbackLocale) => {
 	const contextLocale = require_server_serverContext.getServerContext(require_server_IntlayerServerProvider.IntlayerServerContext) ?? fallbackLocale;
-	if (process.env.INTLAYER_DICTIONARY_SELECTOR !== "false") return require_getIntlayer.getIntlayer(key, (0, _intlayer_core_dictionaryManipulator.resolveDictionaryArgument)({
-		localeOrSelector,
-		contextLocale,
-		contextVariant: require_server_serverContext.getServerContext(require_server_IntlayerServerProvider.IntlayerServerVariantContext),
-		dictionaryKey: key
-	}));
+	if (process.env.INTLAYER_DICTIONARY_SELECTOR !== "false") {
+		const contextVariant = require_server_serverContext.getServerContext(require_server_IntlayerServerProvider.IntlayerServerVariantContext);
+		return require_getIntlayer.getIntlayer(key, (0, _intlayer_core_dictionaryManipulator.resolveDictionaryArgument)({
+			localeOrSelector,
+			contextLocale,
+			contextVariant,
+			dictionaryKey: key
+		}));
+	}
 	return require_getIntlayer.getIntlayer(key, localeOrSelector ?? contextLocale);
 };
 

package/dist/cjs/server/useIntlayer.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useIntlayer.cjs","names":["getServerContext","IntlayerServerContext","getIntlayer","IntlayerServerVariantContext"],"sources":["../../../src/server/useIntlayer.ts"],"sourcesContent":["import { resolveDictionaryArgument } from '@intlayer/core/dictionaryManipulator';\nimport type {\n  DeclaredLocales,\n  DictionaryKeys,\n  DictionarySelectorForKey,\n  LocalesValues,\n  ProviderVariant,\n} from '@intlayer/types/module_augmentation';\nimport { getIntlayer } from '../getIntlayer';\nimport {\n  IntlayerServerContext,\n  IntlayerServerVariantContext,\n} from './IntlayerServerProvider';\nimport { getServerContext } from './serverContext';\n\n/**\n * On the server side, Hook that picking one dictionary by its key and return the content\n *\n * The second argument is either a locale or a selector object\n * (`{ item }`, `{ variant }`, optionally with `locale`).\n *\n * If the locale is not provided, it will use the locale from the server context\n */\nexport const useIntlayer = <\n  const T extends DictionaryKeys,\n  const A extends LocalesValues | DictionarySelectorForKey<T> = DeclaredLocales,\n>(\n  key: T,\n  localeOrSelector?: A,\n  fallbackLocale?: DeclaredLocales\n) => {\n  const contextLocale =\n    getServerContext<LocalesValues>(IntlayerServerContext) ?? fallbackLocale;\n\n  if (process.env.INTLAYER_DICTIONARY_SELECTOR !== 'false') {\n    const contextVariant = getServerContext<ProviderVariant>(\n      IntlayerServerVariantContext\n    );\n\n    return getIntlayer<T, A>(\n      key,\n      resolveDictionaryArgument({\n        localeOrSelector,\n        contextLocale,\n        contextVariant,\n        dictionaryKey: key as string,\n      }) as A\n    );\n  }\n\n  const localeTarget = (localeOrSelector ?? contextLocale) as A;\n\n  return getIntlayer<T, A>(key, localeTarget);\n};\n"],"mappings":";;;;;;;;;;;;;;;AAuBA,MAAa,eAIX,KACA,kBACA,mBACG;CACH,MAAM,gBACJA,8CAAgCC,2DAAqB,KAAK;CAE5D,IAAI,QAAQ,IAAI,iCAAiC,SAK/C,OAAOC,gCACL,yEAC0B;EACxB;EACA;EACA,gBATmBF,8CACrBG,kEAQe;EACb,eAAe;CACjB,CAAC,CACH;CAKF,OAAOD,gCAAkB,KAFH,oBAAoB,aAEA;AAC5C"}
+{"version":3,"file":"useIntlayer.cjs","names":["getServerContext","IntlayerServerContext","IntlayerServerVariantContext","getIntlayer","resolveDictionaryArgument"],"sources":["../../../src/server/useIntlayer.ts"],"sourcesContent":["import { resolveDictionaryArgument } from '@intlayer/core/dictionaryManipulator';\nimport type {\n  DeclaredLocales,\n  DictionaryKeys,\n  DictionarySelectorForKey,\n  LocalesValues,\n  ProviderVariant,\n} from '@intlayer/types/module_augmentation';\nimport { getIntlayer } from '../getIntlayer';\nimport {\n  IntlayerServerContext,\n  IntlayerServerVariantContext,\n} from './IntlayerServerProvider';\nimport { getServerContext } from './serverContext';\n\n/**\n * On the server side, Hook that picking one dictionary by its key and return the content\n *\n * The second argument is either a locale or a selector object\n * (`{ item }`, `{ variant }`, optionally with `locale`).\n *\n * If the locale is not provided, it will use the locale from the server context\n */\nexport const useIntlayer = <\n  const T extends DictionaryKeys,\n  const A extends LocalesValues | DictionarySelectorForKey<T> = DeclaredLocales,\n>(\n  key: T,\n  localeOrSelector?: A,\n  fallbackLocale?: DeclaredLocales\n) => {\n  const contextLocale =\n    getServerContext<LocalesValues>(IntlayerServerContext) ?? fallbackLocale;\n\n  if (process.env.INTLAYER_DICTIONARY_SELECTOR !== 'false') {\n    const contextVariant = getServerContext<ProviderVariant>(\n      IntlayerServerVariantContext\n    );\n\n    return getIntlayer<T, A>(\n      key,\n      resolveDictionaryArgument({\n        localeOrSelector,\n        contextLocale,\n        contextVariant,\n        dictionaryKey: key as string,\n      }) as A\n    );\n  }\n\n  const localeTarget = (localeOrSelector ?? contextLocale) as A;\n\n  return getIntlayer<T, A>(key, localeTarget);\n};\n"],"mappings":";;;;;;;;;;;;;;;AAuBA,MAAa,eAIX,KACA,kBACA,mBACG;CACH,MAAM,gBACJA,8CAAgCC,2DAAqB,KAAK;CAE5D,IAAI,QAAQ,IAAI,iCAAiC,SAAS;EACxD,MAAM,iBAAiBD,8CACrBE,kEACF;EAEA,OAAOC,gCACL,SACAC,gEAA0B;GACxB;GACA;GACA;GACA,eAAe;EACjB,CAAC,CACH;CACF;CAIA,OAAOD,gCAAkB,KAFH,oBAAoB,aAEA;AAC5C"}

package/dist/esm/client/useDictionaryAsync.mjs

@@ -14,7 +14,8 @@ import { useContext, useMemo } from "react";
 const useDictionaryAsync = async (dictionaryPromise, locale) => {
 	const { locale: currentLocale } = useContext(IntlayerClientContext) ?? {};
 	const localeTarget = useMemo(() => locale ?? currentLocale ?? internationalization.defaultLocale, [currentLocale, locale]);
-	return useDictionary(await useMemo(async () => await dictionaryPromise[localeTarget]?.(), [dictionaryPromise, localeTarget]), localeTarget);
+	const dictionary = await useMemo(async () => await dictionaryPromise[localeTarget]?.(), [dictionaryPromise, localeTarget]);
+	return useDictionary(dictionary, localeTarget);
 };
 
 //#endregion

package/dist/esm/client/useDictionaryAsync.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"useDictionaryAsync.mjs","names":[],"sources":["../../../src/client/useDictionaryAsync.ts"],"sourcesContent":["'use client';\n\nimport { internationalization } from '@intlayer/config/built';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  LocalesValues,\n  StrictModeLocaleMap,\n} from '@intlayer/types/module_augmentation';\nimport { useContext, useMemo } from 'react';\nimport { IntlayerClientContext } from './IntlayerProvider';\nimport { useDictionary } from './useDictionary';\n\n/**\n * On the server side, Hook that transform a dictionary and return the content\n *\n * If the locale is not provided, it will use the locale from the client context\n */\nexport const useDictionaryAsync = async <\n  const T extends Dictionary,\n  const L extends LocalesValues = DeclaredLocales,\n>(\n  dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>,\n  locale?: L\n): Promise<T> => {\n  const { locale: currentLocale } = useContext(IntlayerClientContext) ?? {};\n\n  const localeTarget = useMemo(\n    () => locale ?? currentLocale ?? internationalization.defaultLocale,\n    [currentLocale, locale]\n  );\n\n  const dictionary = await useMemo(\n    async () =>\n      (await dictionaryPromise[\n        localeTarget as keyof typeof dictionaryPromise\n      ]?.()) as T,\n    [dictionaryPromise, localeTarget]\n  );\n\n  return useDictionary<T, L>(dictionary, localeTarget as L) as any;\n};\n"],"mappings":";;;;;;;;;;;;;AAkBA,MAAa,qBAAqB,OAIhC,mBACA,WACe;CACf,MAAM,EAAE,QAAQ,kBAAkB,WAAW,qBAAqB,KAAK,CAAC;CAExE,MAAM,eAAe,cACb,UAAU,iBAAiB,qBAAqB,eACtD,CAAC,eAAe,MAAM,CACxB;CAUA,OAAO,cAAoB,MARF,QACvB,YACG,MAAM,kBACL,aACD,GAAG,GACN,CAAC,mBAAmB,YAAY,CAClC,GAEuC,YAAiB;AAC1D"}
+{"version":3,"file":"useDictionaryAsync.mjs","names":[],"sources":["../../../src/client/useDictionaryAsync.ts"],"sourcesContent":["'use client';\n\nimport { internationalization } from '@intlayer/config/built';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  LocalesValues,\n  StrictModeLocaleMap,\n} from '@intlayer/types/module_augmentation';\nimport { useContext, useMemo } from 'react';\nimport { IntlayerClientContext } from './IntlayerProvider';\nimport { useDictionary } from './useDictionary';\n\n/**\n * On the server side, Hook that transform a dictionary and return the content\n *\n * If the locale is not provided, it will use the locale from the client context\n */\nexport const useDictionaryAsync = async <\n  const T extends Dictionary,\n  const L extends LocalesValues = DeclaredLocales,\n>(\n  dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>,\n  locale?: L\n): Promise<T> => {\n  const { locale: currentLocale } = useContext(IntlayerClientContext) ?? {};\n\n  const localeTarget = useMemo(\n    () => locale ?? currentLocale ?? internationalization.defaultLocale,\n    [currentLocale, locale]\n  );\n\n  const dictionary = await useMemo(\n    async () =>\n      (await dictionaryPromise[\n        localeTarget as keyof typeof dictionaryPromise\n      ]?.()) as T,\n    [dictionaryPromise, localeTarget]\n  );\n\n  return useDictionary<T, L>(dictionary, localeTarget as L) as any;\n};\n"],"mappings":";;;;;;;;;;;;;AAkBA,MAAa,qBAAqB,OAIhC,mBACA,WACe;CACf,MAAM,EAAE,QAAQ,kBAAkB,WAAW,qBAAqB,KAAK,CAAC;CAExE,MAAM,eAAe,cACb,UAAU,iBAAiB,qBAAqB,eACtD,CAAC,eAAe,MAAM,CACxB;CAEA,MAAM,aAAa,MAAM,QACvB,YACG,MAAM,kBACL,aACD,GAAG,GACN,CAAC,mBAAmB,YAAY,CAClC;CAEA,OAAO,cAAoB,YAAY,YAAiB;AAC1D"}

package/dist/esm/client/useDictionaryDynamic.mjs

@@ -40,7 +40,8 @@ const useDictionaryDynamic = (dictionaryPromise, key, localeOrSelector) => {
 		transform: (dictionary) => getDictionary(dictionary, localeTarget)
 	});
 	const plainLoaders = dictionaryPromise;
-	return getDictionary(useLoadDynamic(`${String(key)}.${localeTarget}`, plainLoaders[localeTarget]?.()), localeTarget);
+	const dictionary = useLoadDynamic(`${String(key)}.${localeTarget}`, plainLoaders[localeTarget]?.());
+	return getDictionary(dictionary, localeTarget);
 };
 
 //#endregion

package/dist/esm/client/useDictionaryDynamic.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"useDictionaryDynamic.mjs","names":["loadDynamicChunk"],"sources":["../../../src/client/useDictionaryDynamic.ts"],"sourcesContent":["'use client';\n\nimport { internationalization } from '@intlayer/config/built';\nimport {\n  isQualifiedDynamicLoaderMap,\n  parseDictionarySelector,\n  type QualifiedDynamicLoaderMap,\n  resolveDictionaryArgument,\n  resolveQualifiedDynamicContent,\n} from '@intlayer/core/dictionaryManipulator';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  DictionaryKeys,\n  DictionarySelectorForKey,\n  LocalesValues,\n  StrictModeLocaleMap,\n} from '@intlayer/types/module_augmentation';\nimport { useContext } from 'react';\nimport { getDictionary } from '../getDictionary';\nimport { IntlayerClientContext } from './IntlayerProvider';\n// `useLoadDynamic` is a suspender cache, not a React hook — aliased to a\n// non-hook name so it can be invoked in loops / conditionally (e.g. when a\n// collection loads several chunks at once).\nimport { useLoadDynamic as loadDynamicChunk } from './useLoadDynamic';\n\n/**\n * Client-side hook that lazily loads a dictionary and returns its content.\n *\n * The dictionary entry is either a plain dynamic loader map\n * (`locale → loader`) or a qualified one (`locale → qualifierId → loader`,\n * tagged with the qualifier dimension). For qualified maps, only the chunk(s)\n * the selector targets are loaded; the resolution mirrors static mode.\n *\n * If the locale is not provided (directly or through the selector), the client\n * context locale is used.\n */\nexport const useDictionaryDynamic = <\n  const T extends Dictionary,\n  const K extends DictionaryKeys,\n  const A extends LocalesValues | DictionarySelectorForKey<K> = DeclaredLocales,\n>(\n  dictionaryPromise:\n    | StrictModeLocaleMap<() => Promise<T>>\n    | QualifiedDynamicLoaderMap,\n  key: K,\n  localeOrSelector?: A\n) => {\n  const { locale: currentLocale, variant: contextVariant } =\n    useContext(IntlayerClientContext) ?? {};\n\n  const { locale: selectorLocale, selector } =\n    process.env.INTLAYER_DICTIONARY_SELECTOR !== 'false'\n      ? parseDictionarySelector<LocalesValues>(\n          // Layers the provider's ambient variant under the call-site argument\n          // before the chunk walk, so only the targeted chunk is loaded.\n          resolveDictionaryArgument({\n            localeOrSelector,\n            contextLocale: currentLocale,\n            contextVariant,\n            dictionaryKey: String(key),\n          })\n        )\n      : {\n          locale: localeOrSelector as LocalesValues | undefined,\n          selector: undefined,\n        };\n\n  const localeTarget =\n    selectorLocale ?? currentLocale ?? internationalization.defaultLocale;\n\n  if (\n    process.env.INTLAYER_DICTIONARY_SELECTOR !== 'false' &&\n    isQualifiedDynamicLoaderMap(dictionaryPromise)\n  ) {\n    return resolveQualifiedDynamicContent({\n      loaderMap: dictionaryPromise,\n      key: String(key),\n      locale: localeTarget,\n      selector,\n      loadChunk: (cacheKey, promise) => loadDynamicChunk(cacheKey, promise),\n      transform: (dictionary) => getDictionary(dictionary, localeTarget),\n    });\n  }\n\n  const plainLoaders = dictionaryPromise as StrictModeLocaleMap<\n    () => Promise<T>\n  >;\n\n  const dictionary = loadDynamicChunk<T>(\n    `${String(key)}.${localeTarget}`,\n    plainLoaders[localeTarget as keyof typeof plainLoaders]?.() as Promise<T>\n  );\n\n  return getDictionary(dictionary, localeTarget);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAqCA,MAAa,wBAKX,mBAGA,KACA,qBACG;CACH,MAAM,EAAE,QAAQ,eAAe,SAAS,mBACtC,WAAW,qBAAqB,KAAK,CAAC;CAExC,MAAM,EAAE,QAAQ,gBAAgB,aAC9B,QAAQ,IAAI,iCAAiC,UACzC,wBAGE,0BAA0B;EACxB;EACA,eAAe;EACf;EACA,eAAe,OAAO,GAAG;CAC3B,CAAC,CACH,IACA;EACE,QAAQ;EACR,UAAU;CACZ;CAEN,MAAM,eACJ,kBAAkB,iBAAiB,qBAAqB;CAE1D,IACE,QAAQ,IAAI,iCAAiC,WAC7C,4BAA4B,iBAAiB,GAE7C,OAAO,+BAA+B;EACpC,WAAW;EACX,KAAK,OAAO,GAAG;EACf,QAAQ;EACR;EACA,YAAY,UAAU,YAAYA,eAAiB,UAAU,OAAO;EACpE,YAAY,eAAe,cAAc,YAAY,YAAY;CACnE,CAAC;CAGH,MAAM,eAAe;CASrB,OAAO,cALYA,eACjB,GAAG,OAAO,GAAG,EAAE,GAAG,gBAClB,aAAa,aAA0C,GAAG,CAG9B,GAAG,YAAY;AAC/C"}
+{"version":3,"file":"useDictionaryDynamic.mjs","names":["loadDynamicChunk"],"sources":["../../../src/client/useDictionaryDynamic.ts"],"sourcesContent":["'use client';\n\nimport { internationalization } from '@intlayer/config/built';\nimport {\n  isQualifiedDynamicLoaderMap,\n  parseDictionarySelector,\n  type QualifiedDynamicLoaderMap,\n  resolveDictionaryArgument,\n  resolveQualifiedDynamicContent,\n} from '@intlayer/core/dictionaryManipulator';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  DictionaryKeys,\n  DictionarySelectorForKey,\n  LocalesValues,\n  StrictModeLocaleMap,\n} from '@intlayer/types/module_augmentation';\nimport { useContext } from 'react';\nimport { getDictionary } from '../getDictionary';\nimport { IntlayerClientContext } from './IntlayerProvider';\n// `useLoadDynamic` is a suspender cache, not a React hook — aliased to a\n// non-hook name so it can be invoked in loops / conditionally (e.g. when a\n// collection loads several chunks at once).\nimport { useLoadDynamic as loadDynamicChunk } from './useLoadDynamic';\n\n/**\n * Client-side hook that lazily loads a dictionary and returns its content.\n *\n * The dictionary entry is either a plain dynamic loader map\n * (`locale → loader`) or a qualified one (`locale → qualifierId → loader`,\n * tagged with the qualifier dimension). For qualified maps, only the chunk(s)\n * the selector targets are loaded; the resolution mirrors static mode.\n *\n * If the locale is not provided (directly or through the selector), the client\n * context locale is used.\n */\nexport const useDictionaryDynamic = <\n  const T extends Dictionary,\n  const K extends DictionaryKeys,\n  const A extends LocalesValues | DictionarySelectorForKey<K> = DeclaredLocales,\n>(\n  dictionaryPromise:\n    | StrictModeLocaleMap<() => Promise<T>>\n    | QualifiedDynamicLoaderMap,\n  key: K,\n  localeOrSelector?: A\n) => {\n  const { locale: currentLocale, variant: contextVariant } =\n    useContext(IntlayerClientContext) ?? {};\n\n  const { locale: selectorLocale, selector } =\n    process.env.INTLAYER_DICTIONARY_SELECTOR !== 'false'\n      ? parseDictionarySelector<LocalesValues>(\n          // Layers the provider's ambient variant under the call-site argument\n          // before the chunk walk, so only the targeted chunk is loaded.\n          resolveDictionaryArgument({\n            localeOrSelector,\n            contextLocale: currentLocale,\n            contextVariant,\n            dictionaryKey: String(key),\n          })\n        )\n      : {\n          locale: localeOrSelector as LocalesValues | undefined,\n          selector: undefined,\n        };\n\n  const localeTarget =\n    selectorLocale ?? currentLocale ?? internationalization.defaultLocale;\n\n  if (\n    process.env.INTLAYER_DICTIONARY_SELECTOR !== 'false' &&\n    isQualifiedDynamicLoaderMap(dictionaryPromise)\n  ) {\n    return resolveQualifiedDynamicContent({\n      loaderMap: dictionaryPromise,\n      key: String(key),\n      locale: localeTarget,\n      selector,\n      loadChunk: (cacheKey, promise) => loadDynamicChunk(cacheKey, promise),\n      transform: (dictionary) => getDictionary(dictionary, localeTarget),\n    });\n  }\n\n  const plainLoaders = dictionaryPromise as StrictModeLocaleMap<\n    () => Promise<T>\n  >;\n\n  const dictionary = loadDynamicChunk<T>(\n    `${String(key)}.${localeTarget}`,\n    plainLoaders[localeTarget as keyof typeof plainLoaders]?.() as Promise<T>\n  );\n\n  return getDictionary(dictionary, localeTarget);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAqCA,MAAa,wBAKX,mBAGA,KACA,qBACG;CACH,MAAM,EAAE,QAAQ,eAAe,SAAS,mBACtC,WAAW,qBAAqB,KAAK,CAAC;CAExC,MAAM,EAAE,QAAQ,gBAAgB,aAC9B,QAAQ,IAAI,iCAAiC,UACzC,wBAGE,0BAA0B;EACxB;EACA,eAAe;EACf;EACA,eAAe,OAAO,GAAG;CAC3B,CAAC,CACH,IACA;EACE,QAAQ;EACR,UAAU;CACZ;CAEN,MAAM,eACJ,kBAAkB,iBAAiB,qBAAqB;CAE1D,IACE,QAAQ,IAAI,iCAAiC,WAC7C,4BAA4B,iBAAiB,GAE7C,OAAO,+BAA+B;EACpC,WAAW;EACX,KAAK,OAAO,GAAG;EACf,QAAQ;EACR;EACA,YAAY,UAAU,YAAYA,eAAiB,UAAU,OAAO;EACpE,YAAY,eAAe,cAAc,YAAY,YAAY;CACnE,CAAC;CAGH,MAAM,eAAe;CAIrB,MAAM,aAAaA,eACjB,GAAG,OAAO,GAAG,EAAE,GAAG,gBAClB,aAAa,aAA0C,GAAG,CAC5D;CAEA,OAAO,cAAc,YAAY,YAAY;AAC/C"}

package/dist/esm/client/useIntlayer.mjs

@@ -42,7 +42,8 @@ const useIntlayer = (key, localeOrSelector) => {
 		contextVariant,
 		dictionaryKey: key
 	}) : localeOrSelector ?? currentLocale;
-	return useMemo(() => getIntlayer(key, argument), [key, typeof argument === "object" && argument !== null ? `${argument.locale ?? ""}|${getDictionarySelectorCacheKey(argument)}` : argument]);
+	const argumentIdentity = typeof argument === "object" && argument !== null ? `${argument.locale ?? ""}|${getDictionarySelectorCacheKey(argument)}` : argument;
+	return useMemo(() => getIntlayer(key, argument), [key, argumentIdentity]);
 };
 
 //#endregion

package/dist/esm/client/useIntlayer.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"useIntlayer.mjs","names":[],"sources":["../../../src/client/useIntlayer.ts"],"sourcesContent":["'use client';\n\nimport {\n  getDictionarySelectorCacheKey,\n  resolveDictionaryArgument,\n} from '@intlayer/core/dictionaryManipulator';\nimport type {\n  DeclaredLocales,\n  DictionaryKeys,\n  DictionarySelectorForKey,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { useContext, useMemo } from 'react';\nimport { getIntlayer } from '../getIntlayer';\nimport { IntlayerClientContext } from './IntlayerProvider';\n\n/**\n * Client-side hook that picks one dictionary by its key and returns its content.\n *\n * The second argument is either a locale or a selector object:\n * - `{ item: 2 }` — collection item (omit `item` to get every item as array)\n * - `{ variant: 'black-friday' }` — named variant (omit for the `default` one)\n * - `{ variant: ['black-friday', 'promo'] }` — ordered preference chain\n * - `locale` composes with any selector and overrides the context locale\n *\n * `locale` and `variant` both fall back to the surrounding `IntlayerProvider`\n * when the call does not pin them.\n *\n * @param key - The unique key of the dictionary to retrieve.\n * @param localeOrSelector - Optional locale or selector.\n * @returns The dictionary content for the resolved entry and locale.\n *\n * @example\n * ```tsx\n * import { useIntlayer } from 'react-intlayer';\n *\n * const MyComponent = () => {\n *   const content = useIntlayer('my-dictionary-key');\n *   const faq2 = useIntlayer('faq', { item: 2 });\n *\n *   return <div>{content.myField.value}</div>;\n * };\n * ```\n */\nexport const useIntlayer = <\n  const T extends DictionaryKeys,\n  const A extends LocalesValues | DictionarySelectorForKey<T> = DeclaredLocales,\n>(\n  key: T,\n  localeOrSelector?: A\n) => {\n  const { locale: currentLocale, variant: contextVariant } =\n    useContext(IntlayerClientContext) ?? {};\n\n  // Layers the provider's locale and variant under the call-site argument.\n  // Selectors disabled project-wide (build-time flag) ⇒ the argument can only\n  // be a locale, so the merge is dead code and is dropped by the bundler.\n  const argument =\n    process.env.INTLAYER_DICTIONARY_SELECTOR !== 'false'\n      ? resolveDictionaryArgument({\n          localeOrSelector,\n          contextLocale: currentLocale,\n          contextVariant,\n          dictionaryKey: key as string,\n        })\n      : (localeOrSelector ?? currentLocale);\n\n  // Stable identity of the resolved argument for memoization — a provider\n  // variant is often a fresh object literal on every render, so the dependency\n  // has to be its serialization, never its reference.\n  const argumentIdentity =\n    typeof argument === 'object' && argument !== null\n      ? `${argument.locale ?? ''}|${getDictionarySelectorCacheKey(argument)}`\n      : argument;\n\n  return useMemo(\n    () => getIntlayer<T, A>(key, argument as A),\n    [key, argumentIdentity]\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CA,MAAa,eAIX,KACA,qBACG;CACH,MAAM,EAAE,QAAQ,eAAe,SAAS,mBACtC,WAAW,qBAAqB,KAAK,CAAC;CAKxC,MAAM,WACJ,QAAQ,IAAI,iCAAiC,UACzC,0BAA0B;EACxB;EACA,eAAe;EACf;EACA,eAAe;CACjB,CAAC,IACA,oBAAoB;CAU3B,OAAO,cACC,YAAkB,KAAK,QAAa,GAC1C,CAAC,KAND,OAAO,aAAa,YAAY,aAAa,OACzC,GAAG,SAAS,UAAU,GAAG,GAAG,8BAA8B,QAAQ,MAClE,QAIkB,CACxB;AACF"}
+{"version":3,"file":"useIntlayer.mjs","names":[],"sources":["../../../src/client/useIntlayer.ts"],"sourcesContent":["'use client';\n\nimport {\n  getDictionarySelectorCacheKey,\n  resolveDictionaryArgument,\n} from '@intlayer/core/dictionaryManipulator';\nimport type {\n  DeclaredLocales,\n  DictionaryKeys,\n  DictionarySelectorForKey,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { useContext, useMemo } from 'react';\nimport { getIntlayer } from '../getIntlayer';\nimport { IntlayerClientContext } from './IntlayerProvider';\n\n/**\n * Client-side hook that picks one dictionary by its key and returns its content.\n *\n * The second argument is either a locale or a selector object:\n * - `{ item: 2 }` — collection item (omit `item` to get every item as array)\n * - `{ variant: 'black-friday' }` — named variant (omit for the `default` one)\n * - `{ variant: ['black-friday', 'promo'] }` — ordered preference chain\n * - `locale` composes with any selector and overrides the context locale\n *\n * `locale` and `variant` both fall back to the surrounding `IntlayerProvider`\n * when the call does not pin them.\n *\n * @param key - The unique key of the dictionary to retrieve.\n * @param localeOrSelector - Optional locale or selector.\n * @returns The dictionary content for the resolved entry and locale.\n *\n * @example\n * ```tsx\n * import { useIntlayer } from 'react-intlayer';\n *\n * const MyComponent = () => {\n *   const content = useIntlayer('my-dictionary-key');\n *   const faq2 = useIntlayer('faq', { item: 2 });\n *\n *   return <div>{content.myField.value}</div>;\n * };\n * ```\n */\nexport const useIntlayer = <\n  const T extends DictionaryKeys,\n  const A extends LocalesValues | DictionarySelectorForKey<T> = DeclaredLocales,\n>(\n  key: T,\n  localeOrSelector?: A\n) => {\n  const { locale: currentLocale, variant: contextVariant } =\n    useContext(IntlayerClientContext) ?? {};\n\n  // Layers the provider's locale and variant under the call-site argument.\n  // Selectors disabled project-wide (build-time flag) ⇒ the argument can only\n  // be a locale, so the merge is dead code and is dropped by the bundler.\n  const argument =\n    process.env.INTLAYER_DICTIONARY_SELECTOR !== 'false'\n      ? resolveDictionaryArgument({\n          localeOrSelector,\n          contextLocale: currentLocale,\n          contextVariant,\n          dictionaryKey: key as string,\n        })\n      : (localeOrSelector ?? currentLocale);\n\n  // Stable identity of the resolved argument for memoization — a provider\n  // variant is often a fresh object literal on every render, so the dependency\n  // has to be its serialization, never its reference.\n  const argumentIdentity =\n    typeof argument === 'object' && argument !== null\n      ? `${argument.locale ?? ''}|${getDictionarySelectorCacheKey(argument)}`\n      : argument;\n\n  return useMemo(\n    () => getIntlayer<T, A>(key, argument as A),\n    [key, argumentIdentity]\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CA,MAAa,eAIX,KACA,qBACG;CACH,MAAM,EAAE,QAAQ,eAAe,SAAS,mBACtC,WAAW,qBAAqB,KAAK,CAAC;CAKxC,MAAM,WACJ,QAAQ,IAAI,iCAAiC,UACzC,0BAA0B;EACxB;EACA,eAAe;EACf;EACA,eAAe;CACjB,CAAC,IACA,oBAAoB;CAK3B,MAAM,mBACJ,OAAO,aAAa,YAAY,aAAa,OACzC,GAAG,SAAS,UAAU,GAAG,GAAG,8BAA8B,QAAQ,MAClE;CAEN,OAAO,cACC,YAAkB,KAAK,QAAa,GAC1C,CAAC,KAAK,gBAAgB,CACxB;AACF"}

package/dist/esm/editor/useEditor.mjs

@@ -19,12 +19,12 @@ const useEditor = () => {
 			const manager = initEditorClient();
 			managerRef.current = manager;
 			if (locale) manager.currentLocale.set(locale);
-		});
+		}).catch(() => {});
 		return () => {
 			managerRef.current = null;
 			import("@intlayer/editor").then(({ stopEditorClient }) => {
 				stopEditorClient();
-			});
+			}).catch(() => {});
 		};
 	}, []);
 	useEffect(() => {

package/dist/esm/editor/useEditor.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"useEditor.mjs","names":[],"sources":["../../../src/editor/useEditor.tsx"],"sourcesContent":["'use client';\n\nimport type { EditorStateManager } from '@intlayer/editor';\nimport { isEnabled } from '@intlayer/editor/isEnabled';\nimport type { Locale } from '@intlayer/types/allLocales';\nimport { useContext, useEffect, useRef } from 'react';\nimport { IntlayerClientContext } from '../client/IntlayerProvider';\n\n/**\n * Initializes the Intlayer editor client singleton when the editor is enabled.\n * Syncs the current locale from the Intlayer context into the editor manager so\n * the editor always knows which locale the app is displaying.\n */\nexport const useEditor = () => {\n  const { locale } = useContext(IntlayerClientContext) ?? {};\n  const managerRef = useRef<EditorStateManager | null>(null);\n\n  useEffect(() => {\n    if (process.env.INTLAYER_EDITOR_ENABLED === 'false' || !isEnabled) return;\n\n    import('@intlayer/editor').then(({ initEditorClient }) => {\n      const manager = initEditorClient();\n      managerRef.current = manager;\n\n      if (locale) manager.currentLocale.set(locale as Locale);\n    });\n\n    return () => {\n      managerRef.current = null;\n      import('@intlayer/editor').then(({ stopEditorClient }) => {\n        stopEditorClient();\n      });\n    };\n  }, []);\n\n  useEffect(() => {\n    if (!locale || !managerRef.current) return;\n\n    managerRef.current.currentLocale.set(locale as Locale);\n  }, [locale]);\n};\n"],"mappings":";;;;;;;;;;;;AAaA,MAAa,kBAAkB;CAC7B,MAAM,EAAE,WAAW,WAAW,qBAAqB,KAAK,CAAC;CACzD,MAAM,aAAa,OAAkC,IAAI;CAEzD,gBAAgB;EACd,IAAI,QAAQ,IAAI,4BAA4B,WAAW,CAAC,WAAW;EAEnE,OAAO,mBAAmB,CAAC,MAAM,EAAE,uBAAuB;GACxD,MAAM,UAAU,iBAAiB;GACjC,WAAW,UAAU;GAErB,IAAI,QAAQ,QAAQ,cAAc,IAAI,MAAgB;EACxD,CAAC;EAED,aAAa;GACX,WAAW,UAAU;GACrB,OAAO,mBAAmB,CAAC,MAAM,EAAE,uBAAuB;IACxD,iBAAiB;GACnB,CAAC;EACH;CACF,GAAG,CAAC,CAAC;CAEL,gBAAgB;EACd,IAAI,CAAC,UAAU,CAAC,WAAW,SAAS;EAEpC,WAAW,QAAQ,cAAc,IAAI,MAAgB;CACvD,GAAG,CAAC,MAAM,CAAC;AACb"}
+{"version":3,"file":"useEditor.mjs","names":[],"sources":["../../../src/editor/useEditor.tsx"],"sourcesContent":["'use client';\n\nimport type { EditorStateManager } from '@intlayer/editor';\nimport { isEnabled } from '@intlayer/editor/isEnabled';\nimport type { Locale } from '@intlayer/types/allLocales';\nimport { useContext, useEffect, useRef } from 'react';\nimport { IntlayerClientContext } from '../client/IntlayerProvider';\n\n/**\n * Initializes the Intlayer editor client singleton when the editor is enabled.\n * Syncs the current locale from the Intlayer context into the editor manager so\n * the editor always knows which locale the app is displaying.\n */\nexport const useEditor = () => {\n  const { locale } = useContext(IntlayerClientContext) ?? {};\n  const managerRef = useRef<EditorStateManager | null>(null);\n\n  useEffect(() => {\n    if (process.env.INTLAYER_EDITOR_ENABLED === 'false' || !isEnabled) return;\n\n    import('@intlayer/editor')\n      .then(({ initEditorClient }) => {\n        const manager = initEditorClient();\n        managerRef.current = manager;\n\n        if (locale) manager.currentLocale.set(locale as Locale);\n      })\n      .catch(() => {});\n\n    return () => {\n      managerRef.current = null;\n      import('@intlayer/editor')\n        .then(({ stopEditorClient }) => {\n          stopEditorClient();\n        })\n        .catch(() => {});\n    };\n  }, []);\n\n  useEffect(() => {\n    if (!locale || !managerRef.current) return;\n\n    managerRef.current.currentLocale.set(locale as Locale);\n  }, [locale]);\n};\n"],"mappings":";;;;;;;;;;;;AAaA,MAAa,kBAAkB;CAC7B,MAAM,EAAE,WAAW,WAAW,qBAAqB,KAAK,CAAC;CACzD,MAAM,aAAa,OAAkC,IAAI;CAEzD,gBAAgB;EACd,IAAI,QAAQ,IAAI,4BAA4B,WAAW,CAAC,WAAW;EAEnE,OAAO,mBAAmB,CACvB,MAAM,EAAE,uBAAuB;GAC9B,MAAM,UAAU,iBAAiB;GACjC,WAAW,UAAU;GAErB,IAAI,QAAQ,QAAQ,cAAc,IAAI,MAAgB;EACxD,CAAC,CAAC,CACD,YAAY,CAAC,CAAC;EAEjB,aAAa;GACX,WAAW,UAAU;GACrB,OAAO,mBAAmB,CACvB,MAAM,EAAE,uBAAuB;IAC9B,iBAAiB;GACnB,CAAC,CAAC,CACD,YAAY,CAAC,CAAC;EACnB;CACF,GAAG,CAAC,CAAC;CAEL,gBAAgB;EACd,IAAI,CAAC,UAAU,CAAC,WAAW,SAAS;EAEpC,WAAW,QAAQ,cAAc,IAAI,MAAgB;CACvD,GAAG,CAAC,MAAM,CAAC;AACb"}

package/dist/esm/getDictionary.mjs

@@ -8,7 +8,8 @@ import { getDictionary as getDictionary$1 } from "@intlayer/core/interpreter";
 * optionally combined with `locale`).
 */
 const getDictionary = (dictionary, localeOrSelector) => {
-	return getDictionary$1(dictionary, localeOrSelector, getPlugins(typeof localeOrSelector === "object" && localeOrSelector !== null ? localeOrSelector.locale : localeOrSelector));
+	const locale = typeof localeOrSelector === "object" && localeOrSelector !== null ? localeOrSelector.locale : localeOrSelector;
+	return getDictionary$1(dictionary, localeOrSelector, getPlugins(locale));
 };
 
 //#endregion

package/dist/esm/getDictionary.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"getDictionary.mjs","names":["getDictionaryCore"],"sources":["../../src/getDictionary.ts"],"sourcesContent":["import { getDictionary as getDictionaryCore } from '@intlayer/core/interpreter';\nimport type {\n  Dictionary,\n  DictionarySelectorForGroup,\n  QualifiedDictionaryGroup,\n  ResolveQualifiedDictionaryContent,\n} from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  ExtractSelectorLocale,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { type DeepTransformContent, getPlugins } from './plugins';\n\n/**\n * Transforms a dictionary (or qualified dictionary group) and returns its\n * content for the given locale or selector (`{ item }`, `{ variant }`,\n * optionally combined with `locale`).\n */\nexport const getDictionary = <\n  const T extends Dictionary | QualifiedDictionaryGroup,\n  const A extends\n    | LocalesValues\n    | DictionarySelectorForGroup<T> = DeclaredLocales,\n>(\n  dictionary: T,\n  localeOrSelector?: A\n): DeepTransformContent<\n  ResolveQualifiedDictionaryContent<T, A>,\n  ExtractSelectorLocale<A>\n> => {\n  const locale = (\n    typeof localeOrSelector === 'object' && localeOrSelector !== null\n      ? localeOrSelector.locale\n      : localeOrSelector\n  ) as LocalesValues | undefined;\n\n  return getDictionaryCore(\n    dictionary,\n    localeOrSelector,\n    getPlugins(locale)\n  ) as any;\n};\n"],"mappings":";;;;;;;;;AAmBA,MAAa,iBAMX,YACA,qBAIG;CAOH,OAAOA,gBACL,YACA,kBACA,WARA,OAAO,qBAAqB,YAAY,qBAAqB,OACzD,iBAAiB,SACjB,gBAMa,CACnB;AACF"}
+{"version":3,"file":"getDictionary.mjs","names":["getDictionaryCore"],"sources":["../../src/getDictionary.ts"],"sourcesContent":["import { getDictionary as getDictionaryCore } from '@intlayer/core/interpreter';\nimport type {\n  Dictionary,\n  DictionarySelectorForGroup,\n  QualifiedDictionaryGroup,\n  ResolveQualifiedDictionaryContent,\n} from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  ExtractSelectorLocale,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { type DeepTransformContent, getPlugins } from './plugins';\n\n/**\n * Transforms a dictionary (or qualified dictionary group) and returns its\n * content for the given locale or selector (`{ item }`, `{ variant }`,\n * optionally combined with `locale`).\n */\nexport const getDictionary = <\n  const T extends Dictionary | QualifiedDictionaryGroup,\n  const A extends\n    | LocalesValues\n    | DictionarySelectorForGroup<T> = DeclaredLocales,\n>(\n  dictionary: T,\n  localeOrSelector?: A\n): DeepTransformContent<\n  ResolveQualifiedDictionaryContent<T, A>,\n  ExtractSelectorLocale<A>\n> => {\n  const locale = (\n    typeof localeOrSelector === 'object' && localeOrSelector !== null\n      ? localeOrSelector.locale\n      : localeOrSelector\n  ) as LocalesValues | undefined;\n\n  return getDictionaryCore(\n    dictionary,\n    localeOrSelector,\n    getPlugins(locale)\n  ) as any;\n};\n"],"mappings":";;;;;;;;;AAmBA,MAAa,iBAMX,YACA,qBAIG;CACH,MAAM,SACJ,OAAO,qBAAqB,YAAY,qBAAqB,OACzD,iBAAiB,SACjB;CAGN,OAAOA,gBACL,YACA,kBACA,WAAW,MAAM,CACnB;AACF"}

package/dist/esm/getIntlayer.mjs

@@ -8,7 +8,8 @@ import { getIntlayer as getIntlayer$1 } from "@intlayer/core/interpreter";
 * optionally combined with `locale`).
 */
 const getIntlayer = (key, localeOrSelector) => {
-	return getIntlayer$1(key, localeOrSelector, getPlugins(typeof localeOrSelector === "object" && localeOrSelector !== null ? localeOrSelector.locale : localeOrSelector));
+	const locale = typeof localeOrSelector === "object" && localeOrSelector !== null ? localeOrSelector.locale : localeOrSelector;
+	return getIntlayer$1(key, localeOrSelector, getPlugins(locale));
 };
 
 //#endregion

package/dist/esm/getIntlayer.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"getIntlayer.mjs","names":["getIntlayerCore"],"sources":["../../src/getIntlayer.ts"],"sourcesContent":["import { getIntlayer as getIntlayerCore } from '@intlayer/core/interpreter';\nimport type {\n  DeclaredLocales,\n  DictionaryKeys,\n  DictionaryRegistryResult,\n  DictionarySelectorForKey,\n  ExtractSelectorLocale,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { type DeepTransformContent, getPlugins } from './plugins';\n\n/**\n * Picks one dictionary by its key and returns its content for the given\n * locale or selector (`{ item }`, `{ variant }`,\n * optionally combined with `locale`).\n */\nexport const getIntlayer = <\n  const T extends DictionaryKeys,\n  const A extends LocalesValues | DictionarySelectorForKey<T> = DeclaredLocales,\n>(\n  key: T,\n  localeOrSelector?: A\n): DeepTransformContent<\n  DictionaryRegistryResult<T, A>,\n  ExtractSelectorLocale<A>\n> => {\n  const locale = (\n    typeof localeOrSelector === 'object' && localeOrSelector !== null\n      ? localeOrSelector.locale\n      : localeOrSelector\n  ) as LocalesValues | undefined;\n\n  return getIntlayerCore(key, localeOrSelector, getPlugins(locale)) as any;\n};\n"],"mappings":";;;;;;;;;AAgBA,MAAa,eAIX,KACA,qBAIG;CAOH,OAAOA,cAAgB,KAAK,kBAAkB,WAL5C,OAAO,qBAAqB,YAAY,qBAAqB,OACzD,iBAAiB,SACjB,gBAGyD,CAAC;AAClE"}
+{"version":3,"file":"getIntlayer.mjs","names":["getIntlayerCore"],"sources":["../../src/getIntlayer.ts"],"sourcesContent":["import { getIntlayer as getIntlayerCore } from '@intlayer/core/interpreter';\nimport type {\n  DeclaredLocales,\n  DictionaryKeys,\n  DictionaryRegistryResult,\n  DictionarySelectorForKey,\n  ExtractSelectorLocale,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { type DeepTransformContent, getPlugins } from './plugins';\n\n/**\n * Picks one dictionary by its key and returns its content for the given\n * locale or selector (`{ item }`, `{ variant }`,\n * optionally combined with `locale`).\n */\nexport const getIntlayer = <\n  const T extends DictionaryKeys,\n  const A extends LocalesValues | DictionarySelectorForKey<T> = DeclaredLocales,\n>(\n  key: T,\n  localeOrSelector?: A\n): DeepTransformContent<\n  DictionaryRegistryResult<T, A>,\n  ExtractSelectorLocale<A>\n> => {\n  const locale = (\n    typeof localeOrSelector === 'object' && localeOrSelector !== null\n      ? localeOrSelector.locale\n      : localeOrSelector\n  ) as LocalesValues | undefined;\n\n  return getIntlayerCore(key, localeOrSelector, getPlugins(locale)) as any;\n};\n"],"mappings":";;;;;;;;;AAgBA,MAAa,eAIX,KACA,qBAIG;CACH,MAAM,SACJ,OAAO,qBAAqB,YAAY,qBAAqB,OACzD,iBAAiB,SACjB;CAGN,OAAOA,cAAgB,KAAK,kBAAkB,WAAW,MAAM,CAAC;AAClE"}

package/dist/esm/html/HTMLRenderer.mjs

@@ -15,13 +15,14 @@ import { VOID_HTML_ELEMENTS } from "@intlayer/core/transpiler";
 */
 const renderHTML = (content, { components = {} } = {}) => {
 	const userComponents = Object.fromEntries(Object.entries(components).filter(([, Component]) => Component).map(([key, Component]) => [key, (props) => createElement(Component, props)]));
-	return /* @__PURE__ */ jsx(Fragment, { children: getHTML(content, new Proxy(userComponents, { get(target, prop) {
+	const wrappedComponents = new Proxy(userComponents, { get(target, prop) {
 		if (typeof prop === "string" && prop in target) return target[prop];
 		if (typeof prop === "string" && /^[a-z][a-z0-9]*$/.test(prop)) {
 			if (VOID_HTML_ELEMENTS.has(prop)) return ({ children: _children, ...rest }) => createElement(prop, rest);
 			return (props) => createElement(prop, props);
 		}
-	} })) });
+	} });
+	return /* @__PURE__ */ jsx(Fragment, { children: getHTML(content, wrappedComponents) });
 };
 /**
 * Hook that returns a function to render HTML content.

package/dist/esm/html/HTMLRenderer.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"HTMLRenderer.mjs","names":[],"sources":["../../../src/html/HTMLRenderer.tsx"],"sourcesContent":["'use client';\n\nimport { getHTML } from '@intlayer/core/interpreter';\nimport { VOID_HTML_ELEMENTS } from '@intlayer/core/transpiler';\nimport { createElement, type FC, Fragment, type JSX } from 'react';\nimport type { HTMLComponents } from './HTMLComponentTypes';\nimport { useHTMLContext } from './HTMLProvider';\n\nexport type RenderHTMLProps = {\n  /**\n   * Component overrides for HTML tags.\n   * Allows you to customize how specific HTML elements are rendered.\n   */\n  components?: HTMLComponents<'permissive', {}>;\n};\n\n/**\n * Renders HTML-like content to JSX with the provided components.\n *\n * This function does not use context from HTMLProvider. Use `useHTMLRenderer`\n * hook if you want to leverage provider context.\n */\nexport const renderHTML = (\n  content: string,\n  { components = {} }: RenderHTMLProps = {}\n): JSX.Element => {\n  // Wrap explicit user components to ensure they are rendered via React.createElement\n  const userComponents = Object.fromEntries(\n    Object.entries(components)\n      .filter(([, Component]) => Component)\n      .map(([key, Component]) => [\n        key,\n        (props: any) => createElement(Component as any, props),\n      ])\n  );\n\n  // Proxy handles standard HTML tags lazily without a hardcoded list\n  const wrappedComponents = new Proxy(userComponents, {\n    get(target, prop) {\n      if (typeof prop === 'string' && prop in target) {\n        return target[prop];\n      }\n      // Fallback: Lazily generate a wrapper for standard lowercase HTML tags\n      if (typeof prop === 'string' && /^[a-z][a-z0-9]*$/.test(prop)) {\n        if (VOID_HTML_ELEMENTS.has(prop)) {\n          // Void elements cannot have children — strip them to avoid React error\n          return ({ children: _children, ...rest }: any) =>\n            createElement(prop, rest);\n        }\n        return (props: any) => createElement(prop, props);\n      }\n      return undefined;\n    },\n  });\n\n  return <Fragment>{getHTML(content, wrappedComponents as any)}</Fragment>;\n};\n\n/**\n * Hook that returns a function to render HTML content.\n *\n * This hook considers the configuration from the `HTMLProvider` context if available,\n * falling back to the provided components.\n */\nexport const useHTMLRenderer = ({ components }: RenderHTMLProps = {}) => {\n  const context = useHTMLContext();\n\n  return (content: string) => {\n    return renderHTML(content, {\n      components: {\n        ...context?.components,\n        ...components,\n      },\n    });\n  };\n};\n\nexport type HTMLRendererProps = RenderHTMLProps & {\n  /**\n   * The HTML content to render as a string.\n   */\n  children: string;\n};\n\n/**\n * React component that renders HTML-like content to JSX.\n *\n * This component uses the components from the `HTMLProvider` context\n * if available.\n */\nexport const HTMLRenderer: FC<HTMLRendererProps> = ({\n  children = '',\n  components,\n}) => {\n  const render = useHTMLRenderer({ components });\n\n  return render(children);\n};\n"],"mappings":";;;;;;;;;;;;;;;AAsBA,MAAa,cACX,SACA,EAAE,aAAa,CAAC,MAAuB,CAAC,MACxB;CAEhB,MAAM,iBAAiB,OAAO,YAC5B,OAAO,QAAQ,UAAU,CAAC,CACvB,QAAQ,GAAG,eAAe,SAAS,CAAC,CACpC,KAAK,CAAC,KAAK,eAAe,CACzB,MACC,UAAe,cAAc,WAAkB,KAAK,CACvD,CAAC,CACL;CAqBA,OAAO,oBAAC,UAAD,YAAW,QAAQ,SAAS,IAlBL,MAAM,gBAAgB,EAClD,IAAI,QAAQ,MAAM;EAChB,IAAI,OAAO,SAAS,YAAY,QAAQ,QACtC,OAAO,OAAO;EAGhB,IAAI,OAAO,SAAS,YAAY,mBAAmB,KAAK,IAAI,GAAG;GAC7D,IAAI,mBAAmB,IAAI,IAAI,GAE7B,QAAQ,EAAE,UAAU,WAAW,GAAG,WAChC,cAAc,MAAM,IAAI;GAE5B,QAAQ,UAAe,cAAc,MAAM,KAAK;EAClD;CAEF,EACF,CAEmD,CAAQ,EAAY;AACzE;;;;;;;AAQA,MAAa,mBAAmB,EAAE,eAAgC,CAAC,MAAM;CACvE,MAAM,UAAU,eAAe;CAE/B,QAAQ,YAAoB;EAC1B,OAAO,WAAW,SAAS,EACzB,YAAY;GACV,GAAG,SAAS;GACZ,GAAG;EACL,EACF,CAAC;CACH;AACF;;;;;;;AAeA,MAAa,gBAAuC,EAClD,WAAW,IACX,iBACI;CAGJ,OAFe,gBAAgB,EAAE,WAAW,CAEhC,CAAC,CAAC,QAAQ;AACxB"}
+{"version":3,"file":"HTMLRenderer.mjs","names":[],"sources":["../../../src/html/HTMLRenderer.tsx"],"sourcesContent":["'use client';\n\nimport { getHTML } from '@intlayer/core/interpreter';\nimport { VOID_HTML_ELEMENTS } from '@intlayer/core/transpiler';\nimport { createElement, type FC, Fragment, type JSX } from 'react';\nimport type { HTMLComponents } from './HTMLComponentTypes';\nimport { useHTMLContext } from './HTMLProvider';\n\nexport type RenderHTMLProps = {\n  /**\n   * Component overrides for HTML tags.\n   * Allows you to customize how specific HTML elements are rendered.\n   */\n  components?: HTMLComponents<'permissive', {}>;\n};\n\n/**\n * Renders HTML-like content to JSX with the provided components.\n *\n * This function does not use context from HTMLProvider. Use `useHTMLRenderer`\n * hook if you want to leverage provider context.\n */\nexport const renderHTML = (\n  content: string,\n  { components = {} }: RenderHTMLProps = {}\n): JSX.Element => {\n  // Wrap explicit user components to ensure they are rendered via React.createElement\n  const userComponents = Object.fromEntries(\n    Object.entries(components)\n      .filter(([, Component]) => Component)\n      .map(([key, Component]) => [\n        key,\n        (props: any) => createElement(Component as any, props),\n      ])\n  );\n\n  // Proxy handles standard HTML tags lazily without a hardcoded list\n  const wrappedComponents = new Proxy(userComponents, {\n    get(target, prop) {\n      if (typeof prop === 'string' && prop in target) {\n        return target[prop];\n      }\n      // Fallback: Lazily generate a wrapper for standard lowercase HTML tags\n      if (typeof prop === 'string' && /^[a-z][a-z0-9]*$/.test(prop)) {\n        if (VOID_HTML_ELEMENTS.has(prop)) {\n          // Void elements cannot have children — strip them to avoid React error\n          return ({ children: _children, ...rest }: any) =>\n            createElement(prop, rest);\n        }\n        return (props: any) => createElement(prop, props);\n      }\n      return undefined;\n    },\n  });\n\n  return <Fragment>{getHTML(content, wrappedComponents as any)}</Fragment>;\n};\n\n/**\n * Hook that returns a function to render HTML content.\n *\n * This hook considers the configuration from the `HTMLProvider` context if available,\n * falling back to the provided components.\n */\nexport const useHTMLRenderer = ({ components }: RenderHTMLProps = {}) => {\n  const context = useHTMLContext();\n\n  return (content: string) => {\n    return renderHTML(content, {\n      components: {\n        ...context?.components,\n        ...components,\n      },\n    });\n  };\n};\n\nexport type HTMLRendererProps = RenderHTMLProps & {\n  /**\n   * The HTML content to render as a string.\n   */\n  children: string;\n};\n\n/**\n * React component that renders HTML-like content to JSX.\n *\n * This component uses the components from the `HTMLProvider` context\n * if available.\n */\nexport const HTMLRenderer: FC<HTMLRendererProps> = ({\n  children = '',\n  components,\n}) => {\n  const render = useHTMLRenderer({ components });\n\n  return render(children);\n};\n"],"mappings":";;;;;;;;;;;;;;;AAsBA,MAAa,cACX,SACA,EAAE,aAAa,CAAC,MAAuB,CAAC,MACxB;CAEhB,MAAM,iBAAiB,OAAO,YAC5B,OAAO,QAAQ,UAAU,CAAC,CACvB,QAAQ,GAAG,eAAe,SAAS,CAAC,CACpC,KAAK,CAAC,KAAK,eAAe,CACzB,MACC,UAAe,cAAc,WAAkB,KAAK,CACvD,CAAC,CACL;CAGA,MAAM,oBAAoB,IAAI,MAAM,gBAAgB,EAClD,IAAI,QAAQ,MAAM;EAChB,IAAI,OAAO,SAAS,YAAY,QAAQ,QACtC,OAAO,OAAO;EAGhB,IAAI,OAAO,SAAS,YAAY,mBAAmB,KAAK,IAAI,GAAG;GAC7D,IAAI,mBAAmB,IAAI,IAAI,GAE7B,QAAQ,EAAE,UAAU,WAAW,GAAG,WAChC,cAAc,MAAM,IAAI;GAE5B,QAAQ,UAAe,cAAc,MAAM,KAAK;EAClD;CAEF,EACF,CAAC;CAED,OAAO,oBAAC,UAAD,YAAW,QAAQ,SAAS,iBAAwB,EAAY;AACzE;;;;;;;AAQA,MAAa,mBAAmB,EAAE,eAAgC,CAAC,MAAM;CACvE,MAAM,UAAU,eAAe;CAE/B,QAAQ,YAAoB;EAC1B,OAAO,WAAW,SAAS,EACzB,YAAY;GACV,GAAG,SAAS;GACZ,GAAG;EACL,EACF,CAAC;CACH;AACF;;;;;;;AAeA,MAAa,gBAAuC,EAClD,WAAW,IACX,iBACI;CAGJ,OAFe,gBAAgB,EAAE,WAAW,CAEhC,CAAC,CAAC,QAAQ;AACxB"}

package/dist/esm/html/HTMLRendererPlugin.mjs

@@ -4,8 +4,9 @@ import { renderHTML } from "./HTMLRenderer.mjs";
 //#region src/html/HTMLRendererPlugin.tsx
 const HTMLRendererPlugin = (props) => {
 	const { html, userComponents } = props;
+	const context = useHTMLContext();
 	return renderHTML(html, { components: {
-		...useHTMLContext()?.components,
+		...context?.components,
 		...userComponents
 	} });
 };

package/dist/esm/html/HTMLRendererPlugin.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"HTMLRendererPlugin.mjs","names":[],"sources":["../../../src/html/HTMLRendererPlugin.tsx"],"sourcesContent":["import type { FC, ReactNode } from 'react';\nimport { useHTMLContext } from './HTMLProvider';\nimport { renderHTML } from './HTMLRenderer';\n\ntype HTMLRendererPluginProps = {\n  html: string;\n  userComponents?: Record<string, any>;\n};\n\nexport const HTMLRendererPlugin: FC<HTMLRendererPluginProps> = (\n  props\n): ReactNode => {\n  const { html, userComponents } = props;\n  const context = useHTMLContext();\n\n  return renderHTML(html, {\n    components: {\n      ...context?.components,\n      ...userComponents,\n    },\n  });\n};\n"],"mappings":";;;;AASA,MAAa,sBACX,UACc;CACd,MAAM,EAAE,MAAM,mBAAmB;CAGjC,OAAO,WAAW,MAAM,EACtB,YAAY;EACV,GAJY,eAIH,CAAC,EAAE;EACZ,GAAG;CACL,EACF,CAAC;AACH"}
+{"version":3,"file":"HTMLRendererPlugin.mjs","names":[],"sources":["../../../src/html/HTMLRendererPlugin.tsx"],"sourcesContent":["import type { FC, ReactNode } from 'react';\nimport { useHTMLContext } from './HTMLProvider';\nimport { renderHTML } from './HTMLRenderer';\n\ntype HTMLRendererPluginProps = {\n  html: string;\n  userComponents?: Record<string, any>;\n};\n\nexport const HTMLRendererPlugin: FC<HTMLRendererPluginProps> = (\n  props\n): ReactNode => {\n  const { html, userComponents } = props;\n  const context = useHTMLContext();\n\n  return renderHTML(html, {\n    components: {\n      ...context?.components,\n      ...userComponents,\n    },\n  });\n};\n"],"mappings":";;;;AASA,MAAa,sBACX,UACc;CACd,MAAM,EAAE,MAAM,mBAAmB;CACjC,MAAM,UAAU,eAAe;CAE/B,OAAO,WAAW,MAAM,EACtB,YAAY;EACV,GAAG,SAAS;EACZ,GAAG;CACL,EACF,CAAC;AACH"}

package/dist/esm/markdown/MarkdownProvider.mjs

@@ -65,7 +65,8 @@ const MarkdownProvider = ({ children, components, wrapper, forceBlock, forceInli
 		tagfilter
 	};
 	const defaultRenderMarkdown = (markdown, options, components, wrapper) => {
-		return compileMarkdown(markdown, mergeOptions(baseOptions, options, components, wrapper));
+		const mergedOptions = mergeOptions(baseOptions, options, components, wrapper);
+		return compileMarkdown(markdown, mergedOptions);
 	};
 	const customRenderMarkdownWrapper = (markdown, options, components, wrapper) => /* @__PURE__ */ jsx(MarkdownContext.Provider, {
 		value: void 0,

package/dist/esm/markdown/MarkdownProvider.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"MarkdownProvider.mjs","names":[],"sources":["../../../src/markdown/MarkdownProvider.tsx"],"sourcesContent":["'use client';\n\nimport {\n  createContext,\n  type FC,\n  type HTMLAttributes,\n  type PropsWithChildren,\n  type ReactNode,\n  useContext,\n} from 'react';\nimport type { HTMLComponents } from '../html/HTMLComponentTypes';\nimport {\n  compileMarkdown,\n  type MarkdownRendererOptions,\n  type ParsedMarkdown,\n} from './processor';\n\nexport type MarkdownProviderOptions = {\n  /** Forces the compiler to always output content with a block-level wrapper. */\n  forceBlock?: boolean;\n  /** Forces the compiler to always output content with an inline wrapper. */\n  forceInline?: boolean;\n  /** Whether to preserve frontmatter in the markdown content. */\n  preserveFrontmatter?: boolean;\n  /** Whether to use the GitHub Tag Filter for security. */\n  tagfilter?: boolean;\n};\n\ntype MarkdownContextValue = {\n  components?: HTMLComponents<'permissive', {}>;\n  renderMarkdown: (\n    markdown: string | ParsedMarkdown,\n    options?: MarkdownProviderOptions,\n    components?: HTMLComponents<'permissive', {}>,\n    wrapper?: FC<HTMLAttributes<HTMLElement>>\n  ) => ReactNode | Promise<ReactNode>;\n};\n\ntype MarkdownProviderProps = PropsWithChildren<\n  MarkdownProviderOptions & {\n    components?: HTMLComponents<'permissive', {}>;\n    wrapper?: FC<HTMLAttributes<HTMLElement>>;\n    renderMarkdown?: (\n      markdown: string | ParsedMarkdown,\n      options?: MarkdownProviderOptions,\n      components?: HTMLComponents<'permissive', {}>,\n      wrapper?: FC<HTMLAttributes<HTMLElement>>\n    ) => ReactNode | Promise<ReactNode>;\n  }\n>;\n\nconst MarkdownContext = createContext<MarkdownContextValue | undefined>(\n  undefined\n);\n\n/**\n * Returns the raw `MarkdownProvider` context value — the active\n * `renderMarkdown` function plus any provider-level component overrides.\n * Returns `undefined` when called outside a `<MarkdownProvider>`.\n * Prefer `useMarkdownRenderer` for most use cases; use this hook only when\n * you need direct access to the context object itself.\n */\nexport const useMarkdownContext = () => useContext(MarkdownContext);\n\nconst mergeOptions = (\n  baseOptions: MarkdownRendererOptions,\n  options: MarkdownProviderOptions = {},\n  components: HTMLComponents<'permissive', {}> = {},\n  wrapper?: FC<HTMLAttributes<HTMLElement>>\n): MarkdownRendererOptions => {\n  return {\n    ...baseOptions,\n    ...options,\n    forceBlock: options.forceBlock ?? baseOptions.forceBlock,\n    forceInline: options.forceInline ?? baseOptions.forceInline,\n    preserveFrontmatter:\n      options.preserveFrontmatter ?? baseOptions.preserveFrontmatter,\n    tagfilter: options.tagfilter ?? baseOptions.tagfilter,\n    wrapper: wrapper || baseOptions.wrapper,\n\n    forceWrapper: !!(wrapper || baseOptions.wrapper),\n    components: { ...baseOptions.components, ...components },\n  };\n};\n\n/**\n * Provider for the MarkdownRenderer component.\n *\n * It will provide the `renderMarkdown` function to the context, which can be used to render markdown.\n *\n * ```tsx\n * const content = useIntlayer('app');\n *\n * return (\n *   <div>\n *     {content.markdown} // Will be rendered with the components and options provided to the MarkdownProvider\n *   </div>\n * );\n * ```\n *\n * @example\n * ```tsx\n * <MarkdownProvider components={{ h1: CustomHeading }}>\n *   <MarkdownRenderer>\n *     {markdownContent}\n *   </MarkdownRenderer>\n * </MarkdownProvider>\n * ```\n */\nexport const MarkdownProvider: FC<MarkdownProviderProps> = ({\n  children,\n  components,\n  wrapper,\n  forceBlock,\n  forceInline,\n  preserveFrontmatter,\n  tagfilter,\n  renderMarkdown: customRenderFn,\n}) => {\n  const baseOptions: MarkdownRendererOptions = {\n    components,\n    forceBlock,\n    forceInline,\n    wrapper,\n    forceWrapper: !!wrapper,\n    preserveFrontmatter,\n    tagfilter,\n  };\n\n  // Standard internal renderer\n  const defaultRenderMarkdown = (\n    markdown: string | ParsedMarkdown,\n    options?: MarkdownProviderOptions,\n    components?: HTMLComponents<'permissive', {}>,\n    wrapper?: FC<HTMLAttributes<HTMLElement>>\n  ) => {\n    const mergedOptions = mergeOptions(\n      baseOptions,\n      options,\n      components,\n      wrapper\n    );\n\n    return compileMarkdown(markdown, mergedOptions);\n  };\n\n  // Wrapper for user-provided custom renderer\n  // Note: We wrap in a clean Provider to prevent infinite recursion\n  const customRenderMarkdownWrapper = (\n    markdown: string | ParsedMarkdown,\n    options?: MarkdownProviderOptions,\n    components?: HTMLComponents<'permissive', {}>,\n    wrapper?: FC<HTMLAttributes<HTMLElement>>\n  ) => (\n    <MarkdownContext.Provider value={undefined}>\n      {customRenderFn?.(markdown, options, components, wrapper) as ReactNode}\n    </MarkdownContext.Provider>\n  );\n\n  return (\n    <MarkdownContext.Provider\n      value={{\n        components,\n        renderMarkdown: customRenderFn\n          ? customRenderMarkdownWrapper\n          : defaultRenderMarkdown,\n      }}\n    >\n      {children}\n    </MarkdownContext.Provider>\n  );\n};\n"],"mappings":";;;;;;;AAmDA,MAAM,kBAAkB,cACtB,MACF;;;;;;;;AASA,MAAa,2BAA2B,WAAW,eAAe;AAElE,MAAM,gBACJ,aACA,UAAmC,CAAC,GACpC,aAA+C,CAAC,GAChD,YAC4B;CAC5B,OAAO;EACL,GAAG;EACH,GAAG;EACH,YAAY,QAAQ,cAAc,YAAY;EAC9C,aAAa,QAAQ,eAAe,YAAY;EAChD,qBACE,QAAQ,uBAAuB,YAAY;EAC7C,WAAW,QAAQ,aAAa,YAAY;EAC5C,SAAS,WAAW,YAAY;EAEhC,cAAc,CAAC,EAAE,WAAW,YAAY;EACxC,YAAY;GAAE,GAAG,YAAY;GAAY,GAAG;EAAW;CACzD;AACF;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,MAAa,oBAA+C,EAC1D,UACA,YACA,SACA,YACA,aACA,qBACA,WACA,gBAAgB,qBACZ;CACJ,MAAM,cAAuC;EAC3C;EACA;EACA;EACA;EACA,cAAc,CAAC,CAAC;EAChB;EACA;CACF;CAGA,MAAM,yBACJ,UACA,SACA,YACA,YACG;EAQH,OAAO,gBAAgB,UAPD,aACpB,aACA,SACA,YACA,OAG2C,CAAC;CAChD;CAIA,MAAM,+BACJ,UACA,SACA,YACA,YAEA,oBAAC,gBAAgB,UAAjB;EAA0B,OAAO;YAC9B,iBAAiB,UAAU,SAAS,YAAY,OAAO;CAChC;CAG5B,OACE,oBAAC,gBAAgB,UAAjB;EACE,OAAO;GACL;GACA,gBAAgB,iBACZ,8BACA;EACN;EAEC;CACuB;AAE9B"}
+{"version":3,"file":"MarkdownProvider.mjs","names":[],"sources":["../../../src/markdown/MarkdownProvider.tsx"],"sourcesContent":["'use client';\n\nimport {\n  createContext,\n  type FC,\n  type HTMLAttributes,\n  type PropsWithChildren,\n  type ReactNode,\n  useContext,\n} from 'react';\nimport type { HTMLComponents } from '../html/HTMLComponentTypes';\nimport {\n  compileMarkdown,\n  type MarkdownRendererOptions,\n  type ParsedMarkdown,\n} from './processor';\n\nexport type MarkdownProviderOptions = {\n  /** Forces the compiler to always output content with a block-level wrapper. */\n  forceBlock?: boolean;\n  /** Forces the compiler to always output content with an inline wrapper. */\n  forceInline?: boolean;\n  /** Whether to preserve frontmatter in the markdown content. */\n  preserveFrontmatter?: boolean;\n  /** Whether to use the GitHub Tag Filter for security. */\n  tagfilter?: boolean;\n};\n\ntype MarkdownContextValue = {\n  components?: HTMLComponents<'permissive', {}>;\n  renderMarkdown: (\n    markdown: string | ParsedMarkdown,\n    options?: MarkdownProviderOptions,\n    components?: HTMLComponents<'permissive', {}>,\n    wrapper?: FC<HTMLAttributes<HTMLElement>>\n  ) => ReactNode | Promise<ReactNode>;\n};\n\ntype MarkdownProviderProps = PropsWithChildren<\n  MarkdownProviderOptions & {\n    components?: HTMLComponents<'permissive', {}>;\n    wrapper?: FC<HTMLAttributes<HTMLElement>>;\n    renderMarkdown?: (\n      markdown: string | ParsedMarkdown,\n      options?: MarkdownProviderOptions,\n      components?: HTMLComponents<'permissive', {}>,\n      wrapper?: FC<HTMLAttributes<HTMLElement>>\n    ) => ReactNode | Promise<ReactNode>;\n  }\n>;\n\nconst MarkdownContext = createContext<MarkdownContextValue | undefined>(\n  undefined\n);\n\n/**\n * Returns the raw `MarkdownProvider` context value — the active\n * `renderMarkdown` function plus any provider-level component overrides.\n * Returns `undefined` when called outside a `<MarkdownProvider>`.\n * Prefer `useMarkdownRenderer` for most use cases; use this hook only when\n * you need direct access to the context object itself.\n */\nexport const useMarkdownContext = () => useContext(MarkdownContext);\n\nconst mergeOptions = (\n  baseOptions: MarkdownRendererOptions,\n  options: MarkdownProviderOptions = {},\n  components: HTMLComponents<'permissive', {}> = {},\n  wrapper?: FC<HTMLAttributes<HTMLElement>>\n): MarkdownRendererOptions => {\n  return {\n    ...baseOptions,\n    ...options,\n    forceBlock: options.forceBlock ?? baseOptions.forceBlock,\n    forceInline: options.forceInline ?? baseOptions.forceInline,\n    preserveFrontmatter:\n      options.preserveFrontmatter ?? baseOptions.preserveFrontmatter,\n    tagfilter: options.tagfilter ?? baseOptions.tagfilter,\n    wrapper: wrapper || baseOptions.wrapper,\n\n    forceWrapper: !!(wrapper || baseOptions.wrapper),\n    components: { ...baseOptions.components, ...components },\n  };\n};\n\n/**\n * Provider for the MarkdownRenderer component.\n *\n * It will provide the `renderMarkdown` function to the context, which can be used to render markdown.\n *\n * ```tsx\n * const content = useIntlayer('app');\n *\n * return (\n *   <div>\n *     {content.markdown} // Will be rendered with the components and options provided to the MarkdownProvider\n *   </div>\n * );\n * ```\n *\n * @example\n * ```tsx\n * <MarkdownProvider components={{ h1: CustomHeading }}>\n *   <MarkdownRenderer>\n *     {markdownContent}\n *   </MarkdownRenderer>\n * </MarkdownProvider>\n * ```\n */\nexport const MarkdownProvider: FC<MarkdownProviderProps> = ({\n  children,\n  components,\n  wrapper,\n  forceBlock,\n  forceInline,\n  preserveFrontmatter,\n  tagfilter,\n  renderMarkdown: customRenderFn,\n}) => {\n  const baseOptions: MarkdownRendererOptions = {\n    components,\n    forceBlock,\n    forceInline,\n    wrapper,\n    forceWrapper: !!wrapper,\n    preserveFrontmatter,\n    tagfilter,\n  };\n\n  // Standard internal renderer\n  const defaultRenderMarkdown = (\n    markdown: string | ParsedMarkdown,\n    options?: MarkdownProviderOptions,\n    components?: HTMLComponents<'permissive', {}>,\n    wrapper?: FC<HTMLAttributes<HTMLElement>>\n  ) => {\n    const mergedOptions = mergeOptions(\n      baseOptions,\n      options,\n      components,\n      wrapper\n    );\n\n    return compileMarkdown(markdown, mergedOptions);\n  };\n\n  // Wrapper for user-provided custom renderer\n  // Note: We wrap in a clean Provider to prevent infinite recursion\n  const customRenderMarkdownWrapper = (\n    markdown: string | ParsedMarkdown,\n    options?: MarkdownProviderOptions,\n    components?: HTMLComponents<'permissive', {}>,\n    wrapper?: FC<HTMLAttributes<HTMLElement>>\n  ) => (\n    <MarkdownContext.Provider value={undefined}>\n      {customRenderFn?.(markdown, options, components, wrapper) as ReactNode}\n    </MarkdownContext.Provider>\n  );\n\n  return (\n    <MarkdownContext.Provider\n      value={{\n        components,\n        renderMarkdown: customRenderFn\n          ? customRenderMarkdownWrapper\n          : defaultRenderMarkdown,\n      }}\n    >\n      {children}\n    </MarkdownContext.Provider>\n  );\n};\n"],"mappings":";;;;;;;AAmDA,MAAM,kBAAkB,cACtB,MACF;;;;;;;;AASA,MAAa,2BAA2B,WAAW,eAAe;AAElE,MAAM,gBACJ,aACA,UAAmC,CAAC,GACpC,aAA+C,CAAC,GAChD,YAC4B;CAC5B,OAAO;EACL,GAAG;EACH,GAAG;EACH,YAAY,QAAQ,cAAc,YAAY;EAC9C,aAAa,QAAQ,eAAe,YAAY;EAChD,qBACE,QAAQ,uBAAuB,YAAY;EAC7C,WAAW,QAAQ,aAAa,YAAY;EAC5C,SAAS,WAAW,YAAY;EAEhC,cAAc,CAAC,EAAE,WAAW,YAAY;EACxC,YAAY;GAAE,GAAG,YAAY;GAAY,GAAG;EAAW;CACzD;AACF;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,MAAa,oBAA+C,EAC1D,UACA,YACA,SACA,YACA,aACA,qBACA,WACA,gBAAgB,qBACZ;CACJ,MAAM,cAAuC;EAC3C;EACA;EACA;EACA;EACA,cAAc,CAAC,CAAC;EAChB;EACA;CACF;CAGA,MAAM,yBACJ,UACA,SACA,YACA,YACG;EACH,MAAM,gBAAgB,aACpB,aACA,SACA,YACA,OACF;EAEA,OAAO,gBAAgB,UAAU,aAAa;CAChD;CAIA,MAAM,+BACJ,UACA,SACA,YACA,YAEA,oBAAC,gBAAgB,UAAjB;EAA0B,OAAO;YAC9B,iBAAiB,UAAU,SAAS,YAAY,OAAO;CAChC;CAG5B,OACE,oBAAC,gBAAgB,UAAjB;EACE,OAAO;GACL;GACA,gBAAgB,iBACZ,8BACA;EACN;EAEC;CACuB;AAE9B"}

package/dist/esm/plugins.mjs

@@ -13,6 +13,8 @@ import { jsx } from "react/jsx-runtime";
 //#region src/plugins.tsx
 const markdownRendererModulePromise = process.env.INTLAYER_NODE_TYPE_MARKDOWN !== "false" ? import("./markdown/MarkdownRendererPlugin.mjs").then((m) => m.MarkdownRendererPlugin) : null;
 const htmlRendererModulePromise = process.env.INTLAYER_NODE_TYPE_HTML !== "false" ? import("./html/HTMLRendererPlugin.mjs").then((m) => m.HTMLRendererPlugin) : null;
+markdownRendererModulePromise?.catch(() => {});
+htmlRendererModulePromise?.catch(() => {});
 /** Translation plugin. Replaces node with a locale string if nodeType = Translation. */
 const intlayerNodePlugins = {
 	id: "intlayer-node-plugin",
@@ -106,7 +108,8 @@ const insertionPlugin = process.env.INTLAYER_NODE_TYPE_INSERTION === "false" ? f
 	}
 };
 const MarkdownSuspenseRenderer = ({ children, ...props }) => {
-	return createElement(useLoadDynamic("markdown-renderer-plugin", markdownRendererModulePromise), {
+	const MarkdownRendererPlugin = useLoadDynamic("markdown-renderer-plugin", markdownRendererModulePromise);
+	return createElement(MarkdownRendererPlugin, {
 		...props,
 		children
 	});
@@ -181,7 +184,8 @@ const markdownPlugin = process.env.INTLAYER_NODE_TYPE_MARKDOWN === "false" ? fal
 	}
 };
 const HTMLSuspenseRenderer = (props) => {
-	return createElement(useLoadDynamic("html-renderer-plugin", htmlRendererModulePromise), props);
+	const HTMLRendererPlugin = useLoadDynamic("html-renderer-plugin", htmlRendererModulePromise);
+	return createElement(HTMLRendererPlugin, props);
 };
 /** HTML plugin. Replaces node with a function that takes components => ReactNode. */
 const htmlPlugin = process.env.INTLAYER_NODE_TYPE_HTML === "false" ? fallbackPlugin : {