react-intlayer 8.12.5-canary.0 → 9.0.0-canary.1

package/dist/cjs/client/useDictionary.cjs

@@ -5,21 +5,30 @@ const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
 const require_getDictionary = require('../getDictionary.cjs');
 const require_client_IntlayerProvider = require('./IntlayerProvider.cjs');
 let react = require("react");
+let _intlayer_core_dictionaryManipulator = require("@intlayer/core/dictionaryManipulator");
 
 //#region src/client/useDictionary.ts
 /**
-* On the server side, Hook that transform a dictionary and return the content
+* Client-side hook that transforms a dictionary (or qualified dictionary
+* group) and returns the content.
 *
-* If the locale is not provided, it will use the locale from the client context
+* If the locale is not provided (directly or through the selector), it will
+* use the locale from the client context.
 */
-const useDictionary = (dictionary, locale) => {
+const useDictionary = (dictionary, localeOrSelector) => {
 	const { locale: currentLocale } = (0, react.useContext)(require_client_IntlayerProvider.IntlayerClientContext) ?? {};
+	const isSelector = typeof localeOrSelector === "object" && localeOrSelector !== null;
+	const localeOrSelectorIdentity = isSelector ? `${localeOrSelector.locale ?? ""}|${(0, _intlayer_core_dictionaryManipulator.getDictionarySelectorCacheKey)(localeOrSelector)}` : localeOrSelector;
 	return (0, react.useMemo)(() => {
-		return require_getDictionary.getDictionary(dictionary, locale ?? currentLocale);
+		if (isSelector) return require_getDictionary.getDictionary(dictionary, {
+			...localeOrSelector,
+			locale: localeOrSelector.locale ?? currentLocale
+		});
+		return require_getDictionary.getDictionary(dictionary, localeOrSelector ?? currentLocale);
 	}, [
 		dictionary.key,
 		currentLocale,
-		locale
+		localeOrSelectorIdentity
 	]);
 };
 

package/dist/cjs/client/useDictionary.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useDictionary.cjs","names":["IntlayerClientContext","getDictionary"],"sources":["../../../src/client/useDictionary.ts"],"sourcesContent":["'use client';\n\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { useContext, useMemo } from 'react';\nimport { getDictionary } from '../getDictionary';\nimport { IntlayerClientContext } from './IntlayerProvider';\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 useDictionary = <\n  const T extends Dictionary,\n  const L extends LocalesValues = DeclaredLocales,\n>(\n  dictionary: T,\n  locale?: L\n) => {\n  const { locale: currentLocale } = useContext(IntlayerClientContext) ?? {};\n\n  return useMemo(() => {\n    const localeTarget = locale ?? currentLocale;\n\n    return getDictionary<T, L>(dictionary, localeTarget as L);\n  }, [dictionary.key, currentLocale, locale]);\n};\n"],"mappings":";;;;;;;;;;;;;;AAgBA,MAAa,iBAIX,YACA,WACG;CACH,MAAM,EAAE,QAAQ,wCAA6BA,sDAAsB,IAAI,EAAE;AAEzE,iCAAqB;AAGnB,SAAOC,oCAAoB,YAFN,UAAU,cAE0B;IACxD;EAAC,WAAW;EAAK;EAAe;EAAO,CAAC"}
+{"version":3,"file":"useDictionary.cjs","names":["IntlayerClientContext","getDictionary"],"sources":["../../../src/client/useDictionary.ts"],"sourcesContent":["'use client';\n\nimport { getDictionarySelectorCacheKey } from '@intlayer/core/dictionaryManipulator';\nimport type {\n  Dictionary,\n  DictionarySelectorForGroup,\n  QualifiedDictionaryGroup,\n} from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { useContext, useMemo } from 'react';\nimport { getDictionary } from '../getDictionary';\nimport { IntlayerClientContext } from './IntlayerProvider';\n\n/**\n * Client-side hook that transforms a dictionary (or qualified dictionary\n * group) and returns the content.\n *\n * If the locale is not provided (directly or through the selector), it will\n * use the locale from the client 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) => {\n  const { locale: currentLocale } = useContext(IntlayerClientContext) ?? {};\n\n  const isSelector =\n    typeof localeOrSelector === 'object' && localeOrSelector !== null;\n\n  // Stable identity of the second argument for memoization\n  const localeOrSelectorIdentity = isSelector\n    ? `${localeOrSelector.locale ?? ''}|${getDictionarySelectorCacheKey(localeOrSelector)}`\n    : localeOrSelector;\n\n  return useMemo(() => {\n    if (isSelector) {\n      return getDictionary(dictionary, {\n        ...localeOrSelector,\n        locale: localeOrSelector.locale ?? currentLocale,\n      } as A);\n    }\n\n    const localeTarget = (localeOrSelector ?? currentLocale) as A;\n\n    return getDictionary<T, A>(dictionary, localeTarget);\n  }, [dictionary.key, currentLocale, localeOrSelectorIdentity]);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;AAuBA,MAAa,iBAMX,YACA,qBACG;CACH,MAAM,EAAE,QAAQ,wCAA6BA,sDAAsB,IAAI,EAAE;CAEzE,MAAM,aACJ,OAAO,qBAAqB,YAAY,qBAAqB;CAG/D,MAAM,2BAA2B,aAC7B,GAAG,iBAAiB,UAAU,GAAG,2EAAiC,iBAAiB,KACnF;AAEJ,iCAAqB;AACnB,MAAI,WACF,QAAOC,oCAAc,YAAY;GAC/B,GAAG;GACH,QAAQ,iBAAiB,UAAU;GACpC,CAAM;AAKT,SAAOA,oCAAoB,YAFL,oBAAoB,cAEU;IACnD;EAAC,WAAW;EAAK;EAAe;EAAyB,CAAC"}

package/dist/cjs/client/useDictionaryDynamic.cjs

@@ -3,21 +3,38 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
 const require_client_useLoadDynamic = require('./useLoadDynamic.cjs');
+const require_getDictionary = require('../getDictionary.cjs');
 const require_client_IntlayerProvider = require('./IntlayerProvider.cjs');
-const require_client_useDictionary = require('./useDictionary.cjs');
 let _intlayer_config_built = require("@intlayer/config/built");
 let react = require("react");
+let _intlayer_core_dictionaryManipulator = require("@intlayer/core/dictionaryManipulator");
 
 //#region src/client/useDictionaryDynamic.ts
 /**
-* On the server side, Hook that transform a dictionary and return the content
+* Client-side hook that lazily loads a dictionary and returns its content.
 *
-* If the locale is not provided, it will use the locale from the client context
+* The dictionary entry is either a plain dynamic loader map
+* (`locale → loader`) or a qualified one (`locale → qualifierId → loader`,
+* tagged with the qualifier dimension). For qualified maps, only the chunk(s)
+* the selector targets are loaded; the resolution mirrors static mode.
+*
+* If the locale is not provided (directly or through the selector), the client
+* context locale is used.
 */
-const useDictionaryDynamic = (dictionaryPromise, key, locale) => {
+const useDictionaryDynamic = (dictionaryPromise, key, localeOrSelector) => {
 	const { locale: currentLocale } = (0, react.useContext)(require_client_IntlayerProvider.IntlayerClientContext) ?? {};
-	const localeTarget = (0, react.useMemo)(() => locale ?? currentLocale ?? _intlayer_config_built.internationalization.defaultLocale, [currentLocale, locale]);
-	return require_client_useDictionary.useDictionary(require_client_useLoadDynamic.useLoadDynamic(`${String(key)}.${localeTarget}`, dictionaryPromise[localeTarget]?.()), localeTarget);
+	const { locale: selectorLocale, selector } = (0, _intlayer_core_dictionaryManipulator.parseDictionarySelector)(localeOrSelector);
+	const localeTarget = selectorLocale ?? currentLocale ?? _intlayer_config_built.internationalization.defaultLocale;
+	if ((0, _intlayer_core_dictionaryManipulator.isQualifiedDynamicLoaderMap)(dictionaryPromise)) return (0, _intlayer_core_dictionaryManipulator.resolveQualifiedDynamicContent)({
+		loaderMap: dictionaryPromise,
+		key: String(key),
+		locale: localeTarget,
+		selector,
+		loadChunk: (cacheKey, promise) => require_client_useLoadDynamic.useLoadDynamic(cacheKey, promise),
+		transform: (dictionary) => require_getDictionary.getDictionary(dictionary, localeTarget)
+	});
+	const plainLoaders = dictionaryPromise;
+	return require_getDictionary.getDictionary(require_client_useLoadDynamic.useLoadDynamic(`${String(key)}.${localeTarget}`, plainLoaders[localeTarget]?.()), localeTarget);
 };
 
 //#endregion

package/dist/cjs/client/useDictionaryDynamic.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useDictionaryDynamic.cjs","names":["IntlayerClientContext","internationalization","useDictionary","useLoadDynamic"],"sources":["../../../src/client/useDictionaryDynamic.ts"],"sourcesContent":["'use client';\n\nimport { internationalization } from '@intlayer/config/built';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  DictionaryKeys,\n  LocalesValues,\n  StrictModeLocaleMap,\n} from '@intlayer/types/module_augmentation';\nimport { useContext, useMemo } from 'react';\nimport { IntlayerClientContext } from './IntlayerProvider';\nimport { useDictionary } from './useDictionary';\nimport { useLoadDynamic } from './useLoadDynamic';\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 useDictionaryDynamic = <\n  const T extends Dictionary,\n  const K extends DictionaryKeys,\n>(\n  dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>,\n  key: K,\n  locale?: LocalesValues\n) => {\n  const { locale: currentLocale } = useContext(IntlayerClientContext) ?? {};\n  const localeTarget = useMemo(\n    () => locale ?? currentLocale ?? internationalization.defaultLocale,\n    [currentLocale, locale]\n  );\n\n  const dictionary = useLoadDynamic<T>(\n    `${String(key)}.${localeTarget}`,\n    (dictionaryPromise as any)[localeTarget]?.()\n  ) as T;\n\n  return useDictionary(dictionary, localeTarget);\n};\n"],"mappings":";;;;;;;;;;;;;;;;AAmBA,MAAa,wBAIX,mBACA,KACA,WACG;CACH,MAAM,EAAE,QAAQ,wCAA6BA,sDAAsB,IAAI,EAAE;CACzE,MAAM,wCACE,UAAU,iBAAiBC,4CAAqB,eACtD,CAAC,eAAe,OAAO,CACxB;AAOD,QAAOC,2CALYC,6CACjB,GAAG,OAAO,IAAI,CAAC,GAAG,gBACjB,kBAA0B,iBAAiB,CAGf,EAAE,aAAa"}
+{"version":3,"file":"useDictionaryDynamic.cjs","names":["IntlayerClientContext","internationalization","loadDynamicChunk","getDictionary"],"sources":["../../../src/client/useDictionaryDynamic.ts"],"sourcesContent":["'use client';\n\nimport { internationalization } from '@intlayer/config/built';\nimport {\n  isQualifiedDynamicLoaderMap,\n  parseDictionarySelector,\n  type QualifiedDynamicLoaderMap,\n  resolveQualifiedDynamicContent,\n} from '@intlayer/core/dictionaryManipulator';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\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> = LocalesValues,\n>(\n  dictionaryPromise:\n    | StrictModeLocaleMap<() => Promise<T>>\n    | QualifiedDynamicLoaderMap,\n  key: K,\n  localeOrSelector?: A\n) => {\n  const { locale: currentLocale } = useContext(IntlayerClientContext) ?? {};\n\n  const { locale: selectorLocale, selector } =\n    parseDictionarySelector<LocalesValues>(localeOrSelector);\n\n  const localeTarget =\n    selectorLocale ?? currentLocale ?? internationalization.defaultLocale;\n\n  if (isQualifiedDynamicLoaderMap(dictionaryPromise)) {\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":";;;;;;;;;;;;;;;;;;;;;;;AAmCA,MAAa,wBAKX,mBAGA,KACA,qBACG;CACH,MAAM,EAAE,QAAQ,wCAA6BA,sDAAsB,IAAI,EAAE;CAEzE,MAAM,EAAE,QAAQ,gBAAgB,+EACS,iBAAiB;CAE1D,MAAM,eACJ,kBAAkB,iBAAiBC,4CAAqB;AAE1D,2EAAgC,kBAAkB,CAChD,iFAAsC;EACpC,WAAW;EACX,KAAK,OAAO,IAAI;EAChB,QAAQ;EACR;EACA,YAAY,UAAU,YAAYC,6CAAiB,UAAU,QAAQ;EACrE,YAAY,eAAeC,oCAAc,YAAY,aAAa;EACnE,CAAC;CAGJ,MAAM,eAAe;AASrB,QAAOA,oCALYD,6CACjB,GAAG,OAAO,IAAI,CAAC,GAAG,gBAClB,aAAa,iBAA8C,CAG9B,EAAE,aAAa"}

package/dist/cjs/client/useIntlayer.cjs

@@ -5,16 +5,21 @@ const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
 const require_getIntlayer = require('../getIntlayer.cjs');
 const require_client_IntlayerProvider = require('./IntlayerProvider.cjs');
 let react = require("react");
+let _intlayer_core_dictionaryManipulator = require("@intlayer/core/dictionaryManipulator");
 
 //#region src/client/useIntlayer.ts
 /**
 * Client-side hook that picks one dictionary by its key and returns its content.
 *
-* If the locale is not provided, it will use the locale from the client context.
+* The second argument is either a locale or a selector object:
+* - `{ item: 2 }` — collection item (omit `item` to get every item as array)
+* - `{ variant: 'black-friday' }` — named variant (omit for the `default` one)
+* - `{ id: 'prod_abc', ...metaFields }` — meta record
+* - `locale` composes with any selector and overrides the context locale
 *
 * @param key - The unique key of the dictionary to retrieve.
-* @param locale - Optional locale to override the current context locale.
-* @returns The dictionary content for the specified locale.
+* @param localeOrSelector - Optional locale or selector.
+* @returns The dictionary content for the resolved entry and locale.
 *
 * @example
 * ```tsx
@@ -22,19 +27,25 @@ let react = require("react");
 *
 * const MyComponent = () => {
 *   const content = useIntlayer('my-dictionary-key');
+*   const faq2 = useIntlayer('faq', { item: 2 });
 *
 *   return <div>{content.myField.value}</div>;
 * };
 * ```
 */
-const useIntlayer = (key, locale) => {
+const useIntlayer = (key, localeOrSelector) => {
 	const { locale: currentLocale } = (0, react.useContext)(require_client_IntlayerProvider.IntlayerClientContext) ?? {};
+	const isSelector = typeof localeOrSelector === "object" && localeOrSelector !== null;
 	return (0, react.useMemo)(() => {
-		return require_getIntlayer.getIntlayer(key, locale ?? currentLocale);
+		if (isSelector) return require_getIntlayer.getIntlayer(key, {
+			...localeOrSelector,
+			locale: localeOrSelector.locale ?? currentLocale
+		});
+		return require_getIntlayer.getIntlayer(key, localeOrSelector ?? currentLocale);
 	}, [
 		key,
 		currentLocale,
-		locale
+		isSelector ? `${localeOrSelector.locale ?? ""}|${(0, _intlayer_core_dictionaryManipulator.getDictionarySelectorCacheKey)(localeOrSelector)}` : localeOrSelector
 	]);
 };
 

package/dist/cjs/client/useIntlayer.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useIntlayer.cjs","names":["IntlayerClientContext","getIntlayer"],"sources":["../../../src/client/useIntlayer.ts"],"sourcesContent":["'use client';\n\nimport type {\n  DeclaredLocales,\n  DictionaryKeys,\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 * If the locale is not provided, it will use the locale from the client context.\n *\n * @param key - The unique key of the dictionary to retrieve.\n * @param locale - Optional locale to override the current context locale.\n * @returns The dictionary content for the specified locale.\n *\n * @example\n * ```tsx\n * import { useIntlayer } from 'react-intlayer';\n *\n * const MyComponent = () => {\n *   const content = useIntlayer('my-dictionary-key');\n *\n *   return <div>{content.myField.value}</div>;\n * };\n * ```\n */\nexport const useIntlayer = <\n  const T extends DictionaryKeys,\n  const L extends LocalesValues = DeclaredLocales,\n>(\n  key: T,\n  locale?: L\n) => {\n  const { locale: currentLocale } = useContext(IntlayerClientContext) ?? {};\n\n  return useMemo(() => {\n    const localeTarget = locale ?? (currentLocale as L);\n\n    return getIntlayer<T, L>(key, localeTarget);\n  }, [key, currentLocale, locale]);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,MAAa,eAIX,KACA,WACG;CACH,MAAM,EAAE,QAAQ,wCAA6BA,sDAAsB,IAAI,EAAE;AAEzE,iCAAqB;AAGnB,SAAOC,gCAAkB,KAFJ,UAAW,cAEW;IAC1C;EAAC;EAAK;EAAe;EAAO,CAAC"}
+{"version":3,"file":"useIntlayer.cjs","names":["IntlayerClientContext","getIntlayer"],"sources":["../../../src/client/useIntlayer.ts"],"sourcesContent":["'use client';\n\nimport { getDictionarySelectorCacheKey } 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 * - `{ id: 'prod_abc', ...metaFields }` — meta record\n * - `locale` composes with any selector and overrides the context locale\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 } = useContext(IntlayerClientContext) ?? {};\n\n  const isSelector =\n    typeof localeOrSelector === 'object' && localeOrSelector !== null;\n\n  // Stable identity of the second argument for memoization\n  const localeOrSelectorIdentity = isSelector\n    ? `${localeOrSelector.locale ?? ''}|${getDictionarySelectorCacheKey(localeOrSelector)}`\n    : localeOrSelector;\n\n  return useMemo(() => {\n    if (isSelector) {\n      return getIntlayer(key, {\n        ...localeOrSelector,\n        locale: localeOrSelector.locale ?? currentLocale,\n      } as A);\n    }\n\n    const localeTarget = (localeOrSelector ?? currentLocale) as A;\n\n    return getIntlayer<T, A>(key, localeTarget);\n  }, [key, currentLocale, localeOrSelectorIdentity]);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,MAAa,eAIX,KACA,qBACG;CACH,MAAM,EAAE,QAAQ,wCAA6BA,sDAAsB,IAAI,EAAE;CAEzE,MAAM,aACJ,OAAO,qBAAqB,YAAY,qBAAqB;AAO/D,iCAAqB;AACnB,MAAI,WACF,QAAOC,gCAAY,KAAK;GACtB,GAAG;GACH,QAAQ,iBAAiB,UAAU;GACpC,CAAM;AAKT,SAAOA,gCAAkB,KAFH,oBAAoB,cAEC;IAC1C;EAAC;EAAK;EAfwB,aAC7B,GAAG,iBAAiB,UAAU,GAAG,2EAAiC,iBAAiB,KACnF;EAa6C,CAAC"}

package/dist/cjs/getDictionary.cjs

@@ -4,7 +4,14 @@ const require_plugins = require('./plugins.cjs');
 let _intlayer_core_interpreter = require("@intlayer/core/interpreter");
 
 //#region src/getDictionary.ts
-const getDictionary = (dictionary, locale) => (0, _intlayer_core_interpreter.getDictionary)(dictionary, locale, require_plugins.getPlugins(locale));
+/**
+* Transforms a dictionary (or qualified dictionary group) and returns its
+* content for the given locale or selector (`{ item }`, `{ variant }`,
+* `{ id, ...meta }`, optionally combined with `locale`).
+*/
+const getDictionary = (dictionary, localeOrSelector) => {
+	return (0, _intlayer_core_interpreter.getDictionary)(dictionary, localeOrSelector, require_plugins.getPlugins(typeof localeOrSelector === "object" && localeOrSelector !== null ? localeOrSelector.locale : localeOrSelector));
+};
 
 //#endregion
 exports.getDictionary = getDictionary;

package/dist/cjs/getDictionary.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"getDictionary.cjs","names":["getPlugins"],"sources":["../../src/getDictionary.ts"],"sourcesContent":["import { getDictionary as getDictionaryCore } from '@intlayer/core/interpreter';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { type DeepTransformContent, getPlugins } from './plugins';\n\nexport const getDictionary = <\n  const T extends Dictionary,\n  const L extends LocalesValues = DeclaredLocales,\n>(\n  dictionary: T,\n  locale?: L\n): DeepTransformContent<T['content'], L> =>\n  getDictionaryCore(dictionary, locale, getPlugins(locale)) as any;\n"],"mappings":";;;;;;AAQA,MAAa,iBAIX,YACA,yDAEkB,YAAY,QAAQA,2BAAW,OAAO,CAAC"}
+{"version":3,"file":"getDictionary.cjs","names":["getPlugins"],"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 * `{ id, ...meta }`, 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;AAOH,sDACE,YACA,kBACAA,2BARA,OAAO,qBAAqB,YAAY,qBAAqB,OACzD,iBAAiB,SACjB,iBAMc,CACnB"}

package/dist/cjs/getIntlayer.cjs

@@ -4,7 +4,14 @@ const require_plugins = require('./plugins.cjs');
 let _intlayer_core_interpreter = require("@intlayer/core/interpreter");
 
 //#region src/getIntlayer.ts
-const getIntlayer = (key, locale) => (0, _intlayer_core_interpreter.getIntlayer)(key, locale, require_plugins.getPlugins(locale));
+/**
+* Picks one dictionary by its key and returns its content for the given
+* locale or selector (`{ item }`, `{ variant }`, `{ id, ...meta }`,
+* optionally combined with `locale`).
+*/
+const getIntlayer = (key, localeOrSelector) => {
+	return (0, _intlayer_core_interpreter.getIntlayer)(key, localeOrSelector, require_plugins.getPlugins(typeof localeOrSelector === "object" && localeOrSelector !== null ? localeOrSelector.locale : localeOrSelector));
+};
 
 //#endregion
 exports.getIntlayer = getIntlayer;

package/dist/cjs/getIntlayer.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"getIntlayer.cjs","names":["getPlugins"],"sources":["../../src/getIntlayer.ts"],"sourcesContent":["import { getIntlayer as getIntlayerCore } from '@intlayer/core/interpreter';\nimport type {\n  DeclaredLocales,\n  DictionaryKeys,\n  DictionaryRegistryContent,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { type DeepTransformContent, getPlugins } from './plugins';\n\nexport const getIntlayer = <\n  const T extends DictionaryKeys,\n  const L extends LocalesValues = DeclaredLocales,\n>(\n  key: T,\n  locale?: L\n): DeepTransformContent<DictionaryRegistryContent<T>, L> =>\n  getIntlayerCore(key, locale, getPlugins(locale)) as any;\n"],"mappings":";;;;;;AASA,MAAa,eAIX,KACA,uDAEgB,KAAK,QAAQA,2BAAW,OAAO,CAAC"}
+{"version":3,"file":"getIntlayer.cjs","names":["getPlugins"],"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 }`, `{ id, ...meta }`,\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;AAOH,oDAAuB,KAAK,kBAAkBA,2BAL5C,OAAO,qBAAqB,YAAY,qBAAqB,OACzD,iBAAiB,SACjB,iBAG0D,CAAC"}

package/dist/cjs/server/useDictionary.cjs

@@ -5,12 +5,19 @@ const require_server_IntlayerServerProvider = require('./IntlayerServerProvider.
 
 //#region src/server/useDictionary.ts
 /**
-* On the server side, Hook that transform a dictionary and return the content
+* On the server side, Hook that transform a dictionary (or qualified
+* dictionary group) and return the content
 *
-* If the locale is not provided, it will use the locale from the server context
+* If the locale is not provided (directly or through the selector), it will
+* use the locale from the server context
 */
-const useDictionary = (dictionary, locale, fallbackLocale) => {
-	return require_getDictionary.getDictionary(dictionary, locale ?? require_server_serverContext.getServerContext(require_server_IntlayerServerProvider.IntlayerServerContext) ?? fallbackLocale);
+const useDictionary = (dictionary, localeOrSelector, fallbackLocale) => {
+	const contextLocale = require_server_serverContext.getServerContext(require_server_IntlayerServerProvider.IntlayerServerContext) ?? fallbackLocale;
+	if (typeof localeOrSelector === "object" && localeOrSelector !== null) return require_getDictionary.getDictionary(dictionary, {
+		...localeOrSelector,
+		locale: localeOrSelector.locale ?? contextLocale
+	});
+	return require_getDictionary.getDictionary(dictionary, localeOrSelector ?? contextLocale);
 };
 
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"useDictionary.cjs","names":["getDictionary","getServerContext","IntlayerServerContext"],"sources":["../../../src/server/useDictionary.ts"],"sourcesContent":["import type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { getDictionary } from '../getDictionary';\nimport { IntlayerServerContext } from './IntlayerServerProvider';\nimport { getServerContext } from './serverContext';\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 useDictionary = <\n  const T extends Dictionary,\n  const L extends LocalesValues = DeclaredLocales,\n>(\n  dictionary: T,\n  locale?: L,\n  fallbackLocale?: DeclaredLocales\n) => {\n  const localeTarget =\n    locale ??\n    getServerContext<LocalesValues>(IntlayerServerContext) ??\n    fallbackLocale;\n\n  return getDictionary<T, L>(dictionary, localeTarget as L);\n};\n"],"mappings":";;;;;;;;;;;AAcA,MAAa,iBAIX,YACA,QACA,mBACG;AAMH,QAAOA,oCAAoB,YAJzB,UACAC,8CAAgCC,4DAAsB,IACtD,eAEuD"}
+{"version":3,"file":"useDictionary.cjs","names":["getServerContext","IntlayerServerContext","getDictionary"],"sources":["../../../src/server/useDictionary.ts"],"sourcesContent":["import type {\n  Dictionary,\n  DictionarySelectorForGroup,\n  QualifiedDictionaryGroup,\n} from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { getDictionary } from '../getDictionary';\nimport { IntlayerServerContext } 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 (typeof localeOrSelector === 'object' && localeOrSelector !== null) {\n    return getDictionary(dictionary, {\n      ...localeOrSelector,\n      locale: localeOrSelector.locale ?? contextLocale,\n    } as A);\n  }\n\n  const localeTarget = (localeOrSelector ?? contextLocale) as A;\n\n  return getDictionary<T, A>(dictionary, localeTarget);\n};\n"],"mappings":";;;;;;;;;;;;;AAoBA,MAAa,iBAMX,YACA,kBACA,mBACG;CACH,MAAM,gBACJA,8CAAgCC,4DAAsB,IAAI;AAE5D,KAAI,OAAO,qBAAqB,YAAY,qBAAqB,KAC/D,QAAOC,oCAAc,YAAY;EAC/B,GAAG;EACH,QAAQ,iBAAiB,UAAU;EACpC,CAAM;AAKT,QAAOA,oCAAoB,YAFL,oBAAoB,cAEU"}

package/dist/cjs/server/useDictionaryDynamic.cjs

@@ -1,20 +1,37 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+const require_getDictionary = require('../getDictionary.cjs');
 const require_server_serverContext = require('./serverContext.cjs');
 const require_server_IntlayerServerProvider = require('./IntlayerServerProvider.cjs');
-const require_server_useDictionary = require('./useDictionary.cjs');
 const require_server_useLoadDynamic = require('./useLoadDynamic.cjs');
 let _intlayer_config_built = require("@intlayer/config/built");
+let _intlayer_core_dictionaryManipulator = require("@intlayer/core/dictionaryManipulator");
 
 //#region src/server/useDictionaryDynamic.ts
 /**
-* On the server side, Hook that transform a dictionary and return the content
+* Server-side hook that lazily loads a dictionary and returns its content.
 *
-* If the locale is not provided, it will use the locale from the server context
+* The dictionary entry is either a plain dynamic loader map
+* (`locale → loader`) or a qualified one (`locale → qualifierId → loader`,
+* tagged with the qualifier dimension). For qualified maps, only the chunk(s)
+* the selector targets are loaded; the resolution mirrors static mode.
+*
+* If the locale is not provided (directly or through the selector), the server
+* context locale is used.
 */
-const useDictionaryDynamic = (dictionaryPromise, key, locale, fallbackLocale) => {
-	const localeTarget = locale ?? require_server_serverContext.getServerContext(require_server_IntlayerServerProvider.IntlayerServerContext) ?? fallbackLocale ?? _intlayer_config_built.internationalization.defaultLocale;
-	return require_server_useDictionary.useDictionary(require_server_useLoadDynamic.useLoadDynamic(`${String(key)}.${localeTarget}`, dictionaryPromise[localeTarget]?.()), localeTarget);
+const useDictionaryDynamic = (dictionaryPromise, key, localeOrSelector, fallbackLocale) => {
+	const { locale: selectorLocale, selector } = (0, _intlayer_core_dictionaryManipulator.parseDictionarySelector)(localeOrSelector);
+	const localeTarget = selectorLocale ?? require_server_serverContext.getServerContext(require_server_IntlayerServerProvider.IntlayerServerContext) ?? fallbackLocale ?? _intlayer_config_built.internationalization.defaultLocale;
+	if ((0, _intlayer_core_dictionaryManipulator.isQualifiedDynamicLoaderMap)(dictionaryPromise)) return (0, _intlayer_core_dictionaryManipulator.resolveQualifiedDynamicContent)({
+		loaderMap: dictionaryPromise,
+		key: String(key),
+		locale: localeTarget,
+		selector,
+		loadChunk: (cacheKey, promise) => require_server_useLoadDynamic.useLoadDynamic(cacheKey, promise),
+		transform: (dictionary) => require_getDictionary.getDictionary(dictionary, localeTarget)
+	});
+	const plainLoaders = dictionaryPromise;
+	return require_getDictionary.getDictionary(require_server_useLoadDynamic.useLoadDynamic(`${String(key)}.${localeTarget}`, plainLoaders[localeTarget]?.()), localeTarget);
 };
 
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"useDictionaryDynamic.cjs","names":["getServerContext","IntlayerServerContext","internationalization","useDictionary","useLoadDynamic"],"sources":["../../../src/server/useDictionaryDynamic.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';\nimport { useLoadDynamic } from './useLoadDynamic';\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 useDictionaryDynamic = <\n  const T extends Dictionary,\n  const L extends LocalesValues = DeclaredLocales,\n>(\n  dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>,\n  key: string,\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 = useLoadDynamic<T>(\n    `${String(key)}.${localeTarget}`,\n    (dictionaryPromise as any)[localeTarget]?.()\n  );\n\n  return useDictionary<T, L>(dictionary, localeTarget as L);\n};\n"],"mappings":";;;;;;;;;;;;;;AAiBA,MAAa,wBAIX,mBACA,KACA,QACA,mBACG;CACH,MAAM,eACJ,UACAA,8CAAgCC,4DAAsB,IACtD,kBACAC,4CAAqB;AAOvB,QAAOC,2CALYC,6CACjB,GAAG,OAAO,IAAI,CAAC,GAAG,gBACjB,kBAA0B,iBAAiB,CAGT,EAAE,aAAkB"}
+{"version":3,"file":"useDictionaryDynamic.cjs","names":["getServerContext","IntlayerServerContext","internationalization","loadDynamicChunk","getDictionary"],"sources":["../../../src/server/useDictionaryDynamic.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport {\n  isQualifiedDynamicLoaderMap,\n  parseDictionarySelector,\n  type QualifiedDynamicLoaderMap,\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  StrictModeLocaleMap,\n} from '@intlayer/types/module_augmentation';\nimport { getDictionary } from '../getDictionary';\nimport { IntlayerServerContext } 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 = LocalesValues,\n>(\n  dictionaryPromise:\n    | StrictModeLocaleMap<() => Promise<T>>\n    | QualifiedDynamicLoaderMap,\n  key: string,\n  localeOrSelector?: A,\n  fallbackLocale?: DeclaredLocales\n) => {\n  const { locale: selectorLocale, selector } =\n    parseDictionarySelector<LocalesValues>(localeOrSelector);\n\n  const localeTarget =\n    selectorLocale ??\n    getServerContext<LocalesValues>(IntlayerServerContext) ??\n    fallbackLocale ??\n    internationalization.defaultLocale;\n\n  if (isQualifiedDynamicLoaderMap(dictionaryPromise)) {\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":";;;;;;;;;;;;;;;;;;;;;AAmCA,MAAa,wBAIX,mBAGA,KACA,kBACA,mBACG;CACH,MAAM,EAAE,QAAQ,gBAAgB,+EACS,iBAAiB;CAE1D,MAAM,eACJ,kBACAA,8CAAgCC,4DAAsB,IACtD,kBACAC,4CAAqB;AAEvB,2EAAgC,kBAAkB,CAChD,iFAAsC;EACpC,WAAW;EACX,KAAK,OAAO,IAAI;EAChB,QAAQ;EACR;EACA,YAAY,UAAU,YAAYC,6CAAiB,UAAU,QAAQ;EACrE,YAAY,eAAeC,oCAAc,YAAY,aAAa;EACnE,CAAC;CAGJ,MAAM,eAAe;AASrB,QAAOA,oCALYD,6CACjB,GAAG,OAAO,IAAI,CAAC,GAAG,gBAClB,aAAa,iBAA8C,CAG9B,EAAE,aAAa"}

package/dist/cjs/server/useIntlayer.cjs

@@ -7,10 +7,18 @@ const require_server_IntlayerServerProvider = require('./IntlayerServerProvider.
 /**
 * On the server side, Hook that picking one dictionary by its key and return the content
 *
+* The second argument is either a locale or a selector object
+* (`{ item }`, `{ variant }`, `{ id, ...meta }`, optionally with `locale`).
+*
 * If the locale is not provided, it will use the locale from the server context
 */
-const useIntlayer = (key, locale, fallbackLocale) => {
-	return require_getIntlayer.getIntlayer(key, locale ?? require_server_serverContext.getServerContext(require_server_IntlayerServerProvider.IntlayerServerContext) ?? fallbackLocale);
+const useIntlayer = (key, localeOrSelector, fallbackLocale) => {
+	const contextLocale = require_server_serverContext.getServerContext(require_server_IntlayerServerProvider.IntlayerServerContext) ?? fallbackLocale;
+	if (typeof localeOrSelector === "object" && localeOrSelector !== null) return require_getIntlayer.getIntlayer(key, {
+		...localeOrSelector,
+		locale: localeOrSelector.locale ?? contextLocale
+	});
+	return require_getIntlayer.getIntlayer(key, localeOrSelector ?? contextLocale);
 };
 
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"useIntlayer.cjs","names":["getIntlayer","getServerContext","IntlayerServerContext"],"sources":["../../../src/server/useIntlayer.ts"],"sourcesContent":["import type {\n  DeclaredLocales,\n  DictionaryKeys,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { getIntlayer } from '../getIntlayer';\nimport { IntlayerServerContext } 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 * 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 L extends LocalesValues = DeclaredLocales,\n>(\n  key: T,\n  locale?: L,\n  fallbackLocale?: DeclaredLocales\n) => {\n  const localeTarget =\n    locale ??\n    getServerContext<LocalesValues>(IntlayerServerContext) ??\n    fallbackLocale;\n\n  return getIntlayer<T, L>(key, localeTarget as L);\n};\n"],"mappings":";;;;;;;;;;;AAcA,MAAa,eAIX,KACA,QACA,mBACG;AAMH,QAAOA,gCAAkB,KAJvB,UACAC,8CAAgCC,4DAAsB,IACtD,eAE8C"}
+{"version":3,"file":"useIntlayer.cjs","names":["getServerContext","IntlayerServerContext","getIntlayer"],"sources":["../../../src/server/useIntlayer.ts"],"sourcesContent":["import type {\n  DeclaredLocales,\n  DictionaryKeys,\n  DictionarySelectorForKey,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { getIntlayer } from '../getIntlayer';\nimport { IntlayerServerContext } 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 }`, `{ id, ...meta }`, 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 (typeof localeOrSelector === 'object' && localeOrSelector !== null) {\n    return getIntlayer(key, {\n      ...localeOrSelector,\n      locale: localeOrSelector.locale ?? contextLocale,\n    } as A);\n  }\n\n  const localeTarget = (localeOrSelector ?? contextLocale) as A;\n\n  return getIntlayer<T, A>(key, localeTarget);\n};\n"],"mappings":";;;;;;;;;;;;;;AAkBA,MAAa,eAIX,KACA,kBACA,mBACG;CACH,MAAM,gBACJA,8CAAgCC,4DAAsB,IAAI;AAE5D,KAAI,OAAO,qBAAqB,YAAY,qBAAqB,KAC/D,QAAOC,gCAAY,KAAK;EACtB,GAAG;EACH,QAAQ,iBAAiB,UAAU;EACpC,CAAM;AAKT,QAAOA,gCAAkB,KAFH,oBAAoB,cAEC"}

package/dist/esm/client/useDictionary.mjs

@@ -3,21 +3,30 @@
 import { getDictionary } from "../getDictionary.mjs";
 import { IntlayerClientContext } from "./IntlayerProvider.mjs";
 import { useContext, useMemo } from "react";
+import { getDictionarySelectorCacheKey } from "@intlayer/core/dictionaryManipulator";
 
 //#region src/client/useDictionary.ts
 /**
-* On the server side, Hook that transform a dictionary and return the content
+* Client-side hook that transforms a dictionary (or qualified dictionary
+* group) and returns the content.
 *
-* If the locale is not provided, it will use the locale from the client context
+* If the locale is not provided (directly or through the selector), it will
+* use the locale from the client context.
 */
-const useDictionary = (dictionary, locale) => {
+const useDictionary = (dictionary, localeOrSelector) => {
 	const { locale: currentLocale } = useContext(IntlayerClientContext) ?? {};
+	const isSelector = typeof localeOrSelector === "object" && localeOrSelector !== null;
+	const localeOrSelectorIdentity = isSelector ? `${localeOrSelector.locale ?? ""}|${getDictionarySelectorCacheKey(localeOrSelector)}` : localeOrSelector;
 	return useMemo(() => {
-		return getDictionary(dictionary, locale ?? currentLocale);
+		if (isSelector) return getDictionary(dictionary, {
+			...localeOrSelector,
+			locale: localeOrSelector.locale ?? currentLocale
+		});
+		return getDictionary(dictionary, localeOrSelector ?? currentLocale);
 	}, [
 		dictionary.key,
 		currentLocale,
-		locale
+		localeOrSelectorIdentity
 	]);
 };
 

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

@@ -1 +1 @@
-{"version":3,"file":"useDictionary.mjs","names":[],"sources":["../../../src/client/useDictionary.ts"],"sourcesContent":["'use client';\n\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { useContext, useMemo } from 'react';\nimport { getDictionary } from '../getDictionary';\nimport { IntlayerClientContext } from './IntlayerProvider';\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 useDictionary = <\n  const T extends Dictionary,\n  const L extends LocalesValues = DeclaredLocales,\n>(\n  dictionary: T,\n  locale?: L\n) => {\n  const { locale: currentLocale } = useContext(IntlayerClientContext) ?? {};\n\n  return useMemo(() => {\n    const localeTarget = locale ?? currentLocale;\n\n    return getDictionary<T, L>(dictionary, localeTarget as L);\n  }, [dictionary.key, currentLocale, locale]);\n};\n"],"mappings":";;;;;;;;;;;;AAgBA,MAAa,iBAIX,YACA,WACG;CACH,MAAM,EAAE,QAAQ,kBAAkB,WAAW,sBAAsB,IAAI,EAAE;AAEzE,QAAO,cAAc;AAGnB,SAAO,cAAoB,YAFN,UAAU,cAE0B;IACxD;EAAC,WAAW;EAAK;EAAe;EAAO,CAAC"}
+{"version":3,"file":"useDictionary.mjs","names":[],"sources":["../../../src/client/useDictionary.ts"],"sourcesContent":["'use client';\n\nimport { getDictionarySelectorCacheKey } from '@intlayer/core/dictionaryManipulator';\nimport type {\n  Dictionary,\n  DictionarySelectorForGroup,\n  QualifiedDictionaryGroup,\n} from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { useContext, useMemo } from 'react';\nimport { getDictionary } from '../getDictionary';\nimport { IntlayerClientContext } from './IntlayerProvider';\n\n/**\n * Client-side hook that transforms a dictionary (or qualified dictionary\n * group) and returns the content.\n *\n * If the locale is not provided (directly or through the selector), it will\n * use the locale from the client 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) => {\n  const { locale: currentLocale } = useContext(IntlayerClientContext) ?? {};\n\n  const isSelector =\n    typeof localeOrSelector === 'object' && localeOrSelector !== null;\n\n  // Stable identity of the second argument for memoization\n  const localeOrSelectorIdentity = isSelector\n    ? `${localeOrSelector.locale ?? ''}|${getDictionarySelectorCacheKey(localeOrSelector)}`\n    : localeOrSelector;\n\n  return useMemo(() => {\n    if (isSelector) {\n      return getDictionary(dictionary, {\n        ...localeOrSelector,\n        locale: localeOrSelector.locale ?? currentLocale,\n      } as A);\n    }\n\n    const localeTarget = (localeOrSelector ?? currentLocale) as A;\n\n    return getDictionary<T, A>(dictionary, localeTarget);\n  }, [dictionary.key, currentLocale, localeOrSelectorIdentity]);\n};\n"],"mappings":";;;;;;;;;;;;;;;AAuBA,MAAa,iBAMX,YACA,qBACG;CACH,MAAM,EAAE,QAAQ,kBAAkB,WAAW,sBAAsB,IAAI,EAAE;CAEzE,MAAM,aACJ,OAAO,qBAAqB,YAAY,qBAAqB;CAG/D,MAAM,2BAA2B,aAC7B,GAAG,iBAAiB,UAAU,GAAG,GAAG,8BAA8B,iBAAiB,KACnF;AAEJ,QAAO,cAAc;AACnB,MAAI,WACF,QAAO,cAAc,YAAY;GAC/B,GAAG;GACH,QAAQ,iBAAiB,UAAU;GACpC,CAAM;AAKT,SAAO,cAAoB,YAFL,oBAAoB,cAEU;IACnD;EAAC,WAAW;EAAK;EAAe;EAAyB,CAAC"}

package/dist/esm/client/useDictionaryDynamic.mjs

@@ -1,21 +1,38 @@
 'use client';
 
 import { useLoadDynamic } from "./useLoadDynamic.mjs";
+import { getDictionary } from "../getDictionary.mjs";
 import { IntlayerClientContext } from "./IntlayerProvider.mjs";
-import { useDictionary } from "./useDictionary.mjs";
 import { internationalization } from "@intlayer/config/built";
-import { useContext, useMemo } from "react";
+import { useContext } from "react";
+import { isQualifiedDynamicLoaderMap, parseDictionarySelector, resolveQualifiedDynamicContent } from "@intlayer/core/dictionaryManipulator";
 
 //#region src/client/useDictionaryDynamic.ts
 /**
-* On the server side, Hook that transform a dictionary and return the content
+* Client-side hook that lazily loads a dictionary and returns its content.
 *
-* If the locale is not provided, it will use the locale from the client context
+* The dictionary entry is either a plain dynamic loader map
+* (`locale → loader`) or a qualified one (`locale → qualifierId → loader`,
+* tagged with the qualifier dimension). For qualified maps, only the chunk(s)
+* the selector targets are loaded; the resolution mirrors static mode.
+*
+* If the locale is not provided (directly or through the selector), the client
+* context locale is used.
 */
-const useDictionaryDynamic = (dictionaryPromise, key, locale) => {
+const useDictionaryDynamic = (dictionaryPromise, key, localeOrSelector) => {
 	const { locale: currentLocale } = useContext(IntlayerClientContext) ?? {};
-	const localeTarget = useMemo(() => locale ?? currentLocale ?? internationalization.defaultLocale, [currentLocale, locale]);
-	return useDictionary(useLoadDynamic(`${String(key)}.${localeTarget}`, dictionaryPromise[localeTarget]?.()), localeTarget);
+	const { locale: selectorLocale, selector } = parseDictionarySelector(localeOrSelector);
+	const localeTarget = selectorLocale ?? currentLocale ?? internationalization.defaultLocale;
+	if (isQualifiedDynamicLoaderMap(dictionaryPromise)) return resolveQualifiedDynamicContent({
+		loaderMap: dictionaryPromise,
+		key: String(key),
+		locale: localeTarget,
+		selector,
+		loadChunk: (cacheKey, promise) => useLoadDynamic(cacheKey, promise),
+		transform: (dictionary) => getDictionary(dictionary, localeTarget)
+	});
+	const plainLoaders = dictionaryPromise;
+	return getDictionary(useLoadDynamic(`${String(key)}.${localeTarget}`, plainLoaders[localeTarget]?.()), localeTarget);
 };
 
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"useDictionaryDynamic.mjs","names":[],"sources":["../../../src/client/useDictionaryDynamic.ts"],"sourcesContent":["'use client';\n\nimport { internationalization } from '@intlayer/config/built';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  DictionaryKeys,\n  LocalesValues,\n  StrictModeLocaleMap,\n} from '@intlayer/types/module_augmentation';\nimport { useContext, useMemo } from 'react';\nimport { IntlayerClientContext } from './IntlayerProvider';\nimport { useDictionary } from './useDictionary';\nimport { useLoadDynamic } from './useLoadDynamic';\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 useDictionaryDynamic = <\n  const T extends Dictionary,\n  const K extends DictionaryKeys,\n>(\n  dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>,\n  key: K,\n  locale?: LocalesValues\n) => {\n  const { locale: currentLocale } = useContext(IntlayerClientContext) ?? {};\n  const localeTarget = useMemo(\n    () => locale ?? currentLocale ?? internationalization.defaultLocale,\n    [currentLocale, locale]\n  );\n\n  const dictionary = useLoadDynamic<T>(\n    `${String(key)}.${localeTarget}`,\n    (dictionaryPromise as any)[localeTarget]?.()\n  ) as T;\n\n  return useDictionary(dictionary, localeTarget);\n};\n"],"mappings":";;;;;;;;;;;;;;AAmBA,MAAa,wBAIX,mBACA,KACA,WACG;CACH,MAAM,EAAE,QAAQ,kBAAkB,WAAW,sBAAsB,IAAI,EAAE;CACzE,MAAM,eAAe,cACb,UAAU,iBAAiB,qBAAqB,eACtD,CAAC,eAAe,OAAO,CACxB;AAOD,QAAO,cALY,eACjB,GAAG,OAAO,IAAI,CAAC,GAAG,gBACjB,kBAA0B,iBAAiB,CAGf,EAAE,aAAa"}
+{"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  resolveQualifiedDynamicContent,\n} from '@intlayer/core/dictionaryManipulator';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\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> = LocalesValues,\n>(\n  dictionaryPromise:\n    | StrictModeLocaleMap<() => Promise<T>>\n    | QualifiedDynamicLoaderMap,\n  key: K,\n  localeOrSelector?: A\n) => {\n  const { locale: currentLocale } = useContext(IntlayerClientContext) ?? {};\n\n  const { locale: selectorLocale, selector } =\n    parseDictionarySelector<LocalesValues>(localeOrSelector);\n\n  const localeTarget =\n    selectorLocale ?? currentLocale ?? internationalization.defaultLocale;\n\n  if (isQualifiedDynamicLoaderMap(dictionaryPromise)) {\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":";;;;;;;;;;;;;;;;;;;;;AAmCA,MAAa,wBAKX,mBAGA,KACA,qBACG;CACH,MAAM,EAAE,QAAQ,kBAAkB,WAAW,sBAAsB,IAAI,EAAE;CAEzE,MAAM,EAAE,QAAQ,gBAAgB,aAC9B,wBAAuC,iBAAiB;CAE1D,MAAM,eACJ,kBAAkB,iBAAiB,qBAAqB;AAE1D,KAAI,4BAA4B,kBAAkB,CAChD,QAAO,+BAA+B;EACpC,WAAW;EACX,KAAK,OAAO,IAAI;EAChB,QAAQ;EACR;EACA,YAAY,UAAU,YAAYA,eAAiB,UAAU,QAAQ;EACrE,YAAY,eAAe,cAAc,YAAY,aAAa;EACnE,CAAC;CAGJ,MAAM,eAAe;AASrB,QAAO,cALYA,eACjB,GAAG,OAAO,IAAI,CAAC,GAAG,gBAClB,aAAa,iBAA8C,CAG9B,EAAE,aAAa"}

package/dist/esm/client/useIntlayer.mjs

@@ -3,16 +3,21 @@
 import { getIntlayer } from "../getIntlayer.mjs";
 import { IntlayerClientContext } from "./IntlayerProvider.mjs";
 import { useContext, useMemo } from "react";
+import { getDictionarySelectorCacheKey } from "@intlayer/core/dictionaryManipulator";
 
 //#region src/client/useIntlayer.ts
 /**
 * Client-side hook that picks one dictionary by its key and returns its content.
 *
-* If the locale is not provided, it will use the locale from the client context.
+* The second argument is either a locale or a selector object:
+* - `{ item: 2 }` — collection item (omit `item` to get every item as array)
+* - `{ variant: 'black-friday' }` — named variant (omit for the `default` one)
+* - `{ id: 'prod_abc', ...metaFields }` — meta record
+* - `locale` composes with any selector and overrides the context locale
 *
 * @param key - The unique key of the dictionary to retrieve.
-* @param locale - Optional locale to override the current context locale.
-* @returns The dictionary content for the specified locale.
+* @param localeOrSelector - Optional locale or selector.
+* @returns The dictionary content for the resolved entry and locale.
 *
 * @example
 * ```tsx
@@ -20,19 +25,25 @@ import { useContext, useMemo } from "react";
 *
 * const MyComponent = () => {
 *   const content = useIntlayer('my-dictionary-key');
+*   const faq2 = useIntlayer('faq', { item: 2 });
 *
 *   return <div>{content.myField.value}</div>;
 * };
 * ```
 */
-const useIntlayer = (key, locale) => {
+const useIntlayer = (key, localeOrSelector) => {
 	const { locale: currentLocale } = useContext(IntlayerClientContext) ?? {};
+	const isSelector = typeof localeOrSelector === "object" && localeOrSelector !== null;
 	return useMemo(() => {
-		return getIntlayer(key, locale ?? currentLocale);
+		if (isSelector) return getIntlayer(key, {
+			...localeOrSelector,
+			locale: localeOrSelector.locale ?? currentLocale
+		});
+		return getIntlayer(key, localeOrSelector ?? currentLocale);
 	}, [
 		key,
 		currentLocale,
-		locale
+		isSelector ? `${localeOrSelector.locale ?? ""}|${getDictionarySelectorCacheKey(localeOrSelector)}` : localeOrSelector
 	]);
 };
 

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 type {\n  DeclaredLocales,\n  DictionaryKeys,\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 * If the locale is not provided, it will use the locale from the client context.\n *\n * @param key - The unique key of the dictionary to retrieve.\n * @param locale - Optional locale to override the current context locale.\n * @returns The dictionary content for the specified locale.\n *\n * @example\n * ```tsx\n * import { useIntlayer } from 'react-intlayer';\n *\n * const MyComponent = () => {\n *   const content = useIntlayer('my-dictionary-key');\n *\n *   return <div>{content.myField.value}</div>;\n * };\n * ```\n */\nexport const useIntlayer = <\n  const T extends DictionaryKeys,\n  const L extends LocalesValues = DeclaredLocales,\n>(\n  key: T,\n  locale?: L\n) => {\n  const { locale: currentLocale } = useContext(IntlayerClientContext) ?? {};\n\n  return useMemo(() => {\n    const localeTarget = locale ?? (currentLocale as L);\n\n    return getIntlayer<T, L>(key, localeTarget);\n  }, [key, currentLocale, locale]);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,MAAa,eAIX,KACA,WACG;CACH,MAAM,EAAE,QAAQ,kBAAkB,WAAW,sBAAsB,IAAI,EAAE;AAEzE,QAAO,cAAc;AAGnB,SAAO,YAAkB,KAFJ,UAAW,cAEW;IAC1C;EAAC;EAAK;EAAe;EAAO,CAAC"}
+{"version":3,"file":"useIntlayer.mjs","names":[],"sources":["../../../src/client/useIntlayer.ts"],"sourcesContent":["'use client';\n\nimport { getDictionarySelectorCacheKey } 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 * - `{ id: 'prod_abc', ...metaFields }` — meta record\n * - `locale` composes with any selector and overrides the context locale\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 } = useContext(IntlayerClientContext) ?? {};\n\n  const isSelector =\n    typeof localeOrSelector === 'object' && localeOrSelector !== null;\n\n  // Stable identity of the second argument for memoization\n  const localeOrSelectorIdentity = isSelector\n    ? `${localeOrSelector.locale ?? ''}|${getDictionarySelectorCacheKey(localeOrSelector)}`\n    : localeOrSelector;\n\n  return useMemo(() => {\n    if (isSelector) {\n      return getIntlayer(key, {\n        ...localeOrSelector,\n        locale: localeOrSelector.locale ?? currentLocale,\n      } as A);\n    }\n\n    const localeTarget = (localeOrSelector ?? currentLocale) as A;\n\n    return getIntlayer<T, A>(key, localeTarget);\n  }, [key, currentLocale, localeOrSelectorIdentity]);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,MAAa,eAIX,KACA,qBACG;CACH,MAAM,EAAE,QAAQ,kBAAkB,WAAW,sBAAsB,IAAI,EAAE;CAEzE,MAAM,aACJ,OAAO,qBAAqB,YAAY,qBAAqB;AAO/D,QAAO,cAAc;AACnB,MAAI,WACF,QAAO,YAAY,KAAK;GACtB,GAAG;GACH,QAAQ,iBAAiB,UAAU;GACpC,CAAM;AAKT,SAAO,YAAkB,KAFH,oBAAoB,cAEC;IAC1C;EAAC;EAAK;EAfwB,aAC7B,GAAG,iBAAiB,UAAU,GAAG,GAAG,8BAA8B,iBAAiB,KACnF;EAa6C,CAAC"}

package/dist/esm/getDictionary.mjs

@@ -2,7 +2,14 @@ import { getPlugins } from "./plugins.mjs";
 import { getDictionary as getDictionary$1 } from "@intlayer/core/interpreter";
 
 //#region src/getDictionary.ts
-const getDictionary = (dictionary, locale) => getDictionary$1(dictionary, locale, getPlugins(locale));
+/**
+* Transforms a dictionary (or qualified dictionary group) and returns its
+* content for the given locale or selector (`{ item }`, `{ variant }`,
+* `{ id, ...meta }`, optionally combined with `locale`).
+*/
+const getDictionary = (dictionary, localeOrSelector) => {
+	return getDictionary$1(dictionary, localeOrSelector, getPlugins(typeof localeOrSelector === "object" && localeOrSelector !== null ? localeOrSelector.locale : localeOrSelector));
+};
 
 //#endregion
 export { getDictionary };

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 { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { type DeepTransformContent, getPlugins } from './plugins';\n\nexport const getDictionary = <\n  const T extends Dictionary,\n  const L extends LocalesValues = DeclaredLocales,\n>(\n  dictionary: T,\n  locale?: L\n): DeepTransformContent<T['content'], L> =>\n  getDictionaryCore(dictionary, locale, getPlugins(locale)) as any;\n"],"mappings":";;;;AAQA,MAAa,iBAIX,YACA,WAEAA,gBAAkB,YAAY,QAAQ,WAAW,OAAO,CAAC"}
+{"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 * `{ id, ...meta }`, 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;AAOH,QAAOA,gBACL,YACA,kBACA,WARA,OAAO,qBAAqB,YAAY,qBAAqB,OACzD,iBAAiB,SACjB,iBAMc,CACnB"}

package/dist/esm/getIntlayer.mjs

@@ -2,7 +2,14 @@ import { getPlugins } from "./plugins.mjs";
 import { getIntlayer as getIntlayer$1 } from "@intlayer/core/interpreter";
 
 //#region src/getIntlayer.ts
-const getIntlayer = (key, locale) => getIntlayer$1(key, locale, getPlugins(locale));
+/**
+* Picks one dictionary by its key and returns its content for the given
+* locale or selector (`{ item }`, `{ variant }`, `{ id, ...meta }`,
+* optionally combined with `locale`).
+*/
+const getIntlayer = (key, localeOrSelector) => {
+	return getIntlayer$1(key, localeOrSelector, getPlugins(typeof localeOrSelector === "object" && localeOrSelector !== null ? localeOrSelector.locale : localeOrSelector));
+};
 
 //#endregion
 export { getIntlayer };

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  DictionaryRegistryContent,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { type DeepTransformContent, getPlugins } from './plugins';\n\nexport const getIntlayer = <\n  const T extends DictionaryKeys,\n  const L extends LocalesValues = DeclaredLocales,\n>(\n  key: T,\n  locale?: L\n): DeepTransformContent<DictionaryRegistryContent<T>, L> =>\n  getIntlayerCore(key, locale, getPlugins(locale)) as any;\n"],"mappings":";;;;AASA,MAAa,eAIX,KACA,WAEAA,cAAgB,KAAK,QAAQ,WAAW,OAAO,CAAC"}
+{"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 }`, `{ id, ...meta }`,\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;AAOH,QAAOA,cAAgB,KAAK,kBAAkB,WAL5C,OAAO,qBAAqB,YAAY,qBAAqB,OACzD,iBAAiB,SACjB,iBAG0D,CAAC"}

package/dist/esm/server/useDictionary.mjs

@@ -4,12 +4,19 @@ import { IntlayerServerContext } from "./IntlayerServerProvider.mjs";
 
 //#region src/server/useDictionary.ts
 /**
-* On the server side, Hook that transform a dictionary and return the content
+* On the server side, Hook that transform a dictionary (or qualified
+* dictionary group) and return the content
 *
-* If the locale is not provided, it will use the locale from the server context
+* If the locale is not provided (directly or through the selector), it will
+* use the locale from the server context
 */
-const useDictionary = (dictionary, locale, fallbackLocale) => {
-	return getDictionary(dictionary, locale ?? getServerContext(IntlayerServerContext) ?? fallbackLocale);
+const useDictionary = (dictionary, localeOrSelector, fallbackLocale) => {
+	const contextLocale = getServerContext(IntlayerServerContext) ?? fallbackLocale;
+	if (typeof localeOrSelector === "object" && localeOrSelector !== null) return getDictionary(dictionary, {
+		...localeOrSelector,
+		locale: localeOrSelector.locale ?? contextLocale
+	});
+	return getDictionary(dictionary, localeOrSelector ?? contextLocale);
 };
 
 //#endregion

package/dist/esm/server/useDictionary.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"useDictionary.mjs","names":[],"sources":["../../../src/server/useDictionary.ts"],"sourcesContent":["import type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { getDictionary } from '../getDictionary';\nimport { IntlayerServerContext } from './IntlayerServerProvider';\nimport { getServerContext } from './serverContext';\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 useDictionary = <\n  const T extends Dictionary,\n  const L extends LocalesValues = DeclaredLocales,\n>(\n  dictionary: T,\n  locale?: L,\n  fallbackLocale?: DeclaredLocales\n) => {\n  const localeTarget =\n    locale ??\n    getServerContext<LocalesValues>(IntlayerServerContext) ??\n    fallbackLocale;\n\n  return getDictionary<T, L>(dictionary, localeTarget as L);\n};\n"],"mappings":";;;;;;;;;;AAcA,MAAa,iBAIX,YACA,QACA,mBACG;AAMH,QAAO,cAAoB,YAJzB,UACA,iBAAgC,sBAAsB,IACtD,eAEuD"}
+{"version":3,"file":"useDictionary.mjs","names":[],"sources":["../../../src/server/useDictionary.ts"],"sourcesContent":["import type {\n  Dictionary,\n  DictionarySelectorForGroup,\n  QualifiedDictionaryGroup,\n} from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { getDictionary } from '../getDictionary';\nimport { IntlayerServerContext } 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 (typeof localeOrSelector === 'object' && localeOrSelector !== null) {\n    return getDictionary(dictionary, {\n      ...localeOrSelector,\n      locale: localeOrSelector.locale ?? contextLocale,\n    } as A);\n  }\n\n  const localeTarget = (localeOrSelector ?? contextLocale) as A;\n\n  return getDictionary<T, A>(dictionary, localeTarget);\n};\n"],"mappings":";;;;;;;;;;;;AAoBA,MAAa,iBAMX,YACA,kBACA,mBACG;CACH,MAAM,gBACJ,iBAAgC,sBAAsB,IAAI;AAE5D,KAAI,OAAO,qBAAqB,YAAY,qBAAqB,KAC/D,QAAO,cAAc,YAAY;EAC/B,GAAG;EACH,QAAQ,iBAAiB,UAAU;EACpC,CAAM;AAKT,QAAO,cAAoB,YAFL,oBAAoB,cAEU"}

package/dist/esm/server/useDictionaryDynamic.mjs

@@ -1,18 +1,35 @@
+import { getDictionary } from "../getDictionary.mjs";
 import { getServerContext } from "./serverContext.mjs";
 import { IntlayerServerContext } from "./IntlayerServerProvider.mjs";
-import { useDictionary } from "./useDictionary.mjs";
 import { useLoadDynamic } from "./useLoadDynamic.mjs";
 import { internationalization } from "@intlayer/config/built";
+import { isQualifiedDynamicLoaderMap, parseDictionarySelector, resolveQualifiedDynamicContent } from "@intlayer/core/dictionaryManipulator";
 
 //#region src/server/useDictionaryDynamic.ts
 /**
-* On the server side, Hook that transform a dictionary and return the content
+* Server-side hook that lazily loads a dictionary and returns its content.
 *
-* If the locale is not provided, it will use the locale from the server context
+* The dictionary entry is either a plain dynamic loader map
+* (`locale → loader`) or a qualified one (`locale → qualifierId → loader`,
+* tagged with the qualifier dimension). For qualified maps, only the chunk(s)
+* the selector targets are loaded; the resolution mirrors static mode.
+*
+* If the locale is not provided (directly or through the selector), the server
+* context locale is used.
 */
-const useDictionaryDynamic = (dictionaryPromise, key, locale, fallbackLocale) => {
-	const localeTarget = locale ?? getServerContext(IntlayerServerContext) ?? fallbackLocale ?? internationalization.defaultLocale;
-	return useDictionary(useLoadDynamic(`${String(key)}.${localeTarget}`, dictionaryPromise[localeTarget]?.()), localeTarget);
+const useDictionaryDynamic = (dictionaryPromise, key, localeOrSelector, fallbackLocale) => {
+	const { locale: selectorLocale, selector } = parseDictionarySelector(localeOrSelector);
+	const localeTarget = selectorLocale ?? getServerContext(IntlayerServerContext) ?? fallbackLocale ?? internationalization.defaultLocale;
+	if (isQualifiedDynamicLoaderMap(dictionaryPromise)) return resolveQualifiedDynamicContent({
+		loaderMap: dictionaryPromise,
+		key: String(key),
+		locale: localeTarget,
+		selector,
+		loadChunk: (cacheKey, promise) => useLoadDynamic(cacheKey, promise),
+		transform: (dictionary) => getDictionary(dictionary, localeTarget)
+	});
+	const plainLoaders = dictionaryPromise;
+	return getDictionary(useLoadDynamic(`${String(key)}.${localeTarget}`, plainLoaders[localeTarget]?.()), localeTarget);
 };
 
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"useDictionaryDynamic.mjs","names":[],"sources":["../../../src/server/useDictionaryDynamic.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';\nimport { useLoadDynamic } from './useLoadDynamic';\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 useDictionaryDynamic = <\n  const T extends Dictionary,\n  const L extends LocalesValues = DeclaredLocales,\n>(\n  dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>,\n  key: string,\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 = useLoadDynamic<T>(\n    `${String(key)}.${localeTarget}`,\n    (dictionaryPromise as any)[localeTarget]?.()\n  );\n\n  return useDictionary<T, L>(dictionary, localeTarget as L);\n};\n"],"mappings":";;;;;;;;;;;;AAiBA,MAAa,wBAIX,mBACA,KACA,QACA,mBACG;CACH,MAAM,eACJ,UACA,iBAAgC,sBAAsB,IACtD,kBACA,qBAAqB;AAOvB,QAAO,cALY,eACjB,GAAG,OAAO,IAAI,CAAC,GAAG,gBACjB,kBAA0B,iBAAiB,CAGT,EAAE,aAAkB"}
+{"version":3,"file":"useDictionaryDynamic.mjs","names":["loadDynamicChunk"],"sources":["../../../src/server/useDictionaryDynamic.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport {\n  isQualifiedDynamicLoaderMap,\n  parseDictionarySelector,\n  type QualifiedDynamicLoaderMap,\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  StrictModeLocaleMap,\n} from '@intlayer/types/module_augmentation';\nimport { getDictionary } from '../getDictionary';\nimport { IntlayerServerContext } 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 = LocalesValues,\n>(\n  dictionaryPromise:\n    | StrictModeLocaleMap<() => Promise<T>>\n    | QualifiedDynamicLoaderMap,\n  key: string,\n  localeOrSelector?: A,\n  fallbackLocale?: DeclaredLocales\n) => {\n  const { locale: selectorLocale, selector } =\n    parseDictionarySelector<LocalesValues>(localeOrSelector);\n\n  const localeTarget =\n    selectorLocale ??\n    getServerContext<LocalesValues>(IntlayerServerContext) ??\n    fallbackLocale ??\n    internationalization.defaultLocale;\n\n  if (isQualifiedDynamicLoaderMap(dictionaryPromise)) {\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":";;;;;;;;;;;;;;;;;;;AAmCA,MAAa,wBAIX,mBAGA,KACA,kBACA,mBACG;CACH,MAAM,EAAE,QAAQ,gBAAgB,aAC9B,wBAAuC,iBAAiB;CAE1D,MAAM,eACJ,kBACA,iBAAgC,sBAAsB,IACtD,kBACA,qBAAqB;AAEvB,KAAI,4BAA4B,kBAAkB,CAChD,QAAO,+BAA+B;EACpC,WAAW;EACX,KAAK,OAAO,IAAI;EAChB,QAAQ;EACR;EACA,YAAY,UAAU,YAAYA,eAAiB,UAAU,QAAQ;EACrE,YAAY,eAAe,cAAc,YAAY,aAAa;EACnE,CAAC;CAGJ,MAAM,eAAe;AASrB,QAAO,cALYA,eACjB,GAAG,OAAO,IAAI,CAAC,GAAG,gBAClB,aAAa,iBAA8C,CAG9B,EAAE,aAAa"}

package/dist/esm/server/useIntlayer.mjs

@@ -6,10 +6,18 @@ import { IntlayerServerContext } from "./IntlayerServerProvider.mjs";
 /**
 * On the server side, Hook that picking one dictionary by its key and return the content
 *
+* The second argument is either a locale or a selector object
+* (`{ item }`, `{ variant }`, `{ id, ...meta }`, optionally with `locale`).
+*
 * If the locale is not provided, it will use the locale from the server context
 */
-const useIntlayer = (key, locale, fallbackLocale) => {
-	return getIntlayer(key, locale ?? getServerContext(IntlayerServerContext) ?? fallbackLocale);
+const useIntlayer = (key, localeOrSelector, fallbackLocale) => {
+	const contextLocale = getServerContext(IntlayerServerContext) ?? fallbackLocale;
+	if (typeof localeOrSelector === "object" && localeOrSelector !== null) return getIntlayer(key, {
+		...localeOrSelector,
+		locale: localeOrSelector.locale ?? contextLocale
+	});
+	return getIntlayer(key, localeOrSelector ?? contextLocale);
 };
 
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"useIntlayer.mjs","names":[],"sources":["../../../src/server/useIntlayer.ts"],"sourcesContent":["import type {\n  DeclaredLocales,\n  DictionaryKeys,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { getIntlayer } from '../getIntlayer';\nimport { IntlayerServerContext } 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 * 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 L extends LocalesValues = DeclaredLocales,\n>(\n  key: T,\n  locale?: L,\n  fallbackLocale?: DeclaredLocales\n) => {\n  const localeTarget =\n    locale ??\n    getServerContext<LocalesValues>(IntlayerServerContext) ??\n    fallbackLocale;\n\n  return getIntlayer<T, L>(key, localeTarget as L);\n};\n"],"mappings":";;;;;;;;;;AAcA,MAAa,eAIX,KACA,QACA,mBACG;AAMH,QAAO,YAAkB,KAJvB,UACA,iBAAgC,sBAAsB,IACtD,eAE8C"}
+{"version":3,"file":"useIntlayer.mjs","names":[],"sources":["../../../src/server/useIntlayer.ts"],"sourcesContent":["import type {\n  DeclaredLocales,\n  DictionaryKeys,\n  DictionarySelectorForKey,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { getIntlayer } from '../getIntlayer';\nimport { IntlayerServerContext } 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 }`, `{ id, ...meta }`, 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 (typeof localeOrSelector === 'object' && localeOrSelector !== null) {\n    return getIntlayer(key, {\n      ...localeOrSelector,\n      locale: localeOrSelector.locale ?? contextLocale,\n    } as A);\n  }\n\n  const localeTarget = (localeOrSelector ?? contextLocale) as A;\n\n  return getIntlayer<T, A>(key, localeTarget);\n};\n"],"mappings":";;;;;;;;;;;;;AAkBA,MAAa,eAIX,KACA,kBACA,mBACG;CACH,MAAM,gBACJ,iBAAgC,sBAAsB,IAAI;AAE5D,KAAI,OAAO,qBAAqB,YAAY,qBAAqB,KAC/D,QAAO,YAAY,KAAK;EACtB,GAAG;EACH,QAAQ,iBAAiB,UAAU;EACpC,CAAM;AAKT,QAAO,YAAkB,KAFH,oBAAoB,cAEC"}

package/dist/types/client/useDictionary.d.ts

@@ -1,15 +1,18 @@
 import { IInterpreterPluginState as IInterpreterPluginState$1 } from "../plugins.js";
 import * as _$_intlayer_core_interpreter0 from "@intlayer/core/interpreter";
 import { DeclaredLocales, LocalesValues } from "@intlayer/types/module_augmentation";
-import { Dictionary } from "@intlayer/types/dictionary";
+import * as _$_intlayer_types0 from "@intlayer/types";
+import { Dictionary, DictionarySelectorForGroup, QualifiedDictionaryGroup } from "@intlayer/types/dictionary";
 
 //#region src/client/useDictionary.d.ts
 /**
- * On the server side, Hook that transform a dictionary and return the content
+ * Client-side hook that transforms a dictionary (or qualified dictionary
+ * group) and returns the content.
  *
- * If the locale is not provided, it will use the locale from the client context
+ * If the locale is not provided (directly or through the selector), it will
+ * use the locale from the client context.
  */
-declare const useDictionary: <const T extends Dictionary, const L extends LocalesValues = DeclaredLocales>(dictionary: T, locale?: L) => _$_intlayer_core_interpreter0.DeepTransformContent<T["content"], IInterpreterPluginState$1, L>;
+declare const useDictionary: <const T extends Dictionary | QualifiedDictionaryGroup, const A extends LocalesValues | DictionarySelectorForGroup<T> = DeclaredLocales>(dictionary: T, localeOrSelector?: A) => _$_intlayer_core_interpreter0.DeepTransformContent<_$_intlayer_types0.ResolveQualifiedDictionaryContent<T, A>, IInterpreterPluginState$1, _$_intlayer_types0.ExtractSelectorLocale<A>>;
 //#endregion
 export { useDictionary };
 //# sourceMappingURL=useDictionary.d.ts.map

package/dist/types/client/useDictionary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDictionary.d.ts","names":[],"sources":["../../../src/client/useDictionary.ts"],"mappings":";;;;;;;;;;AAgBA;cAAa,aAAA,mBACK,UAAA,kBACA,aAAA,GAAgB,eAAA,EAEhC,UAAA,EAAY,CAAA,EACZ,MAAA,GAAS,CAAA,KAAC,6BAAA,CAAA,oBAAA,CAAA,CAAA,aAAA,yBAAA,EAAA,CAAA"}
+{"version":3,"file":"useDictionary.d.ts","names":[],"sources":["../../../src/client/useDictionary.ts"],"mappings":";;;;;;;;;;;;AAuBA;;cAAa,aAAA,mBACK,UAAA,GAAa,wBAAA,kBAEzB,aAAA,GACA,0BAAA,CAA2B,CAAA,IAAK,eAAA,EAEpC,UAAA,EAAY,CAAA,EACZ,gBAAA,GAAmB,CAAA,KAAC,6BAAA,CAAA,oBAAA,CAAA,kBAAA,CAAA,iCAAA,CAAA,CAAA,EAAA,CAAA,GAAA,yBAAA,EAAA,kBAAA,CAAA,qBAAA,CAAA,CAAA"}

package/dist/types/client/useDictionaryDynamic.d.ts

@@ -1,15 +1,20 @@
-import { IInterpreterPluginState as IInterpreterPluginState$1 } from "../plugins.js";
-import * as _$_intlayer_core_interpreter0 from "@intlayer/core/interpreter";
-import { DictionaryKeys, LocalesValues, StrictModeLocaleMap } from "@intlayer/types/module_augmentation";
+import { DictionaryKeys, DictionarySelectorForKey, LocalesValues, StrictModeLocaleMap } from "@intlayer/types/module_augmentation";
 import { Dictionary } from "@intlayer/types/dictionary";
+import { QualifiedDynamicLoaderMap } from "@intlayer/core/dictionaryManipulator";
 
 //#region src/client/useDictionaryDynamic.d.ts
 /**
- * On the server side, Hook that transform a dictionary and return the content
+ * Client-side hook that lazily loads a dictionary and returns its content.
  *
- * If the locale is not provided, it will use the locale from the client context
+ * The dictionary entry is either a plain dynamic loader map
+ * (`locale → loader`) or a qualified one (`locale → qualifierId → loader`,
+ * tagged with the qualifier dimension). For qualified maps, only the chunk(s)
+ * the selector targets are loaded; the resolution mirrors static mode.
+ *
+ * If the locale is not provided (directly or through the selector), the client
+ * context locale is used.
  */
-declare const useDictionaryDynamic: <const T extends Dictionary, const K extends DictionaryKeys>(dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>, key: K, locale?: LocalesValues) => _$_intlayer_core_interpreter0.DeepTransformContent<T["content"], IInterpreterPluginState$1, any>;
+declare const useDictionaryDynamic: <const T extends Dictionary, const K extends DictionaryKeys, const A extends LocalesValues | DictionarySelectorForKey<K> = LocalesValues>(dictionaryPromise: StrictModeLocaleMap<() => Promise<T>> | QualifiedDynamicLoaderMap, key: K, localeOrSelector?: A) => any;
 //#endregion
 export { useDictionaryDynamic };
 //# sourceMappingURL=useDictionaryDynamic.d.ts.map

package/dist/types/client/useDictionaryDynamic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDictionaryDynamic.d.ts","names":[],"sources":["../../../src/client/useDictionaryDynamic.ts"],"mappings":";;;;;;;;;;AAmBA;cAAa,oBAAA,mBACK,UAAA,kBACA,cAAA,EAEhB,iBAAA,EAAmB,mBAAA,OAA0B,OAAA,CAAQ,CAAA,IACrD,GAAA,EAAK,CAAA,EACL,MAAA,GAAS,aAAA,KAAa,6BAAA,CAAA,oBAAA,CAAA,CAAA,aAAA,yBAAA"}
+{"version":3,"file":"useDictionaryDynamic.d.ts","names":[],"sources":["../../../src/client/useDictionaryDynamic.ts"],"mappings":";;;;;;;AAmCA;;;;;;;;;cAAa,oBAAA,mBACK,UAAA,kBACA,cAAA,kBACA,aAAA,GAAgB,wBAAA,CAAyB,CAAA,IAAK,aAAA,EAE9D,iBAAA,EACI,mBAAA,OAA0B,OAAA,CAAQ,CAAA,KAClC,yBAAA,EACJ,GAAA,EAAK,CAAA,EACL,gBAAA,GAAmB,CAAA"}

package/dist/types/client/useIntlayer.d.ts

@@ -1,17 +1,21 @@
 import { IInterpreterPluginState as IInterpreterPluginState$1 } from "../plugins.js";
 import * as _$_intlayer_core_interpreter0 from "@intlayer/core/interpreter";
-import { DeclaredLocales, DictionaryKeys, LocalesValues } from "@intlayer/types/module_augmentation";
+import { DeclaredLocales, DictionaryKeys, DictionarySelectorForKey, LocalesValues } from "@intlayer/types/module_augmentation";
 import * as _$_intlayer_types0 from "@intlayer/types";
 
 //#region src/client/useIntlayer.d.ts
 /**
  * Client-side hook that picks one dictionary by its key and returns its content.
  *
- * If the locale is not provided, it will use the locale from the client context.
+ * The second argument is either a locale or a selector object:
+ * - `{ item: 2 }` — collection item (omit `item` to get every item as array)
+ * - `{ variant: 'black-friday' }` — named variant (omit for the `default` one)
+ * - `{ id: 'prod_abc', ...metaFields }` — meta record
+ * - `locale` composes with any selector and overrides the context locale
  *
  * @param key - The unique key of the dictionary to retrieve.
- * @param locale - Optional locale to override the current context locale.
- * @returns The dictionary content for the specified locale.
+ * @param localeOrSelector - Optional locale or selector.
+ * @returns The dictionary content for the resolved entry and locale.
  *
  * @example
  * ```tsx
@@ -19,12 +23,13 @@ import * as _$_intlayer_types0 from "@intlayer/types";
  *
  * const MyComponent = () => {
  *   const content = useIntlayer('my-dictionary-key');
+ *   const faq2 = useIntlayer('faq', { item: 2 });
  *
  *   return <div>{content.myField.value}</div>;
  * };
  * ```
  */
-declare const useIntlayer: <const T extends DictionaryKeys, const L extends LocalesValues = DeclaredLocales>(key: T, locale?: L) => _$_intlayer_core_interpreter0.DeepTransformContent<_$_intlayer_types0.DictionaryRegistryContent<T>, IInterpreterPluginState$1, L>;
+declare const useIntlayer: <const T extends DictionaryKeys, const A extends LocalesValues | DictionarySelectorForKey<T> = DeclaredLocales>(key: T, localeOrSelector?: A) => _$_intlayer_core_interpreter0.DeepTransformContent<_$_intlayer_types0.DictionaryRegistryResult<T, A>, IInterpreterPluginState$1, _$_intlayer_types0.ExtractSelectorLocale<A>>;
 //#endregion
 export { useIntlayer };
 //# sourceMappingURL=useIntlayer.d.ts.map

package/dist/types/client/useIntlayer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useIntlayer.d.ts","names":[],"sources":["../../../src/client/useIntlayer.ts"],"mappings":";;;;;;;;;;;AA+BA;;;;;;;;;;;;;;;cAAa,WAAA,mBACK,cAAA,kBACA,aAAA,GAAgB,eAAA,EAEhC,GAAA,EAAK,CAAA,EACL,MAAA,GAAS,CAAA,KAAC,6BAAA,CAAA,oBAAA,CAAA,kBAAA,CAAA,yBAAA,CAAA,CAAA,GAAA,yBAAA,EAAA,CAAA"}
+{"version":3,"file":"useIntlayer.d.ts","names":[],"sources":["../../../src/client/useIntlayer.ts"],"mappings":";;;;;;;;;;;AAsCA;;;;;;;;;;;;;;;;;;;;cAAa,WAAA,mBACK,cAAA,kBACA,aAAA,GAAgB,wBAAA,CAAyB,CAAA,IAAK,eAAA,EAE9D,GAAA,EAAK,CAAA,EACL,gBAAA,GAAmB,CAAA,KAAC,6BAAA,CAAA,oBAAA,CAAA,kBAAA,CAAA,wBAAA,CAAA,CAAA,EAAA,CAAA,GAAA,yBAAA,EAAA,kBAAA,CAAA,qBAAA,CAAA,CAAA"}

package/dist/types/getDictionary.d.ts

@@ -1,9 +1,14 @@
 import { DeepTransformContent } from "./plugins.js";
-import { DeclaredLocales, LocalesValues } from "@intlayer/types/module_augmentation";
-import { Dictionary } from "@intlayer/types/dictionary";
+import { DeclaredLocales, ExtractSelectorLocale, LocalesValues } from "@intlayer/types/module_augmentation";
+import { Dictionary, DictionarySelectorForGroup, QualifiedDictionaryGroup, ResolveQualifiedDictionaryContent } from "@intlayer/types/dictionary";
 
 //#region src/getDictionary.d.ts
-declare const getDictionary: <const T extends Dictionary, const L extends LocalesValues = DeclaredLocales>(dictionary: T, locale?: L) => DeepTransformContent<T["content"], L>;
+/**
+ * Transforms a dictionary (or qualified dictionary group) and returns its
+ * content for the given locale or selector (`{ item }`, `{ variant }`,
+ * `{ id, ...meta }`, optionally combined with `locale`).
+ */
+declare const getDictionary: <const T extends Dictionary | QualifiedDictionaryGroup, const A extends LocalesValues | DictionarySelectorForGroup<T> = DeclaredLocales>(dictionary: T, localeOrSelector?: A) => DeepTransformContent<ResolveQualifiedDictionaryContent<T, A>, ExtractSelectorLocale<A>>;
 //#endregion
 export { getDictionary };
 //# sourceMappingURL=getDictionary.d.ts.map

package/dist/types/getDictionary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getDictionary.d.ts","names":[],"sources":["../../src/getDictionary.ts"],"mappings":";;;;;cAQa,aAAA,mBACK,UAAA,kBACA,aAAA,GAAgB,eAAA,EAEhC,UAAA,EAAY,CAAA,EACZ,MAAA,GAAS,CAAA,KACR,oBAAA,CAAqB,CAAA,aAAc,CAAA"}
+{"version":3,"file":"getDictionary.d.ts","names":[],"sources":["../../src/getDictionary.ts"],"mappings":";;;;;;;AAmBA;;;cAAa,aAAA,mBACK,UAAA,GAAa,wBAAA,kBAEzB,aAAA,GACA,0BAAA,CAA2B,CAAA,IAAK,eAAA,EAEpC,UAAA,EAAY,CAAA,EACZ,gBAAA,GAAmB,CAAA,KAClB,oBAAA,CACD,iCAAA,CAAkC,CAAA,EAAG,CAAA,GACrC,qBAAA,CAAsB,CAAA"}

package/dist/types/getIntlayer.d.ts

@@ -1,8 +1,13 @@
 import { DeepTransformContent } from "./plugins.js";
-import { DeclaredLocales, DictionaryKeys, DictionaryRegistryContent, LocalesValues } from "@intlayer/types/module_augmentation";
+import { DeclaredLocales, DictionaryKeys, DictionaryRegistryResult, DictionarySelectorForKey, ExtractSelectorLocale, LocalesValues } from "@intlayer/types/module_augmentation";
 
 //#region src/getIntlayer.d.ts
-declare const getIntlayer: <const T extends DictionaryKeys, const L extends LocalesValues = DeclaredLocales>(key: T, locale?: L) => DeepTransformContent<DictionaryRegistryContent<T>, L>;
+/**
+ * Picks one dictionary by its key and returns its content for the given
+ * locale or selector (`{ item }`, `{ variant }`, `{ id, ...meta }`,
+ * optionally combined with `locale`).
+ */
+declare const getIntlayer: <const T extends DictionaryKeys, const A extends LocalesValues | DictionarySelectorForKey<T> = DeclaredLocales>(key: T, localeOrSelector?: A) => DeepTransformContent<DictionaryRegistryResult<T, A>, ExtractSelectorLocale<A>>;
 //#endregion
 export { getIntlayer };
 //# sourceMappingURL=getIntlayer.d.ts.map

package/dist/types/getIntlayer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getIntlayer.d.ts","names":[],"sources":["../../src/getIntlayer.ts"],"mappings":";;;;cASa,WAAA,mBACK,cAAA,kBACA,aAAA,GAAgB,eAAA,EAEhC,GAAA,EAAK,CAAA,EACL,MAAA,GAAS,CAAA,KACR,oBAAA,CAAqB,yBAAA,CAA0B,CAAA,GAAI,CAAA"}
+{"version":3,"file":"getIntlayer.d.ts","names":[],"sources":["../../src/getIntlayer.ts"],"mappings":";;;;;;AAgBA;;;cAAa,WAAA,mBACK,cAAA,kBACA,aAAA,GAAgB,wBAAA,CAAyB,CAAA,IAAK,eAAA,EAE9D,GAAA,EAAK,CAAA,EACL,gBAAA,GAAmB,CAAA,KAClB,oBAAA,CACD,wBAAA,CAAyB,CAAA,EAAG,CAAA,GAC5B,qBAAA,CAAsB,CAAA"}

package/dist/types/index.d.ts

@@ -71,7 +71,7 @@ declare const useMarkdownRenderer: ({
   forceInline,
   preserveFrontmatter,
   tagfilter
-}?: RenderMarkdownProps$1) => (content: string | _$_intlayer_core_markdown0.ParsedMarkdown) => string | number | bigint | boolean | Iterable<_$react.ReactNode> | Promise<_$react.ReactNode> | _$react.JSX.Element;
+}?: RenderMarkdownProps$1) => (content: string | _$_intlayer_core_markdown0.ParsedMarkdown) => string | number | bigint | boolean | Iterable<_$react.ReactNode> | _$react.JSX.Element | Promise<_$react.ReactNode>;
 /**
  * @deprecated import from react-intlayer/markdown instead
  */

package/dist/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;YAIY,kBAAA,iBAAmC,aAAA,UACnC,uBAAA,CAAwB,CAAA,EAAG,CAAA,EAAG,CAAA;AAAA;;;;;;;cAqD7B,gBAAA,UAAgB,EAAA,CAAA,yBAAA;eAAA,cAAA;;4FAxBlB,yBAAA,EAAA,UAAA,GAAA,cAAA,oBAEG,OAAA,GAEN,OAAA,CAAA,EAAA,CAAA,OAAA,CAAA,cAAA,CAAA,WAAA,OAAA,OAAA,CAAA,SAAA,GAAA,OAAA,CAAA,OAAA,CAAA,SAAA;AAAA;aAAA,OAAA,CAAA,SAAA;AAAA;;;;cAwBK,kBAAA;eAAwC,cAAA;2FAvCG,yBAAA,EAAA,UAAA,GAAA,cAAA,oBAC5B,OAAA,GACI,OAAA,CAAA,EAAA,CAAA,OAAA,CAAA,cAAA,CAAA,WAAA,OAAA,OAAA,CAAA,SAAA,GAAA,OAAA,CAAA,OAAA,CAAA,SAAA;AAAA;;;;KAyCpB,uBAAA,GAA0B,yBAAA;AARtC;;;AAAA,cAYa,cAAA,GAAc,OAAA,WAAkB,0BAAA,CAAlB,cAAA;EAAA,UAAA;EAAA,OAAA;EAAA,UAAA;EAAA,WAAA;EAAA,mBAAA;EAAA;AAAA,IAAA,qBAAA,KAAA,OAAA,CAAA,GAAA,CAAA,OAAA;;;;cAId,mBAAA;EAAmB,UAAA;EAAA,OAAA;EAAA,UAAA;EAAA,WAAA;EAAA,mBAAA;EAAA;AAAA,IAAA,qBAAA,MAak1C,OAAA,WAbl1C,0BAAA,CAak1C,cAAA,0CAAgC,QAAA,CAAA,OAAA,CAAA,SAAA,IAAA,OAAA,CAAA,OAAA,CAAA,SAAA,IAAA,OAAA,CAAA,GAAA,CAAA,OAAA;;;;cATr4C,gBAAA,EAAgB,OAAA,CAAA,EAAA,CAAA,uBAAA;;;;KAIjB,mBAAA,GAAsB,qBAAA;;;;KAItB,qBAAA,GAAwB,uBAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;YAIY,kBAAA,iBAAmC,aAAA,UACnC,uBAAA,CAAwB,CAAA,EAAG,CAAA,EAAG,CAAA;AAAA;;;;;;;cAqD7B,gBAAA,UAAgB,EAAA,CAAA,yBAAA;eAAA,cAAA;;4FAxBlB,yBAAA,EAAA,UAAA,GAAA,cAAA,oBAEG,OAAA,GAEN,OAAA,CAAA,EAAA,CAAA,OAAA,CAAA,cAAA,CAAA,WAAA,OAAA,OAAA,CAAA,SAAA,GAAA,OAAA,CAAA,OAAA,CAAA,SAAA;AAAA;aAAA,OAAA,CAAA,SAAA;AAAA;;;;cAwBK,kBAAA;eAAwC,cAAA;2FAvCG,yBAAA,EAAA,UAAA,GAAA,cAAA,oBAC5B,OAAA,GACI,OAAA,CAAA,EAAA,CAAA,OAAA,CAAA,cAAA,CAAA,WAAA,OAAA,OAAA,CAAA,SAAA,GAAA,OAAA,CAAA,OAAA,CAAA,SAAA;AAAA;;;;KAyCpB,uBAAA,GAA0B,yBAAA;AARtC;;;AAAA,cAYa,cAAA,GAAc,OAAA,WAAkB,0BAAA,CAAlB,cAAA;EAAA,UAAA;EAAA,OAAA;EAAA,UAAA;EAAA,WAAA;EAAA,mBAAA;EAAA;AAAA,IAAA,qBAAA,KAAA,OAAA,CAAA,GAAA,CAAA,OAAA;;;;cAId,mBAAA;EAAmB,UAAA;EAAA,OAAA;EAAA,UAAA;EAAA,WAAA;EAAA,mBAAA;EAAA;AAAA,IAAA,qBAAA,MAak1C,OAAA,WAbl1C,0BAAA,CAak1C,cAAA,0CAAgC,QAAA,CAAA,OAAA,CAAA,SAAA,IAAA,OAAA,CAAA,GAAA,CAAA,OAAA,GAAA,OAAA,CAAA,OAAA,CAAA,SAAA;;;;cATr4C,gBAAA,EAAgB,OAAA,CAAA,EAAA,CAAA,uBAAA;;;;KAIjB,mBAAA,GAAsB,qBAAA;;;;KAItB,qBAAA,GAAwB,uBAAA"}

package/dist/types/markdown/MarkdownRenderer.d.ts

@@ -134,7 +134,7 @@ declare const useMarkdownRenderer: ({
   forceInline,
   preserveFrontmatter,
   tagfilter
-}?: RenderMarkdownProps) => (content: string | ParsedMarkdown) => string | number | bigint | boolean | Iterable<ReactNode> | Promise<ReactNode> | JSX.Element;
+}?: RenderMarkdownProps) => (content: string | ParsedMarkdown) => string | number | bigint | boolean | Iterable<ReactNode> | JSX.Element | Promise<ReactNode>;
 /**
  * Props for the MarkdownRenderer component.
  *

package/dist/types/markdown/MarkdownRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MarkdownRenderer.d.ts","names":[],"sources":["../../../src/markdown/MarkdownRenderer.tsx"],"mappings":";;;;;;;;AAiCA;;;;;;;;;;;;;;;;;KAAY,mBAAA,GAAsB,uBAAA;EAwBO;AA4BzC;;;;;;;;;;;;EAtCE,UAAA,GAAa,cAAA;EA6Dd;;;;;;;;;EAnDC,OAAA,GAAU,EAAA,CAAG,cAAA,CAAe,WAAA;AAAA;;;;;;;;;;AAkG9B;;;;;;;;;;;;;;;;cAtEa,cAAA,GACX,OAAA,WAAkB,cAAA;EAClB,UAAA;EAAA,OAAA;EAAA,UAAA;EAAA,WAAA;EAAA,mBAAA;EAAA;AAAA,IAOG,mBAAA,KACF,GAAA,CAAI,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;AA+GP;;;;;;;;;;;;;;;;;;;;;cAnDa,mBAAA;EAAuB,UAAA;EAAA,OAAA;EAAA,UAAA;EAAA,WAAA;EAAA,mBAAA;EAAA;AAAA,IAOjC,mBAAA,MAGO,OAAA,WAAkB,cAAA,0CAAc,QAAA,CAAA,SAAA,IAAA,OAAA,CAAA,SAAA,IAAA,GAAA,CAAA,OAAA;;;;;;;;;;;;AAmJ1C;;;;KA1GY,qBAAA,GAAwB,mBAAA;;;;;;;;;;;EAWlC,QAAA,WAAmB,cAAA;;;;;;;;;;;;;;;;;;;;;EAqBnB,cAAA,IACE,QAAA,WAAmB,cAAA,EACnB,OAAA;IACE,UAAA,GAAa,cAAA;IACb,OAAA,GAAU,EAAA;IACV,UAAA;IACA,WAAA;IACA,mBAAA;IACA,SAAA;EAAA,MAEC,SAAA,GAAY,OAAA,CAAQ,SAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAgEd,gBAAA,EAAkB,EAAA,CAAG,qBAAA"}
+{"version":3,"file":"MarkdownRenderer.d.ts","names":[],"sources":["../../../src/markdown/MarkdownRenderer.tsx"],"mappings":";;;;;;;;AAiCA;;;;;;;;;;;;;;;;;KAAY,mBAAA,GAAsB,uBAAA;EAwBO;AA4BzC;;;;;;;;;;;;EAtCE,UAAA,GAAa,cAAA;EA6Dd;;;;;;;;;EAnDC,OAAA,GAAU,EAAA,CAAG,cAAA,CAAe,WAAA;AAAA;;;;;;;;;;AAkG9B;;;;;;;;;;;;;;;;cAtEa,cAAA,GACX,OAAA,WAAkB,cAAA;EAClB,UAAA;EAAA,OAAA;EAAA,UAAA;EAAA,WAAA;EAAA,mBAAA;EAAA;AAAA,IAOG,mBAAA,KACF,GAAA,CAAI,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;AA+GP;;;;;;;;;;;;;;;;;;;;;cAnDa,mBAAA;EAAuB,UAAA;EAAA,OAAA;EAAA,UAAA;EAAA,WAAA;EAAA,mBAAA;EAAA;AAAA,IAOjC,mBAAA,MAGO,OAAA,WAAkB,cAAA,0CAAc,QAAA,CAAA,SAAA,IAAA,GAAA,CAAA,OAAA,GAAA,OAAA,CAAA,SAAA;;;;;;;;;;;;AAmJ1C;;;;KA1GY,qBAAA,GAAwB,mBAAA;;;;;;;;;;;EAWlC,QAAA,WAAmB,cAAA;;;;;;;;;;;;;;;;;;;;;EAqBnB,cAAA,IACE,QAAA,WAAmB,cAAA,EACnB,OAAA;IACE,UAAA,GAAa,cAAA;IACb,OAAA,GAAU,EAAA;IACV,UAAA;IACA,WAAA;IACA,mBAAA;IACA,SAAA;EAAA,MAEC,SAAA,GAAY,OAAA,CAAQ,SAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAgEd,gBAAA,EAAkB,EAAA,CAAG,qBAAA"}

package/dist/types/server/useDictionary.d.ts

@@ -1,15 +1,18 @@
 import { IInterpreterPluginState as IInterpreterPluginState$1 } from "../plugins.js";
 import * as _$_intlayer_core_interpreter0 from "@intlayer/core/interpreter";
 import { DeclaredLocales, LocalesValues } from "@intlayer/types/module_augmentation";
-import { Dictionary } from "@intlayer/types/dictionary";
+import * as _$_intlayer_types0 from "@intlayer/types";
+import { Dictionary, DictionarySelectorForGroup, QualifiedDictionaryGroup } from "@intlayer/types/dictionary";
 
 //#region src/server/useDictionary.d.ts
 /**
- * On the server side, Hook that transform a dictionary and return the content
+ * On the server side, Hook that transform a dictionary (or qualified
+ * dictionary group) and return the content
  *
- * If the locale is not provided, it will use the locale from the server context
+ * If the locale is not provided (directly or through the selector), it will
+ * use the locale from the server context
  */
-declare const useDictionary: <const T extends Dictionary, const L extends LocalesValues = DeclaredLocales>(dictionary: T, locale?: L, fallbackLocale?: DeclaredLocales) => _$_intlayer_core_interpreter0.DeepTransformContent<T["content"], IInterpreterPluginState$1, L>;
+declare const useDictionary: <const T extends Dictionary | QualifiedDictionaryGroup, const A extends LocalesValues | DictionarySelectorForGroup<T> = DeclaredLocales>(dictionary: T, localeOrSelector?: A, fallbackLocale?: DeclaredLocales) => _$_intlayer_core_interpreter0.DeepTransformContent<_$_intlayer_types0.ResolveQualifiedDictionaryContent<T, A>, IInterpreterPluginState$1, _$_intlayer_types0.ExtractSelectorLocale<A>>;
 //#endregion
 export { useDictionary };
 //# sourceMappingURL=useDictionary.d.ts.map

package/dist/types/server/useDictionary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDictionary.d.ts","names":[],"sources":["../../../src/server/useDictionary.ts"],"mappings":";;;;;;;;;;AAcA;cAAa,aAAA,mBACK,UAAA,kBACA,aAAA,GAAgB,eAAA,EAEhC,UAAA,EAAY,CAAA,EACZ,MAAA,GAAS,CAAA,EACT,cAAA,GAAiB,eAAA,KAAe,6BAAA,CAAA,oBAAA,CAAA,CAAA,aAAA,yBAAA,EAAA,CAAA"}
+{"version":3,"file":"useDictionary.d.ts","names":[],"sources":["../../../src/server/useDictionary.ts"],"mappings":";;;;;;;;;;;;AAoBA;;cAAa,aAAA,mBACK,UAAA,GAAa,wBAAA,kBAEzB,aAAA,GACA,0BAAA,CAA2B,CAAA,IAAK,eAAA,EAEpC,UAAA,EAAY,CAAA,EACZ,gBAAA,GAAmB,CAAA,EACnB,cAAA,GAAiB,eAAA,KAAe,6BAAA,CAAA,oBAAA,CAAA,kBAAA,CAAA,iCAAA,CAAA,CAAA,EAAA,CAAA,GAAA,yBAAA,EAAA,kBAAA,CAAA,qBAAA,CAAA,CAAA"}

package/dist/types/server/useDictionaryAsync.d.ts

@@ -1,6 +1,7 @@
 import { IInterpreterPluginState as IInterpreterPluginState$1 } from "../plugins.js";
 import * as _$_intlayer_core_interpreter0 from "@intlayer/core/interpreter";
 import { DeclaredLocales, LocalesValues, StrictModeLocaleMap } from "@intlayer/types/module_augmentation";
+import * as _$_intlayer_types0 from "@intlayer/types";
 import { Dictionary } from "@intlayer/types/dictionary";
 
 //#region src/server/useDictionaryAsync.d.ts
@@ -9,7 +10,7 @@ import { Dictionary } from "@intlayer/types/dictionary";
  *
  * If the locale is not provided, it will use the locale from the server context
  */
-declare const useDictionaryAsync: <const T extends Dictionary, const L extends LocalesValues = DeclaredLocales>(dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>, locale?: L, fallbackLocale?: DeclaredLocales) => Promise<_$_intlayer_core_interpreter0.DeepTransformContent<T["content"], IInterpreterPluginState$1, L>>;
+declare const useDictionaryAsync: <const T extends Dictionary, const L extends LocalesValues = DeclaredLocales>(dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>, locale?: L, fallbackLocale?: DeclaredLocales) => Promise<_$_intlayer_core_interpreter0.DeepTransformContent<_$_intlayer_types0.ResolveQualifiedDictionaryContent<T, L>, IInterpreterPluginState$1, _$_intlayer_types0.ExtractSelectorLocale<L>>>;
 //#endregion
 export { useDictionaryAsync };
 //# sourceMappingURL=useDictionaryAsync.d.ts.map

package/dist/types/server/useDictionaryAsync.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDictionaryAsync.d.ts","names":[],"sources":["../../../src/server/useDictionaryAsync.ts"],"mappings":";;;;;;;;;;AAgBA;cAAa,kBAAA,mBACK,UAAA,kBACA,aAAA,GAAgB,eAAA,EAEhC,iBAAA,EAAmB,mBAAA,OAA0B,OAAA,CAAQ,CAAA,IACrD,MAAA,GAAS,CAAA,EACT,cAAA,GAAiB,eAAA,KAAe,OAAA,CAAA,6BAAA,CAAA,oBAAA,CAAA,CAAA,aAAA,yBAAA,EAAA,CAAA"}
+{"version":3,"file":"useDictionaryAsync.d.ts","names":[],"sources":["../../../src/server/useDictionaryAsync.ts"],"mappings":";;;;;;;;;;;;cAgBa,kBAAA,mBACK,UAAA,kBACA,aAAA,GAAgB,eAAA,EAEhC,iBAAA,EAAmB,mBAAA,OAA0B,OAAA,CAAQ,CAAA,IACrD,MAAA,GAAS,CAAA,EACT,cAAA,GAAiB,eAAA,KAAe,OAAA,CAAA,6BAAA,CAAA,oBAAA,CAAA,kBAAA,CAAA,iCAAA,CAAA,CAAA,EAAA,CAAA,GAAA,yBAAA,EAAA,kBAAA,CAAA,qBAAA,CAAA,CAAA"}

package/dist/types/server/useDictionaryDynamic.d.ts

@@ -1,15 +1,20 @@
-import { IInterpreterPluginState as IInterpreterPluginState$1 } from "../plugins.js";
-import * as _$_intlayer_core_interpreter0 from "@intlayer/core/interpreter";
 import { DeclaredLocales, LocalesValues, StrictModeLocaleMap } from "@intlayer/types/module_augmentation";
-import { Dictionary } from "@intlayer/types/dictionary";
+import { Dictionary, DictionarySelector } from "@intlayer/types/dictionary";
+import { QualifiedDynamicLoaderMap } from "@intlayer/core/dictionaryManipulator";
 
 //#region src/server/useDictionaryDynamic.d.ts
 /**
- * On the server side, Hook that transform a dictionary and return the content
+ * Server-side hook that lazily loads a dictionary and returns its content.
  *
- * If the locale is not provided, it will use the locale from the server context
+ * The dictionary entry is either a plain dynamic loader map
+ * (`locale → loader`) or a qualified one (`locale → qualifierId → loader`,
+ * tagged with the qualifier dimension). For qualified maps, only the chunk(s)
+ * the selector targets are loaded; the resolution mirrors static mode.
+ *
+ * If the locale is not provided (directly or through the selector), the server
+ * context locale is used.
  */
-declare const useDictionaryDynamic: <const T extends Dictionary, const L extends LocalesValues = DeclaredLocales>(dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>, key: string, locale?: L, fallbackLocale?: DeclaredLocales) => _$_intlayer_core_interpreter0.DeepTransformContent<T["content"], IInterpreterPluginState$1, L>;
+declare const useDictionaryDynamic: <const T extends Dictionary, const A extends LocalesValues | DictionarySelector = LocalesValues>(dictionaryPromise: StrictModeLocaleMap<() => Promise<T>> | QualifiedDynamicLoaderMap, key: string, localeOrSelector?: A, fallbackLocale?: DeclaredLocales) => any;
 //#endregion
 export { useDictionaryDynamic };
 //# sourceMappingURL=useDictionaryDynamic.d.ts.map

package/dist/types/server/useDictionaryDynamic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDictionaryDynamic.d.ts","names":[],"sources":["../../../src/server/useDictionaryDynamic.ts"],"mappings":";;;;;;;;;;AAiBA;cAAa,oBAAA,mBACK,UAAA,kBACA,aAAA,GAAgB,eAAA,EAEhC,iBAAA,EAAmB,mBAAA,OAA0B,OAAA,CAAQ,CAAA,IACrD,GAAA,UACA,MAAA,GAAS,CAAA,EACT,cAAA,GAAiB,eAAA,KAAe,6BAAA,CAAA,oBAAA,CAAA,CAAA,aAAA,yBAAA,EAAA,CAAA"}
+{"version":3,"file":"useDictionaryDynamic.d.ts","names":[],"sources":["../../../src/server/useDictionaryDynamic.ts"],"mappings":";;;;;;;AAmCA;;;;;;;;;cAAa,oBAAA,mBACK,UAAA,kBACA,aAAA,GAAgB,kBAAA,GAAqB,aAAA,EAErD,iBAAA,EACI,mBAAA,OAA0B,OAAA,CAAQ,CAAA,KAClC,yBAAA,EACJ,GAAA,UACA,gBAAA,GAAmB,CAAA,EACnB,cAAA,GAAiB,eAAA"}

package/dist/types/server/useIntlayer.d.ts

@@ -1,15 +1,18 @@
 import { IInterpreterPluginState as IInterpreterPluginState$1 } from "../plugins.js";
 import * as _$_intlayer_core_interpreter0 from "@intlayer/core/interpreter";
-import { DeclaredLocales, DictionaryKeys, LocalesValues } from "@intlayer/types/module_augmentation";
+import { DeclaredLocales, DictionaryKeys, DictionarySelectorForKey, LocalesValues } from "@intlayer/types/module_augmentation";
 import * as _$_intlayer_types0 from "@intlayer/types";
 
 //#region src/server/useIntlayer.d.ts
 /**
  * On the server side, Hook that picking one dictionary by its key and return the content
  *
+ * The second argument is either a locale or a selector object
+ * (`{ item }`, `{ variant }`, `{ id, ...meta }`, optionally with `locale`).
+ *
  * If the locale is not provided, it will use the locale from the server context
  */
-declare const useIntlayer: <const T extends DictionaryKeys, const L extends LocalesValues = DeclaredLocales>(key: T, locale?: L, fallbackLocale?: DeclaredLocales) => _$_intlayer_core_interpreter0.DeepTransformContent<_$_intlayer_types0.DictionaryRegistryContent<T>, IInterpreterPluginState$1, L>;
+declare const useIntlayer: <const T extends DictionaryKeys, const A extends LocalesValues | DictionarySelectorForKey<T> = DeclaredLocales>(key: T, localeOrSelector?: A, fallbackLocale?: DeclaredLocales) => _$_intlayer_core_interpreter0.DeepTransformContent<_$_intlayer_types0.DictionaryRegistryResult<T, A>, IInterpreterPluginState$1, _$_intlayer_types0.ExtractSelectorLocale<A>>;
 //#endregion
 export { useIntlayer };
 //# sourceMappingURL=useIntlayer.d.ts.map

package/dist/types/server/useIntlayer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useIntlayer.d.ts","names":[],"sources":["../../../src/server/useIntlayer.ts"],"mappings":";;;;;;;;;;;cAca,WAAA,mBACK,cAAA,kBACA,aAAA,GAAgB,eAAA,EAEhC,GAAA,EAAK,CAAA,EACL,MAAA,GAAS,CAAA,EACT,cAAA,GAAiB,eAAA,KAAe,6BAAA,CAAA,oBAAA,CAAA,kBAAA,CAAA,yBAAA,CAAA,CAAA,GAAA,yBAAA,EAAA,CAAA"}
+{"version":3,"file":"useIntlayer.d.ts","names":[],"sources":["../../../src/server/useIntlayer.ts"],"mappings":";;;;;;;;;;;AAkBA;;;cAAa,WAAA,mBACK,cAAA,kBACA,aAAA,GAAgB,wBAAA,CAAyB,CAAA,IAAK,eAAA,EAE9D,GAAA,EAAK,CAAA,EACL,gBAAA,GAAmB,CAAA,EACnB,cAAA,GAAiB,eAAA,KAAe,6BAAA,CAAA,oBAAA,CAAA,kBAAA,CAAA,wBAAA,CAAA,CAAA,EAAA,CAAA,GAAA,yBAAA,EAAA,kBAAA,CAAA,qBAAA,CAAA,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-intlayer",
-  "version": "8.12.5-canary.0",
+  "version": "9.0.0-canary.1",
   "private": false,
   "description": "Easily internationalize i18n your React applications with type-safe multilingual content management.",
   "keywords": [
@@ -124,18 +124,18 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/api": "8.12.5-canary.0",
-    "@intlayer/config": "8.12.5-canary.0",
-    "@intlayer/core": "8.12.5-canary.0",
-    "@intlayer/dictionaries-entry": "8.12.5-canary.0",
-    "@intlayer/editor": "8.12.5-canary.0",
-    "@intlayer/editor-react": "8.12.5-canary.0",
-    "@intlayer/types": "8.12.5-canary.0"
+    "@intlayer/api": "9.0.0-canary.1",
+    "@intlayer/config": "9.0.0-canary.1",
+    "@intlayer/core": "9.0.0-canary.1",
+    "@intlayer/dictionaries-entry": "9.0.0-canary.1",
+    "@intlayer/editor": "9.0.0-canary.1",
+    "@intlayer/editor-react": "9.0.0-canary.1",
+    "@intlayer/types": "9.0.0-canary.1"
   },
   "devDependencies": {
     "@craco/types": "7.1.0",
     "@testing-library/react": "16.3.2",
-    "@types/node": "25.9.2",
+    "@types/node": "25.9.3",
     "@types/react": ">=16.0.0",
     "@types/react-dom": ">=16.0.0",
     "@utils/ts-config": "1.0.4",
@@ -144,7 +144,7 @@
     "rimraf": "6.1.3",
     "tsdown": "0.21.10",
     "typescript": "6.0.3",
-    "vitest": "4.1.8"
+    "vitest": "4.1.9"
   },
   "peerDependencies": {
     "react": ">=16.0.0",