preact-intlayer 8.12.4 → 9.0.0-canary.0

package/dist/cjs/client/useDictionary.cjs

@@ -3,21 +3,30 @@ const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
 const require_getDictionary = require('../getDictionary.cjs');
 const require_client_IntlayerProvider = require('./IntlayerProvider.cjs');
 let preact_hooks = require("preact/hooks");
+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
+* Preact 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, preact_hooks.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, preact_hooks.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":["import type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { useContext, useMemo } from 'preact/hooks';\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":";;;;;;;;;;;;AAcA,MAAa,iBAIX,YACA,WACG;CACH,MAAM,EAAE,QAAQ,+CAA6BA,sDAAsB,IAAI,EAAE;AAEzE,wCAAqB;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":["import { getDictionarySelectorCacheKey } from '@intlayer/core/dictionaryManipulator';\nimport type {\n  Dictionary,\n  DictionarySelector,\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 'preact/hooks';\nimport { getDictionary } from '../getDictionary';\nimport { IntlayerClientContext } from './IntlayerProvider';\n\n/**\n * Preact hook that transforms a dictionary (or qualified dictionary group) and\n * returns the content.\n *\n * If the locale is not provided (directly or through the selector), it will use\n * 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":";;;;;;;;;;;;;;;AAsBA,MAAa,iBAMX,YACA,qBACG;CACH,MAAM,EAAE,QAAQ,+CAA6BA,sDAAsB,IAAI,EAAE;CAEzE,MAAM,aACJ,OAAO,qBAAqB,YAAY,qBAAqB;CAG/D,MAAM,2BAA2B,aAC7B,GAAG,iBAAiB,UAAU,GAAG,2EAAiC,iBAAiB,KACnF;AAEJ,wCAAqB;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

@@ -1,20 +1,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 preact_hooks = require("preact/hooks");
+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
+* Preact 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 → …qualifier → loader`,
+* tagged with the qualifier dimensions). For qualified maps, only the chunk(s)
+* the selector targets are loaded.
+*
+* 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, preact_hooks.useContext)(require_client_IntlayerProvider.IntlayerClientContext) ?? {};
-	const localeTarget = (0, preact_hooks.useMemo)(() => locale ?? currentLocale, [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","useDictionary","useLoadDynamic"],"sources":["../../../src/client/useDictionaryDynamic.ts"],"sourcesContent":["import type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  DictionaryKeys,\n  LocalesValues,\n  StrictModeLocaleMap,\n} from '@intlayer/types/module_augmentation';\nimport { useContext, useMemo } from 'preact/hooks';\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,\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":";;;;;;;;;;;;;AAgBA,MAAa,wBAIX,mBACA,KACA,WACG;CACH,MAAM,EAAE,QAAQ,+CAA6BA,sDAAsB,IAAI,EAAE;CACzE,MAAM,+CACE,UAAU,eAChB,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":["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  DictionaryKeys,\n  DictionarySelectorForKey,\n  LocalesValues,\n  StrictModeLocaleMap,\n} from '@intlayer/types/module_augmentation';\nimport { useContext } from 'preact/hooks';\nimport { getDictionary } from '../getDictionary';\nimport { IntlayerClientContext } from './IntlayerProvider';\n// `useLoadDynamic` is a suspender cache, not a hook — aliased to a non-hook\n// name so it can be invoked in loops / conditionally (collection chunks).\nimport { useLoadDynamic as loadDynamicChunk } from './useLoadDynamic';\n\n/**\n * Preact 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 → …qualifier → loader`,\n * tagged with the qualifier dimensions). For qualified maps, only the chunk(s)\n * the selector targets are loaded.\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,+CAA6BA,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

@@ -3,15 +3,20 @@ const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
 const require_getIntlayer = require('../getIntlayer.cjs');
 const require_client_IntlayerProvider = require('./IntlayerProvider.cjs');
 let preact_hooks = require("preact/hooks");
+let _intlayer_core_dictionaryManipulator = require("@intlayer/core/dictionaryManipulator");
 
 //#region src/client/useIntlayer.ts
 /**
 * Preact 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.
+* @param localeOrSelector - Optional locale or selector.
 * @returns The transformed dictionary content.
 *
 * @example
@@ -20,19 +25,25 @@ let preact_hooks = require("preact/hooks");
 *
 * 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, preact_hooks.useContext)(require_client_IntlayerProvider.IntlayerClientContext) ?? {};
+	const isSelector = typeof localeOrSelector === "object" && localeOrSelector !== null;
 	return (0, preact_hooks.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":["import type {\n  DictionaryKeys,\n  DictionaryRegistryContent,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { useContext, useMemo } from 'preact/hooks';\nimport { getIntlayer } from '../getIntlayer';\nimport type { DeepTransformContent } from '../plugins';\nimport { IntlayerClientContext } from './IntlayerProvider';\n\n/**\n * Preact 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 transformed dictionary content.\n *\n * @example\n * ```tsx\n * import { useIntlayer } from 'preact-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,\n>(\n  key: T,\n  locale?: L\n) => {\n  const { locale: currentLocale } = useContext(IntlayerClientContext) ?? {};\n\n  return useMemo(() => {\n    const localeTarget = locale ?? currentLocale;\n\n    // @ts-ignore Type instantiation is excessively deep and possibly infinite\n    return getIntlayer<T, L>(key, localeTarget as L) as DeepTransformContent<\n      DictionaryRegistryContent<T>\n    >;\n  }, [key, currentLocale, locale]);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,MAAa,eAIX,KACA,WACG;CACH,MAAM,EAAE,QAAQ,+CAA6BA,sDAAsB,IAAI,EAAE;AAEzE,wCAAqB;AAInB,SAAOC,gCAAkB,KAHJ,UAAU,cAGiB;IAG/C;EAAC;EAAK;EAAe;EAAO,CAAC"}
+{"version":3,"file":"useIntlayer.cjs","names":["IntlayerClientContext","getIntlayer"],"sources":["../../../src/client/useIntlayer.ts"],"sourcesContent":["import { getDictionarySelectorCacheKey } from '@intlayer/core/dictionaryManipulator';\nimport type { DictionarySelector } from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  DictionaryKeys,\n  DictionarySelectorForKey,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { useContext, useMemo } from 'preact/hooks';\nimport { getIntlayer } from '../getIntlayer';\nimport { IntlayerClientContext } from './IntlayerProvider';\n\n/**\n * Preact 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 transformed dictionary content.\n *\n * @example\n * ```tsx\n * import { useIntlayer } from 'preact-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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,MAAa,eAIX,KACA,qBACG;CACH,MAAM,EAAE,QAAQ,+CAA6BA,sDAAsB,IAAI,EAAE;CAEzE,MAAM,aACJ,OAAO,qBAAqB,YAAY,qBAAqB;AAO/D,wCAAqB;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']> =>\n  getDictionaryCore<T, L>(dictionary, locale, getPlugins(locale)) as any;\n"],"mappings":";;;;;;AAQA,MAAa,iBAIX,YACA,yDAEwB,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  DictionarySelector,\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":";;;;;;;;;;;AAoBA,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) =>\n  getIntlayerCore<T, L>(\n    key,\n    locale,\n    getPlugins(locale)\n  ) as DeepTransformContent<DictionaryRegistryContent<T>>;\n"],"mappings":";;;;;;AASA,MAAa,eAIX,KACA,uDAGE,KACA,QACAA,2BAAW,OAAO,CACnB"}
+{"version":3,"file":"getIntlayer.cjs","names":["getPlugins"],"sources":["../../src/getIntlayer.ts"],"sourcesContent":["import { getIntlayer as getIntlayerCore } from '@intlayer/core/interpreter';\nimport type { DictionarySelector } from '@intlayer/types/dictionary';\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":";;;;;;;;;;;AAiBA,MAAa,eAIX,KACA,qBAIG;AAOH,oDAAuB,KAAK,kBAAkBA,2BAL5C,OAAO,qBAAqB,YAAY,qBAAqB,OACzD,iBAAiB,SACjB,iBAG0D,CAAC"}

package/dist/esm/client/useDictionary.mjs

@@ -1,21 +1,30 @@
 import { getDictionary } from "../getDictionary.mjs";
 import { IntlayerClientContext } from "./IntlayerProvider.mjs";
 import { useContext, useMemo } from "preact/hooks";
+import { getDictionarySelectorCacheKey } from "@intlayer/core/dictionaryManipulator";
 
 //#region src/client/useDictionary.ts
 /**
-* On the server side, Hook that transform a dictionary and return the content
+* Preact 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":["import type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { useContext, useMemo } from 'preact/hooks';\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":";;;;;;;;;;AAcA,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":["import { getDictionarySelectorCacheKey } from '@intlayer/core/dictionaryManipulator';\nimport type {\n  Dictionary,\n  DictionarySelector,\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 'preact/hooks';\nimport { getDictionary } from '../getDictionary';\nimport { IntlayerClientContext } from './IntlayerProvider';\n\n/**\n * Preact hook that transforms a dictionary (or qualified dictionary group) and\n * returns the content.\n *\n * If the locale is not provided (directly or through the selector), it will use\n * 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":";;;;;;;;;;;;;AAsBA,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,18 +1,36 @@
 import { useLoadDynamic } from "./useLoadDynamic.mjs";
+import { getDictionary } from "../getDictionary.mjs";
 import { IntlayerClientContext } from "./IntlayerProvider.mjs";
-import { useDictionary } from "./useDictionary.mjs";
-import { useContext, useMemo } from "preact/hooks";
+import { internationalization } from "@intlayer/config/built";
+import { useContext } from "preact/hooks";
+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
+* Preact 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 → …qualifier → loader`,
+* tagged with the qualifier dimensions). For qualified maps, only the chunk(s)
+* the selector targets are loaded.
+*
+* 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, [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":["import type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  DictionaryKeys,\n  LocalesValues,\n  StrictModeLocaleMap,\n} from '@intlayer/types/module_augmentation';\nimport { useContext, useMemo } from 'preact/hooks';\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,\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":";;;;;;;;;;;AAgBA,MAAa,wBAIX,mBACA,KACA,WACG;CACH,MAAM,EAAE,QAAQ,kBAAkB,WAAW,sBAAsB,IAAI,EAAE;CACzE,MAAM,eAAe,cACb,UAAU,eAChB,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":["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  DictionaryKeys,\n  DictionarySelectorForKey,\n  LocalesValues,\n  StrictModeLocaleMap,\n} from '@intlayer/types/module_augmentation';\nimport { useContext } from 'preact/hooks';\nimport { getDictionary } from '../getDictionary';\nimport { IntlayerClientContext } from './IntlayerProvider';\n// `useLoadDynamic` is a suspender cache, not a hook — aliased to a non-hook\n// name so it can be invoked in loops / conditionally (collection chunks).\nimport { useLoadDynamic as loadDynamicChunk } from './useLoadDynamic';\n\n/**\n * Preact 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 → …qualifier → loader`,\n * tagged with the qualifier dimensions). For qualified maps, only the chunk(s)\n * the selector targets are loaded.\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

@@ -1,15 +1,20 @@
 import { getIntlayer } from "../getIntlayer.mjs";
 import { IntlayerClientContext } from "./IntlayerProvider.mjs";
 import { useContext, useMemo } from "preact/hooks";
+import { getDictionarySelectorCacheKey } from "@intlayer/core/dictionaryManipulator";
 
 //#region src/client/useIntlayer.ts
 /**
 * Preact 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.
+* @param localeOrSelector - Optional locale or selector.
 * @returns The transformed dictionary content.
 *
 * @example
@@ -18,19 +23,25 @@ import { useContext, useMemo } from "preact/hooks";
 *
 * 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":["import type {\n  DictionaryKeys,\n  DictionaryRegistryContent,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { useContext, useMemo } from 'preact/hooks';\nimport { getIntlayer } from '../getIntlayer';\nimport type { DeepTransformContent } from '../plugins';\nimport { IntlayerClientContext } from './IntlayerProvider';\n\n/**\n * Preact 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 transformed dictionary content.\n *\n * @example\n * ```tsx\n * import { useIntlayer } from 'preact-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,\n>(\n  key: T,\n  locale?: L\n) => {\n  const { locale: currentLocale } = useContext(IntlayerClientContext) ?? {};\n\n  return useMemo(() => {\n    const localeTarget = locale ?? currentLocale;\n\n    // @ts-ignore Type instantiation is excessively deep and possibly infinite\n    return getIntlayer<T, L>(key, localeTarget as L) as DeepTransformContent<\n      DictionaryRegistryContent<T>\n    >;\n  }, [key, currentLocale, locale]);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,MAAa,eAIX,KACA,WACG;CACH,MAAM,EAAE,QAAQ,kBAAkB,WAAW,sBAAsB,IAAI,EAAE;AAEzE,QAAO,cAAc;AAInB,SAAO,YAAkB,KAHJ,UAAU,cAGiB;IAG/C;EAAC;EAAK;EAAe;EAAO,CAAC"}
+{"version":3,"file":"useIntlayer.mjs","names":[],"sources":["../../../src/client/useIntlayer.ts"],"sourcesContent":["import { getDictionarySelectorCacheKey } from '@intlayer/core/dictionaryManipulator';\nimport type { DictionarySelector } from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  DictionaryKeys,\n  DictionarySelectorForKey,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { useContext, useMemo } from 'preact/hooks';\nimport { getIntlayer } from '../getIntlayer';\nimport { IntlayerClientContext } from './IntlayerProvider';\n\n/**\n * Preact 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 transformed dictionary content.\n *\n * @example\n * ```tsx\n * import { useIntlayer } from 'preact-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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,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']> =>\n  getDictionaryCore<T, L>(dictionary, locale, getPlugins(locale)) as any;\n"],"mappings":";;;;AAQA,MAAa,iBAIX,YACA,WAEAA,gBAAwB,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  DictionarySelector,\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":";;;;;;;;;AAoBA,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) =>\n  getIntlayerCore<T, L>(\n    key,\n    locale,\n    getPlugins(locale)\n  ) as DeepTransformContent<DictionaryRegistryContent<T>>;\n"],"mappings":";;;;AASA,MAAa,eAIX,KACA,WAEAA,cACE,KACA,QACA,WAAW,OAAO,CACnB"}
+{"version":3,"file":"getIntlayer.mjs","names":["getIntlayerCore"],"sources":["../../src/getIntlayer.ts"],"sourcesContent":["import { getIntlayer as getIntlayerCore } from '@intlayer/core/interpreter';\nimport type { DictionarySelector } from '@intlayer/types/dictionary';\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":";;;;;;;;;AAiBA,MAAa,eAIX,KACA,qBAIG;AAOH,QAAOA,cAAgB,KAAK,kBAAkB,WAL5C,OAAO,qBAAqB,YAAY,qBAAqB,OACzD,iBAAiB,SACjB,iBAG0D,CAAC"}

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

@@ -1,12 +1,12 @@
+import { LocalesValues as LocalesValues$1 } from "../intlayer/dist/types/index.js";
 import { StrictModeLocaleMap } from "@intlayer/types/module_augmentation";
-import * as _$_intlayer_types0 from "@intlayer/types";
 
 //#region src/client/useContent.d.ts
 /**
  * On the client side, hook to get the translation content based on the locale
  */
 declare const useContent: <Content>(languageContent: StrictModeLocaleMap<Content>) => {
-  locale: _$_intlayer_types0.LocalesValues;
+  locale: LocalesValues$1;
   content: Content;
   t: <Content_1 = string>(languageContent: StrictModeLocaleMap<Content_1>) => Content_1;
 };

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

@@ -1 +1 @@
-{"version":3,"file":"useContent.d.ts","names":[],"sources":["../../../src/client/useContent.ts"],"mappings":";;;;;;;cAOa,UAAA,YACX,eAAA,EAAiB,mBAAA,CAAoB,OAAA;UAAD,kBAAA,CAAA,aAAA"}
+{"version":3,"file":"useContent.d.ts","names":[],"sources":["../../../src/client/useContent.ts"],"mappings":";;;;;;;cAOa,UAAA,YACX,eAAA,EAAiB,mBAAA,CAAoB,OAAA;UAAD,eAAA"}

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

@@ -2,15 +2,17 @@ import { IInterpreterPluginState as IInterpreterPluginState$1 } from "../plugins
 import * as _$_intlayer_core_interpreter0 from "@intlayer/core/interpreter";
 import { DeclaredLocales, LocalesValues } from "@intlayer/types/module_augmentation";
 import * as _$_intlayer_types0 from "@intlayer/types";
-import { Dictionary } from "@intlayer/types/dictionary";
+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
+ * Preact 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, _$_intlayer_types0.Locale>;
+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":";;;;;;;;;;;;cAca,aAAA,mBACK,UAAA,kBACA,aAAA,GAAgB,eAAA,EAEhC,UAAA,EAAY,CAAA,EACZ,MAAA,GAAS,CAAA,KAAC,6BAAA,CAAA,oBAAA,CAAA,CAAA,aAAA,yBAAA,EAAA,kBAAA,CAAA,MAAA"}
+{"version":3,"file":"useDictionary.d.ts","names":[],"sources":["../../../src/client/useDictionary.ts"],"mappings":";;;;;;;;;;;;AAsBA;;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,16 +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 * as _$_intlayer_types0 from "@intlayer/types";
+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
+ * Preact 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 → …qualifier → loader`,
+ * tagged with the qualifier dimensions). For qualified maps, only the chunk(s)
+ * the selector targets are loaded.
+ *
+ * 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, _$_intlayer_types0.Locale>;
+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":";;;;;;;;;;;;cAgBa,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,EAAA,kBAAA,CAAA,MAAA"}
+{"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,14 +1,20 @@
-import { DeepTransformContent } from "../plugins.js";
-import { DictionaryKeys, DictionaryRegistryContent, LocalesValues } from "@intlayer/types/module_augmentation";
+import { IInterpreterPluginState as IInterpreterPluginState$1 } from "../plugins.js";
+import * as _$_intlayer_core_interpreter0 from "@intlayer/core/interpreter";
+import { DeclaredLocales, DictionaryKeys, DictionarySelectorForKey, LocalesValues } from "@intlayer/types/module_augmentation";
+import * as _$_intlayer_types0 from "@intlayer/types";
 
 //#region src/client/useIntlayer.d.ts
 /**
  * Preact 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.
+ * @param localeOrSelector - Optional locale or selector.
  * @returns The transformed dictionary content.
  *
  * @example
@@ -17,12 +23,13 @@ import { DictionaryKeys, DictionaryRegistryContent, LocalesValues } from "@intla
  *
  * 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>(key: T, locale?: L) => DeepTransformContent<DictionaryRegistryContent<T>>;
+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":";;;;;;AA8BA;;;;;;;;;;;;;;;;;;cAAa,WAAA,mBACK,cAAA,kBACA,aAAA,EAEhB,GAAA,EAAK,CAAA,EACL,MAAA,GAAS,CAAA,KAAC,oBAAA,CAAA,yBAAA,CAAA,CAAA"}
+{"version":3,"file":"useIntlayer.d.ts","names":[],"sources":["../../../src/client/useIntlayer.ts"],"mappings":";;;;;;;;;;;AAqCA;;;;;;;;;;;;;;;;;;;;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/client/useLocaleBase.d.ts

@@ -1,14 +1,14 @@
-import * as _$_intlayer_types0 from "@intlayer/types";
+import { LocalesValues } from "../intlayer/dist/types/index.js";
 
 //#region src/client/useLocaleBase.d.ts
 /**
  * On the client side, hook to get the current locale and all related fields
  */
 declare const useLocaleBase: () => {
-  locale: _$_intlayer_types0.LocalesValues;
+  locale: LocalesValues;
   defaultLocale: any;
   availableLocales: any;
-  setLocale: (newLocale: _$_intlayer_types0.LocalesValues) => void;
+  setLocale: (newLocale: LocalesValues) => void;
 };
 //#endregion
 export { useLocaleBase };

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

@@ -1 +1 @@
-{"version":3,"file":"useLocaleBase.d.ts","names":[],"sources":["../../../src/client/useLocaleBase.ts"],"mappings":";;;;;;cASa,aAAA;UASZ,kBAAA,CAAA,aAAA;;;yBAAA,kBAAA,CAAA,aAAA;AAAA"}
+{"version":3,"file":"useLocaleBase.d.ts","names":[],"sources":["../../../src/client/useLocaleBase.ts"],"mappings":";;;;;;cASa,aAAA;UASZ,aAAA;;;yBAAA,aAAA;AAAA"}

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

@@ -1,17 +1,17 @@
+import { Locale } from "../intlayer/dist/types/index.js";
 import { LocalesValues } from "@intlayer/types/module_augmentation";
-import * as _$_intlayer_types0 from "@intlayer/types";
 
 //#region src/client/useLocaleStorage.d.ts
 /**
  * Get the locale cookie
  */
-declare const localeInStorage: _$_intlayer_types0.Locale;
+declare const localeInStorage: Locale;
 /**
  * @deprecated Use localeInStorage instead
  *
  * Get the locale cookie
  */
-declare const localeCookie: _$_intlayer_types0.Locale;
+declare const localeCookie: Locale;
 /**
  * Set the locale cookie
  */
@@ -26,7 +26,7 @@ declare const setLocaleCookie: (locale: LocalesValues, isCookieEnabled: boolean)
  * Hook that provides the locale storage and a function to set it
  */
 declare const useLocaleStorage: (isCookieEnabled?: boolean) => {
-  getLocale: () => _$_intlayer_types0.Locale;
+  getLocale: () => Locale;
   setLocale: (locale: LocalesValues) => void;
 };
 /**
@@ -37,7 +37,7 @@ declare const useLocaleStorage: (isCookieEnabled?: boolean) => {
  * Hook that provides the locale cookie and a function to set it
  */
 declare const useLocaleCookie: (isCookieEnabled?: boolean) => {
-  getLocale: () => _$_intlayer_types0.Locale;
+  getLocale: () => Locale;
   setLocale: (locale: LocalesValues) => void;
 };
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"useLocaleStorage.d.ts","names":[],"sources":["../../../src/client/useLocaleStorage.ts"],"mappings":";;;;;;;cAYa,eAAA,EAAkE,kBAAA,CAAnD,MAAA;;;;;AAM5B;cAAa,YAAA,EAA8B,kBAAA,CAAlB,MAAA;;;;cAKZ,kBAAA,GACX,MAAA,EAAQ,aAAA,EACR,eAAA;;;;;;cAYW,eAAA,GAAe,MAAA,EAblB,aAAA,EAAa,eAAA;;;AAavB;cAKa,gBAAA,GAAoB,eAAA;mBAQ9B,kBAAA,CAAA,MAAA;sBAAA,aAAA;AAAA;;;;;AARH;;;cAiBa,eAAA,GAAe,eAAA;mBAAmB,kBAAA,CAAA,MAAA;sBAAA,aAAA;AAAA"}
+{"version":3,"file":"useLocaleStorage.d.ts","names":[],"sources":["../../../src/client/useLocaleStorage.ts"],"mappings":";;;;;;;cAYa,eAAA,EAAkE,MAAA;;;;;AAM/E;cAAa,YAAA,EAA8B,MAAA;;;;cAK9B,kBAAA,GACX,MAAA,EAAQ,aAAA,EACR,eAAA;;;;;;cAYW,eAAA,GAAe,MAAA,EAblB,aAAA,EAAa,eAAA;;;AAavB;cAKa,gBAAA,GAAoB,eAAA;mBAQ9B,MAAA;sBAAA,aAAA;AAAA;;;;;AARH;;;cAiBa,eAAA,GAAe,eAAA;mBAAmB,MAAA;sBAAA,aAAA;AAAA"}

package/dist/types/format/useCompact.d.ts

@@ -1,4 +1,4 @@
-import * as _$_intlayer_types0 from "@intlayer/types";
+import { LocalesValues } from "../intlayer/dist/types/index.js";
 
 //#region src/format/useCompact.d.ts
 /**
@@ -12,7 +12,7 @@ import * as _$_intlayer_types0 from "@intlayer/types";
  * ```
  */
 declare const useCompact: () => (value: string | number, options?: Intl.NumberFormatOptions & {
-  locale?: _$_intlayer_types0.LocalesValues;
+  locale?: LocalesValues;
 }) => string;
 //#endregion
 export { useCompact };

package/dist/types/format/useCompact.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useCompact.d.ts","names":[],"sources":["../../../src/format/useCompact.ts"],"mappings":";;;;;;AAcA;;;;;;;cAAa,UAAA,SAAU,KAAA,mBAAA,OAAA,GAAA,IAAA,CAAA,mBAAA;WAAA,kBAAA,CAAA,aAAA;AAAA"}
+{"version":3,"file":"useCompact.d.ts","names":[],"sources":["../../../src/format/useCompact.ts"],"mappings":";;;;;;AAcA;;;;;;;cAAa,UAAA,SAAU,KAAA,mBAAA,OAAA,GAAA,IAAA,CAAA,mBAAA;WAAA,aAAA;AAAA"}

package/dist/types/format/useCurrency.d.ts

@@ -1,4 +1,4 @@
-import * as _$_intlayer_types0 from "@intlayer/types";
+import { LocalesValues } from "../intlayer/dist/types/index.js";
 
 //#region src/format/useCurrency.d.ts
 /**
@@ -26,7 +26,7 @@ import * as _$_intlayer_types0 from "@intlayer/types";
  * ```
  */
 declare const useCurrency: () => (value: string | number, options?: Intl.NumberFormatOptions & {
-  locale?: _$_intlayer_types0.LocalesValues;
+  locale?: LocalesValues;
 }) => string;
 //#endregion
 export { useCurrency };

package/dist/types/format/useCurrency.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useCurrency.d.ts","names":[],"sources":["../../../src/format/useCurrency.ts"],"mappings":";;;;;;AA4BA;;;;;;;;;;;;;;;;;;;;;cAAa,WAAA,SAAW,KAAA,mBAAA,OAAA,GAAA,IAAA,CAAA,mBAAA;WAAA,kBAAA,CAAA,aAAA;AAAA"}
+{"version":3,"file":"useCurrency.d.ts","names":[],"sources":["../../../src/format/useCurrency.ts"],"mappings":";;;;;;AA4BA;;;;;;;;;;;;;;;;;;;;;cAAa,WAAA,SAAW,KAAA,mBAAA,OAAA,GAAA,IAAA,CAAA,mBAAA;WAAA,aAAA;AAAA"}

package/dist/types/format/useList.d.ts

@@ -1,4 +1,4 @@
-import * as _$_intlayer_types0 from "@intlayer/types";
+import { LocalesValues } from "../intlayer/dist/types/index.js";
 
 //#region src/format/useList.d.ts
 /**
@@ -27,7 +27,7 @@ declare const useList: () => (values: (string | number)[], options?: {
   type?: "conjunction" | "disjunction" | "unit";
   style?: "long" | "short" | "narrow";
 } & {
-  locale?: _$_intlayer_types0.LocalesValues;
+  locale?: LocalesValues;
 }) => string;
 //#endregion
 export { useList };

package/dist/types/format/useList.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useList.d.ts","names":[],"sources":["../../../src/format/useList.ts"],"mappings":";;;;;;AAyBA;;;;;;;;;;;;;;;;;;cAAa,OAAA,SAAO,MAAA,uBAAA,OAAA;;;;;WAWnB,kBAAA,CAAA,aAAA;AAAA"}
+{"version":3,"file":"useList.d.ts","names":[],"sources":["../../../src/format/useList.ts"],"mappings":";;;;;;AAyBA;;;;;;;;;;;;;;;;;;cAAa,OAAA,SAAO,MAAA,uBAAA,OAAA;;;;;WAWnB,aAAA;AAAA"}

package/dist/types/format/useNumber.d.ts

@@ -1,4 +1,4 @@
-import * as _$_intlayer_types0 from "@intlayer/types";
+import { LocalesValues } from "../intlayer/dist/types/index.js";
 
 //#region src/format/useNumber.d.ts
 /**
@@ -24,7 +24,7 @@ import * as _$_intlayer_types0 from "@intlayer/types";
  * A number formatting function bound to the active locale.
  */
 declare const useNumber: () => (value: string | number, args_1?: Intl.NumberFormatOptions & {
-  locale?: _$_intlayer_types0.LocalesValues;
+  locale?: LocalesValues;
 }) => string;
 //#endregion
 export { useNumber };

package/dist/types/format/useNumber.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useNumber.d.ts","names":[],"sources":["../../../src/format/useNumber.ts"],"mappings":";;;;;;AA0BA;;;;;;;;;;;;;;;;;;;cAAa,SAAA,SAAS,KAAA,mBAAA,MAAA,GAAA,IAAA,CAAA,mBAAA;WAAA,kBAAA,CAAA,aAAA;AAAA"}
+{"version":3,"file":"useNumber.d.ts","names":[],"sources":["../../../src/format/useNumber.ts"],"mappings":";;;;;;AA0BA;;;;;;;;;;;;;;;;;;;cAAa,SAAA,SAAS,KAAA,mBAAA,MAAA,GAAA,IAAA,CAAA,mBAAA;WAAA,aAAA;AAAA"}

package/dist/types/format/usePercentage.d.ts

@@ -1,4 +1,4 @@
-import * as _$_intlayer_types0 from "@intlayer/types";
+import { LocalesValues } from "../intlayer/dist/types/index.js";
 
 //#region src/format/usePercentage.d.ts
 /**
@@ -20,7 +20,7 @@ import * as _$_intlayer_types0 from "@intlayer/types";
  * A function that formats numbers or numeric strings into localized percentages.
  */
 declare const usePercentage: () => (value: string | number, args_1?: Intl.NumberFormatOptions & {
-  locale?: _$_intlayer_types0.LocalesValues;
+  locale?: LocalesValues;
 }) => string;
 //#endregion
 export { usePercentage };

package/dist/types/format/usePercentage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"usePercentage.d.ts","names":[],"sources":["../../../src/format/usePercentage.ts"],"mappings":";;;;;;AAsBA;;;;;;;;;;;;;;;cAAa,aAAA,SAAa,KAAA,mBAAA,MAAA,GAAA,IAAA,CAAA,mBAAA;WAAA,kBAAA,CAAA,aAAA;AAAA"}
+{"version":3,"file":"usePercentage.d.ts","names":[],"sources":["../../../src/format/usePercentage.ts"],"mappings":";;;;;;AAsBA;;;;;;;;;;;;;;;cAAa,aAAA,SAAa,KAAA,mBAAA,MAAA,GAAA,IAAA,CAAA,mBAAA;WAAA,aAAA;AAAA"}

package/dist/types/format/useRelativeTime.d.ts

@@ -1,4 +1,4 @@
-import * as _$_intlayer_types0 from "@intlayer/types";
+import { LocalesValues } from "../intlayer/dist/types/index.js";
 
 //#region src/format/useRelativeTime.d.ts
 /**
@@ -20,7 +20,7 @@ import * as _$_intlayer_types0 from "@intlayer/types";
  *          bound to the current client locale.
  */
 declare const useRelativeTime: () => (from: string | number | Date, to?: string | number | Date, options?: Intl.RelativeTimeFormatOptions & {
-  locale?: _$_intlayer_types0.LocalesValues;
+  locale?: LocalesValues;
   unit?: Intl.RelativeTimeFormatUnit;
 }) => string;
 //#endregion

package/dist/types/format/useRelativeTime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useRelativeTime.d.ts","names":[],"sources":["../../../src/format/useRelativeTime.ts"],"mappings":";;;;;;AAsBA;;;;;;;;;;;;;;;cAAa,eAAA,SAAe,IAAA,oBAAA,IAAA,EAAA,EAAA,qBAAA,IAAA,EAAA,OAAA,GAAA,IAAA,CAAA,yBAAA;WAAA,kBAAA,CAAA,aAAA"}
+{"version":3,"file":"useRelativeTime.d.ts","names":[],"sources":["../../../src/format/useRelativeTime.ts"],"mappings":";;;;;;AAsBA;;;;;;;;;;;;;;;cAAa,eAAA,SAAe,IAAA,oBAAA,IAAA,EAAA,EAAA,qBAAA,IAAA,EAAA,OAAA,GAAA,IAAA,CAAA,yBAAA;WAAA,aAAA"}

package/dist/types/format/useUnit.d.ts

@@ -1,4 +1,4 @@
-import * as _$_intlayer_types0 from "@intlayer/types";
+import { LocalesValues } from "../intlayer/dist/types/index.js";
 
 //#region src/format/useUnit.d.ts
 /**
@@ -19,7 +19,7 @@ import * as _$_intlayer_types0 from "@intlayer/types";
  * @returns {Function} A unit formatting function that accepts a value and optional formatting options.
  */
 declare const useUnit: () => (value: string | number, options?: Intl.NumberFormatOptions & {
-  locale?: _$_intlayer_types0.LocalesValues;
+  locale?: LocalesValues;
 }) => string;
 //#endregion
 export { useUnit };

package/dist/types/format/useUnit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useUnit.d.ts","names":[],"sources":["../../../src/format/useUnit.ts"],"mappings":";;;;;;AAqBA;;;;;;;;;;;;;;cAAa,OAAA,SAAO,KAAA,mBAAA,OAAA,GAAA,IAAA,CAAA,mBAAA;WAAA,kBAAA,CAAA,aAAA;AAAA"}
+{"version":3,"file":"useUnit.d.ts","names":[],"sources":["../../../src/format/useUnit.ts"],"mappings":";;;;;;AAqBA;;;;;;;;;;;;;;cAAa,OAAA,SAAO,KAAA,mBAAA,OAAA,GAAA,IAAA,CAAA,mBAAA;WAAA,aAAA;AAAA"}

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"]>;
+/**
+ * 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"}
+{"version":3,"file":"getDictionary.d.ts","names":[],"sources":["../../src/getDictionary.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,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>>;
+/**
+ * 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,KAMJ,oBAAA,CAAqB,yBAAA,CAA0B,CAAA"}
+{"version":3,"file":"getIntlayer.d.ts","names":[],"sources":["../../src/getIntlayer.ts"],"mappings":";;;;;;AAiBA;;;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/intlayer/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+import { LocalesValues as LocalesValues$1 } from "@intlayer/types/module_augmentation";
+import { Locale as Locale$1 } from "@intlayer/types/allLocales";
+import { Dictionary } from "@intlayer/types/dictionary";
+export { type Locale$1 as Locale, type LocalesValues$1 as LocalesValues };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "preact-intlayer",
-  "version": "8.12.4",
+  "version": "9.0.0-canary.0",
   "private": false,
   "description": "Easily internationalize i18n your Preact applications with type-safe multilingual content management.",
   "keywords": [
@@ -100,15 +100,15 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/api": "8.12.4",
-    "@intlayer/chokidar": "8.12.4",
-    "@intlayer/config": "8.12.4",
-    "@intlayer/core": "8.12.4",
-    "@intlayer/editor": "8.12.4",
-    "@intlayer/types": "8.12.4"
+    "@intlayer/api": "9.0.0-canary.0",
+    "@intlayer/chokidar": "9.0.0-canary.0",
+    "@intlayer/config": "9.0.0-canary.0",
+    "@intlayer/core": "9.0.0-canary.0",
+    "@intlayer/editor": "9.0.0-canary.0",
+    "@intlayer/types": "9.0.0-canary.0"
   },
   "devDependencies": {
-    "@types/node": "25.9.2",
+    "@types/node": "25.9.3",
     "@utils/ts-config": "1.0.4",
     "@utils/ts-config-types": "1.0.4",
     "@utils/tsdown-config": "1.0.4",