@intlayer/core 9.1.0 → 9.1.2

package/dist/cjs/interpreter/getIntlayer.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"getIntlayer.cjs","names":["parseDictionarySelector","getDictionarySelectorCacheKey","getDictionary"],"sources":["../../../src/interpreter/getIntlayer.ts"],"sourcesContent":["import { log } from '@intlayer/config/built';\nimport { colorizeKey, getAppLogger } from '@intlayer/config/logger';\nimport { getDictionaries } from '@intlayer/dictionaries-entry';\nimport type { DictionarySelector } from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  DictionaryKeys,\n  DictionaryRegistryResult,\n  ExtractSelectorLocale,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport {\n  getDictionarySelectorCacheKey,\n  parseDictionarySelector,\n} from '../dictionaryManipulator/qualifiedDictionary';\nimport type {\n  DeepTransformContent,\n  IInterpreterPluginState,\n  Plugins,\n} from './getContent';\nimport { getDictionary } from './getDictionary';\n\n/**\n * Creates a Recursive Proxy that returns the path of the accessed key\n * stringified. This prevents the app from crashing on undefined access.\n */\nconst createSafeFallback = (path = ''): any => {\n  return new Proxy({} as Record<string | symbol, unknown>, {\n    get: (_target, prop) => {\n      if (\n        prop === 'toJSON' ||\n        prop === Symbol.toPrimitive ||\n        prop === 'toString' ||\n        prop === 'valueOf'\n      ) {\n        return () => path;\n      }\n      if (prop === 'then') {\n        return undefined; // Prevent it from being treated as a Promise\n      }\n      if (prop === Symbol.iterator) {\n        return function* () {\n          yield path;\n        };\n      }\n\n      // Recursively build the path (e.g., \"myDictionary.home.title\")\n      const nextPath = path ? `${path}.${String(prop)}` : String(prop);\n      return createSafeFallback(nextPath);\n    },\n  });\n};\n\nconst dictionaryCache = new Map<string, any>();\nconst warnedMissingDictionaries = new Set<string>();\n\n/**\n * Picks one dictionary by its key and returns its content for the given\n * locale or selector.\n *\n * The second argument is either a locale (`'fr'`) or a selector object:\n * - `{ item: 2 }` — collection item (omit `item` to get every item as array)\n * - `{ variant: 'black-friday' }` — named variant (omit for the `default` one)\n * - `{ variant: { id: 'prod_abc', userId: '123' } }` — structured variant\n * - `locale` can be combined with any selector: `{ item: 2, locale: 'fr' }`\n */\nexport const getIntlayer = <\n  const T extends DictionaryKeys,\n  const A extends LocalesValues | DictionarySelector = DeclaredLocales,\n>(\n  key: T,\n  localeOrSelector?: A,\n  plugins?: Plugins[]\n): DeepTransformContent<\n  DictionaryRegistryResult<T, A>,\n  IInterpreterPluginState,\n  ExtractSelectorLocale<A>\n> => {\n  const dictionaries = getDictionaries();\n  const dictionary = dictionaries[key as T];\n\n  if (!dictionary && process.env.NODE_ENV === 'development') {\n    if (!warnedMissingDictionaries.has(key as string)) {\n      // Log a warning instead of throwing (so developers know it's missing)\n      const logger = getAppLogger({ log });\n      logger(\n        typeof window === 'undefined'\n          ? `Dictionary ${colorizeKey(key)} was not found. Using fallback proxy.`\n          : `Dictionary ${key} was not found. Using fallback proxy.`,\n        {\n          level: 'warn',\n        }\n      );\n      warnedMissingDictionaries.add(key as string);\n    }\n\n    return createSafeFallback(key as string);\n  }\n\n  let locale: LocalesValues | undefined;\n  let selectorCacheKey = '';\n\n  if (process.env.INTLAYER_DICTIONARY_SELECTOR !== 'false') {\n    const parsed = parseDictionarySelector(localeOrSelector);\n    locale = parsed.locale;\n    selectorCacheKey = getDictionarySelectorCacheKey(parsed.selector);\n  } else {\n    // Selectors are unused in this project (build-time flag): the second\n    // argument can only be a locale, so the selector parsing is dead code.\n    locale = localeOrSelector as LocalesValues | undefined;\n  }\n\n  const cacheKey = `${key}_${locale ?? 'default'}_${selectorCacheKey}_${plugins ? 'custom_plugins' : 'default_plugins'}`;\n\n  if (dictionaryCache.has(cacheKey)) {\n    return dictionaryCache.get(cacheKey);\n  }\n\n  const result = getDictionary(dictionary, localeOrSelector, plugins);\n\n  dictionaryCache.set(cacheKey, result);\n\n  return result as any;\n};\n"],"mappings":";;;;;;;;;;;;AA0BA,MAAM,sBAAsB,OAAO,OAAY;CAC7C,OAAO,IAAI,MAAM,CAAC,GAAuC,EACvD,MAAM,SAAS,SAAS;EACtB,IACE,SAAS,YACT,SAAS,OAAO,eAChB,SAAS,cACT,SAAS,WAET,aAAa;EAEf,IAAI,SAAS,QACX;EAEF,IAAI,SAAS,OAAO,UAClB,OAAO,aAAa;GAClB,MAAM;EACR;EAIF,MAAM,WAAW,OAAO,GAAG,KAAK,GAAG,OAAO,IAAI,MAAM,OAAO,IAAI;EAC/D,OAAO,mBAAmB,QAAQ;CACpC,EACF,CAAC;AACH;AAEA,MAAM,kCAAkB,IAAI,IAAiB;AAC7C,MAAM,4CAA4B,IAAI,IAAY;;;;;;;;;;;AAYlD,MAAa,eAIX,KACA,kBACA,YAKG;CAEH,MAAM,+DAAwB,CAAC,CAAC;CAEhC,IAAI,CAAC,cAAc,QAAQ,IAAI,aAAa,eAAe;EACzD,IAAI,CAAC,0BAA0B,IAAI,GAAa,GAAG;GAGjD,0CAD4B,EAAE,gCAAI,CAC7B,CAAC,CACJ,OAAO,WAAW,cACd,uDAA0B,GAAG,EAAE,yCAC/B,cAAc,IAAI,wCACtB,EACE,OAAO,OACT,CACF;GACA,0BAA0B,IAAI,GAAa;EAC7C;EAEA,OAAO,mBAAmB,GAAa;CACzC;CAEA,IAAI;CACJ,IAAI,mBAAmB;CAEvB,IAAI,QAAQ,IAAI,iCAAiC,SAAS;EACxD,MAAM,SAASA,0EAAwB,gBAAgB;EACvD,SAAS,OAAO;EAChB,mBAAmBC,gFAA8B,OAAO,QAAQ;CAClE,OAGE,SAAS;CAGX,MAAM,WAAW,GAAG,IAAI,GAAG,UAAU,UAAU,GAAG,iBAAiB,GAAG,UAAU,mBAAmB;CAEnG,IAAI,gBAAgB,IAAI,QAAQ,GAC9B,OAAO,gBAAgB,IAAI,QAAQ;CAGrC,MAAM,SAASC,gDAAc,YAAY,kBAAkB,OAAO;CAElE,gBAAgB,IAAI,UAAU,MAAM;CAEpC,OAAO;AACT"}
+{"version":3,"file":"getIntlayer.cjs","names":["parseDictionarySelector","getDictionarySelectorCacheKey","getDictionary"],"sources":["../../../src/interpreter/getIntlayer.ts"],"sourcesContent":["import { log } from '@intlayer/config/built';\nimport { colorizeKey, getAppLogger } from '@intlayer/config/logger';\nimport { getDictionaries } from '@intlayer/dictionaries-entry';\nimport type { DictionarySelector } from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  DictionaryKeys,\n  DictionaryRegistryResult,\n  ExtractSelectorLocale,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport {\n  getDictionarySelectorCacheKey,\n  parseDictionarySelector,\n} from '../dictionaryManipulator/qualifiedDictionary';\nimport type {\n  DeepTransformContent,\n  IInterpreterPluginState,\n  Plugins,\n} from './getContent';\nimport { getDictionary } from './getDictionary';\n\n/**\n * Creates a Recursive Proxy that returns the path of the accessed key\n * stringified. This prevents the app from crashing on undefined access.\n */\nconst createSafeFallback = (path = ''): any => {\n  return new Proxy({} as Record<string | symbol, unknown>, {\n    get: (_target, prop) => {\n      if (\n        prop === 'toJSON' ||\n        prop === Symbol.toPrimitive ||\n        prop === 'toString' ||\n        prop === 'valueOf'\n      ) {\n        return () => path;\n      }\n      if (prop === 'then') {\n        return undefined; // Prevent it from being treated as a Promise\n      }\n      if (prop === Symbol.iterator) {\n        return function* () {\n          yield path;\n        };\n      }\n\n      // Recursively build the path (e.g., \"myDictionary.home.title\")\n      const nextPath = path ? `${path}.${String(prop)}` : String(prop);\n      return createSafeFallback(nextPath);\n    },\n  });\n};\n\nconst dictionaryCache = new Map<string, any>();\nconst warnedMissingDictionaries = new Set<string>();\n\n/**\n * Picks one dictionary by its key and returns its content for the given\n * locale or selector.\n *\n * The second argument is either a locale (`'fr'`) or a selector object:\n * - `{ item: 2 }` — collection item (omit `item` to get every item as array)\n * - `{ variant: 'black-friday' }` — named variant (omit for the `default` one)\n * - `{ variant: { id: 'prod_abc', userId: '123' } }` — structured variant\n * - `locale` can be combined with any selector: `{ item: 2, locale: 'fr' }`\n */\nexport const getIntlayer = <\n  const T extends DictionaryKeys,\n  const A extends DeclaredLocales | DictionarySelector = DeclaredLocales,\n>(\n  key: T,\n  localeOrSelector?: A,\n  plugins?: Plugins[]\n): DeepTransformContent<\n  DictionaryRegistryResult<T, A>,\n  IInterpreterPluginState,\n  ExtractSelectorLocale<A>\n> => {\n  const dictionaries = getDictionaries();\n  const dictionary = dictionaries[key as T];\n\n  if (!dictionary && process.env.NODE_ENV === 'development') {\n    if (!warnedMissingDictionaries.has(key as string)) {\n      // Log a warning instead of throwing (so developers know it's missing)\n      const logger = getAppLogger({ log });\n      logger(\n        typeof window === 'undefined'\n          ? `Dictionary ${colorizeKey(key)} was not found. Using fallback proxy.`\n          : `Dictionary ${key} was not found. Using fallback proxy.`,\n        {\n          level: 'warn',\n        }\n      );\n      warnedMissingDictionaries.add(key as string);\n    }\n\n    return createSafeFallback(key as string);\n  }\n\n  let locale: LocalesValues | undefined;\n  let selectorCacheKey = '';\n\n  if (process.env.INTLAYER_DICTIONARY_SELECTOR !== 'false') {\n    const parsed = parseDictionarySelector(localeOrSelector);\n    locale = parsed.locale;\n    selectorCacheKey = getDictionarySelectorCacheKey(parsed.selector);\n  } else {\n    // Selectors are unused in this project (build-time flag): the second\n    // argument can only be a locale, so the selector parsing is dead code.\n    locale = localeOrSelector as LocalesValues | undefined;\n  }\n\n  const cacheKey = `${key}_${locale ?? 'default'}_${selectorCacheKey}_${plugins ? 'custom_plugins' : 'default_plugins'}`;\n\n  if (dictionaryCache.has(cacheKey)) {\n    return dictionaryCache.get(cacheKey);\n  }\n\n  const result = getDictionary(dictionary, localeOrSelector, plugins);\n\n  dictionaryCache.set(cacheKey, result);\n\n  return result as any;\n};\n"],"mappings":";;;;;;;;;;;;AA0BA,MAAM,sBAAsB,OAAO,OAAY;CAC7C,OAAO,IAAI,MAAM,CAAC,GAAuC,EACvD,MAAM,SAAS,SAAS;EACtB,IACE,SAAS,YACT,SAAS,OAAO,eAChB,SAAS,cACT,SAAS,WAET,aAAa;EAEf,IAAI,SAAS,QACX;EAEF,IAAI,SAAS,OAAO,UAClB,OAAO,aAAa;GAClB,MAAM;EACR;EAIF,MAAM,WAAW,OAAO,GAAG,KAAK,GAAG,OAAO,IAAI,MAAM,OAAO,IAAI;EAC/D,OAAO,mBAAmB,QAAQ;CACpC,EACF,CAAC;AACH;AAEA,MAAM,kCAAkB,IAAI,IAAiB;AAC7C,MAAM,4CAA4B,IAAI,IAAY;;;;;;;;;;;AAYlD,MAAa,eAIX,KACA,kBACA,YAKG;CAEH,MAAM,+DAAwB,CAAC,CAAC;CAEhC,IAAI,CAAC,cAAc,QAAQ,IAAI,aAAa,eAAe;EACzD,IAAI,CAAC,0BAA0B,IAAI,GAAa,GAAG;GAGjD,0CAD4B,EAAE,gCAAI,CAC7B,CAAC,CACJ,OAAO,WAAW,cACd,uDAA0B,GAAG,EAAE,yCAC/B,cAAc,IAAI,wCACtB,EACE,OAAO,OACT,CACF;GACA,0BAA0B,IAAI,GAAa;EAC7C;EAEA,OAAO,mBAAmB,GAAa;CACzC;CAEA,IAAI;CACJ,IAAI,mBAAmB;CAEvB,IAAI,QAAQ,IAAI,iCAAiC,SAAS;EACxD,MAAM,SAASA,0EAAwB,gBAAgB;EACvD,SAAS,OAAO;EAChB,mBAAmBC,gFAA8B,OAAO,QAAQ;CAClE,OAGE,SAAS;CAGX,MAAM,WAAW,GAAG,IAAI,GAAG,UAAU,UAAU,GAAG,iBAAiB,GAAG,UAAU,mBAAmB;CAEnG,IAAI,gBAAgB,IAAI,QAAQ,GAC9B,OAAO,gBAAgB,IAAI,QAAQ;CAGrC,MAAM,SAASC,gDAAc,YAAY,kBAAkB,OAAO;CAElE,gBAAgB,IAAI,UAAU,MAAM;CAEpC,OAAO;AACT"}

package/dist/esm/dictionaryManipulator/index.mjs

@@ -1,4 +1,4 @@
-import { COMPOSITE_ID_SEPARATOR, QUALIFIER_DYNAMIC_TYPES_KEY, QUALIFIER_ORDER, getDictionaryCompositeIds, getDictionaryQualifierIds, getDictionaryQualifierTypes, getDictionarySelectorCacheKey, getVariantIds, isQualifiedDictionaryGroup, isQualifiedDynamicLoaderMap, parseDictionarySelector, reconstructQualifiedEntry, resolveQualifiedDictionary, resolveQualifiedDynamicContent, resolveQualifiedDynamicContentAsync, serializeVariant } from "./qualifiedDictionary.mjs";
+import { COMPOSITE_ID_SEPARATOR, DEFAULT_VARIANT_ID, QUALIFIER_DYNAMIC_TYPES_KEY, QUALIFIER_ORDER, getDictionaryCompositeIds, getDictionaryQualifierIds, getDictionaryQualifierTypes, getDictionarySelectorCacheKey, getVariantIds, isQualifiedDictionaryGroup, isQualifiedDynamicLoaderMap, parseDictionarySelector, reconstructQualifiedEntry, resolveDictionaryArgument, resolveProviderVariant, resolveQualifiedDictionary, resolveQualifiedDynamicContent, resolveQualifiedDynamicContentAsync, serializeVariant, serializeVariantChain } from "./qualifiedDictionary.mjs";
 import { editDictionaryByKeyPath } from "./editDictionaryByKeyPath.mjs";
 import { getContentNodeByKeyPath } from "./getContentNodeByKeyPath.mjs";
 import { getDefaultNode } from "./getDefaultNode.mjs";
@@ -13,4 +13,4 @@ import { removeContentNodeByKeyPath } from "./removeContentNodeByKeyPath.mjs";
 import { renameContentNodeByKeyPath } from "./renameContentNodeByKeyPath.mjs";
 import { updateNodeChildren } from "./updateNodeChildren.mjs";
 
-export { COMPOSITE_ID_SEPARATOR, QUALIFIER_DYNAMIC_TYPES_KEY, QUALIFIER_ORDER, editDictionaryByKeyPath, getContentNodeByKeyPath, getDefaultNode, getDictionaryCompositeIds, getDictionaryQualifierIds, getDictionaryQualifierTypes, getDictionarySelectorCacheKey, getEmptyNode, getNodeChildren, getNodeType, getVariantIds, isQualifiedDictionaryGroup, isQualifiedDynamicLoaderMap, mergeDictionaries, mergeQualifiedDictionaries, normalizeDictionaries, normalizeDictionary, orderDictionaries, parseDictionarySelector, reconstructQualifiedEntry, removeContentNodeByKeyPath, renameContentNodeByKeyPath, resolveQualifiedDictionary, resolveQualifiedDynamicContent, resolveQualifiedDynamicContentAsync, serializeVariant, updateNodeChildren };
+export { COMPOSITE_ID_SEPARATOR, DEFAULT_VARIANT_ID, QUALIFIER_DYNAMIC_TYPES_KEY, QUALIFIER_ORDER, editDictionaryByKeyPath, getContentNodeByKeyPath, getDefaultNode, getDictionaryCompositeIds, getDictionaryQualifierIds, getDictionaryQualifierTypes, getDictionarySelectorCacheKey, getEmptyNode, getNodeChildren, getNodeType, getVariantIds, isQualifiedDictionaryGroup, isQualifiedDynamicLoaderMap, mergeDictionaries, mergeQualifiedDictionaries, normalizeDictionaries, normalizeDictionary, orderDictionaries, parseDictionarySelector, reconstructQualifiedEntry, removeContentNodeByKeyPath, renameContentNodeByKeyPath, resolveDictionaryArgument, resolveProviderVariant, resolveQualifiedDictionary, resolveQualifiedDynamicContent, resolveQualifiedDynamicContentAsync, serializeVariant, serializeVariantChain, updateNodeChildren };

package/dist/esm/dictionaryManipulator/mergeQualifiedDictionaries.mjs

@@ -1,4 +1,4 @@
-import { QUALIFIER_ORDER, getDictionaryCompositeIds, getDictionaryQualifierTypes } from "./qualifiedDictionary.mjs";
+import { COMPOSITE_ID_SEPARATOR, DEFAULT_VARIANT_ID, QUALIFIER_ORDER, getDictionaryCompositeIds, getDictionaryQualifierTypes } from "./qualifiedDictionary.mjs";
 import { mergeDictionaries } from "./mergeDictionaries.mjs";
 import { log } from "@intlayer/config/built";
 import { colorizeKey, getAppLogger } from "@intlayer/config/logger";
@@ -14,7 +14,10 @@ import { colorizeKey, getAppLogger } from "@intlayer/config/logger";
 *   `variant → item`). Dictionaries are grouped by their composite id
 *   (one segment per dimension), merged within each group (locale completion /
 *   priority overrides preserved), and a `QualifiedDictionaryGroup` is returned.
-*   Unqualified siblings act as shared base content merged into every entry.
+*   Unqualified siblings act as shared base content merged into every entry —
+*   and, on a variant-only key, also materialize the `default` entry when no
+*   declaration claims it. Every other variant entry then inherits from that
+*   `default` entry, so a variant only declares the fields it overrides.
 *
 * Every qualified entry must declare ALL dimensions of the group; an entry that
 * declares only a subset is ambiguous and is rejected with an error log.
@@ -44,10 +47,30 @@ const mergeQualifiedDictionaries = (dictionaries) => {
 			entriesDictionaries.set(compositeId, existingEntries);
 		}
 	});
+	if (groupQualifierTypes.length === 1 && groupQualifierTypes[0] === "variant" && baseDictionaries.length > 0 && !entriesDictionaries.has("default")) entriesDictionaries.set(DEFAULT_VARIANT_ID, []);
 	const content = {};
 	let importMode;
+	const variantIndex = groupQualifierTypes.indexOf("variant");
+	/**
+	* The id of the entry a composite id inherits from — itself with its variant
+	* segment swapped for `default` (`'promo/2'` → `'default/2'`). `undefined`
+	* for the default entries themselves and for keys with no variant dimension.
+	*/
+	const getInheritedEntryId = (compositeId) => {
+		if (variantIndex === -1) return void 0;
+		const segments = compositeId.split("/");
+		if (segments[variantIndex] === "default") return void 0;
+		segments[variantIndex] = DEFAULT_VARIANT_ID;
+		return segments.join("/");
+	};
 	for (const [compositeId, qualifiedDictionaries] of entriesDictionaries) {
-		content[compositeId] = mergeDictionaries([...qualifiedDictionaries, ...baseDictionaries]).content;
+		const inheritedEntryId = getInheritedEntryId(compositeId);
+		const inheritedDictionaries = inheritedEntryId ? entriesDictionaries.get(inheritedEntryId) ?? [] : [];
+		content[compositeId] = mergeDictionaries([
+			...qualifiedDictionaries,
+			...inheritedDictionaries,
+			...baseDictionaries
+		]).content;
 		const [firstQualified] = qualifiedDictionaries;
 		importMode ??= firstQualified?.importMode;
 	}

package/dist/esm/dictionaryManipulator/mergeQualifiedDictionaries.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"mergeQualifiedDictionaries.mjs","names":[],"sources":["../../../src/dictionaryManipulator/mergeQualifiedDictionaries.ts"],"sourcesContent":["import { log } from '@intlayer/config/built';\nimport { colorizeKey, getAppLogger } from '@intlayer/config/logger';\nimport type {\n  Dictionary,\n  DictionaryQualifierType,\n  QualifiedDictionaryGroup,\n} from '@intlayer/types/dictionary';\nimport { mergeDictionaries } from './mergeDictionaries';\nimport {\n  getDictionaryCompositeIds,\n  getDictionaryQualifierTypes,\n  QUALIFIER_ORDER,\n} from './qualifiedDictionary';\n\n/**\n * Merges sibling dictionaries sharing the same key, honouring qualifiers.\n *\n * - No dictionary declares a qualifier → behaves exactly like\n *   `mergeDictionaries` (single merged dictionary).\n * - At least one dictionary declares a qualifier → the group's dimension set is\n *   the union of every declared dimension (in canonical order\n *   `variant → item`). Dictionaries are grouped by their composite id\n *   (one segment per dimension), merged within each group (locale completion /\n *   priority overrides preserved), and a `QualifiedDictionaryGroup` is returned.\n *   Unqualified siblings act as shared base content merged into every entry.\n *\n * Every qualified entry must declare ALL dimensions of the group; an entry that\n * declares only a subset is ambiguous and is rejected with an error log.\n */\nexport const mergeQualifiedDictionaries = (\n  dictionaries: Dictionary[]\n): Dictionary | QualifiedDictionaryGroup => {\n  const perDictionaryTypes = dictionaries.map(getDictionaryQualifierTypes);\n\n  const declaredDimensions = new Set<DictionaryQualifierType>();\n  for (const types of perDictionaryTypes) {\n    for (const type of types) declaredDimensions.add(type);\n  }\n\n  // Canonical order, restricted to the dimensions actually declared.\n  const groupQualifierTypes = QUALIFIER_ORDER.filter((qualifierType) =>\n    declaredDimensions.has(qualifierType)\n  );\n\n  if (groupQualifierTypes.length === 0) {\n    return mergeDictionaries(dictionaries);\n  }\n\n  const appLogger = getAppLogger({ log });\n\n  const baseDictionaries: Dictionary[] = [];\n  const entriesDictionaries = new Map<string, Dictionary[]>();\n\n  dictionaries.forEach((dictionary, index) => {\n    if (perDictionaryTypes[index]?.length === 0) {\n      baseDictionaries.push(dictionary);\n      return;\n    }\n\n    // A dictionary may map to several composite ids (array variant fan-out):\n    // its content is registered under every id it lists.\n    const compositeIds = getDictionaryCompositeIds(\n      dictionary,\n      groupQualifierTypes\n    );\n\n    if (compositeIds === undefined) {\n      appLogger(\n        `Dictionary ${colorizeKey(dictionary.key)} declares (${perDictionaryTypes[index].join(', ')}) but the key's dimensions are (${groupQualifierTypes.join(', ')}); every entry must declare all of them. Entry ignored${dictionary.filePath ? ` - ${dictionary.filePath}` : ''}.`,\n        { level: 'error' }\n      );\n      return;\n    }\n\n    for (const compositeId of compositeIds) {\n      const existingEntries = entriesDictionaries.get(compositeId) ?? [];\n      existingEntries.push(dictionary);\n      entriesDictionaries.set(compositeId, existingEntries);\n    }\n  });\n\n  // `content` maps each composite id to its resolved content node directly; the\n  // qualifier coordinates live in the key, not in a per-entry wrapper. For an\n  // object variant the variant segment is the canonical serialization of the\n  // object, so it fully identifies the entry — no side-map is needed.\n  const content: Record<string, unknown> = {};\n\n  let importMode: Dictionary['importMode'];\n\n  for (const [compositeId, qualifiedDictionaries] of entriesDictionaries) {\n    // Unqualified siblings act as shared base content: appended last so the\n    // qualified entries take precedence (mergeDictionaries prefers first).\n    const mergedEntry = mergeDictionaries([\n      ...qualifiedDictionaries,\n      ...baseDictionaries,\n    ]);\n\n    content[compositeId] = mergedEntry.content;\n\n    const [firstQualified] = qualifiedDictionaries;\n\n    importMode ??= firstQualified?.importMode;\n  }\n\n  const localIds = Array.from(\n    new Set(\n      dictionaries\n        .filter((dictionary) => dictionary.localId)\n        .map((dictionary) => dictionary.localId!)\n    )\n  );\n\n  return {\n    key: dictionaries[0]!.key,\n    qualifierTypes: groupQualifierTypes,\n    content,\n    ...(importMode !== undefined && { importMode }),\n    localIds,\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AA6BA,MAAa,8BACX,iBAC0C;CAC1C,MAAM,qBAAqB,aAAa,IAAI,2BAA2B;CAEvE,MAAM,qCAAqB,IAAI,IAA6B;CAC5D,KAAK,MAAM,SAAS,oBAClB,KAAK,MAAM,QAAQ,OAAO,mBAAmB,IAAI,IAAI;CAIvD,MAAM,sBAAsB,gBAAgB,QAAQ,kBAClD,mBAAmB,IAAI,aAAa,CACtC;CAEA,IAAI,oBAAoB,WAAW,GACjC,OAAO,kBAAkB,YAAY;CAGvC,MAAM,YAAY,aAAa,EAAE,IAAI,CAAC;CAEtC,MAAM,mBAAiC,CAAC;CACxC,MAAM,sCAAsB,IAAI,IAA0B;CAE1D,aAAa,SAAS,YAAY,UAAU;EAC1C,IAAI,mBAAmB,MAAM,EAAE,WAAW,GAAG;GAC3C,iBAAiB,KAAK,UAAU;GAChC;EACF;EAIA,MAAM,eAAe,0BACnB,YACA,mBACF;EAEA,IAAI,iBAAiB,QAAW;GAC9B,UACE,cAAc,YAAY,WAAW,GAAG,EAAE,aAAa,mBAAmB,MAAM,CAAC,KAAK,IAAI,EAAE,kCAAkC,oBAAoB,KAAK,IAAI,EAAE,wDAAwD,WAAW,WAAW,MAAM,WAAW,aAAa,GAAG,IAC5Q,EAAE,OAAO,QAAQ,CACnB;GACA;EACF;EAEA,KAAK,MAAM,eAAe,cAAc;GACtC,MAAM,kBAAkB,oBAAoB,IAAI,WAAW,KAAK,CAAC;GACjE,gBAAgB,KAAK,UAAU;GAC/B,oBAAoB,IAAI,aAAa,eAAe;EACtD;CACF,CAAC;CAMD,MAAM,UAAmC,CAAC;CAE1C,IAAI;CAEJ,KAAK,MAAM,CAAC,aAAa,0BAA0B,qBAAqB;EAQtE,QAAQ,eALY,kBAAkB,CACpC,GAAG,uBACH,GAAG,gBACL,CAEiC,CAAC,CAAC;EAEnC,MAAM,CAAC,kBAAkB;EAEzB,eAAe,gBAAgB;CACjC;CAEA,MAAM,WAAW,MAAM,KACrB,IAAI,IACF,aACG,QAAQ,eAAe,WAAW,OAAO,CAAC,CAC1C,KAAK,eAAe,WAAW,OAAQ,CAC5C,CACF;CAEA,OAAO;EACL,KAAK,aAAa,EAAE,CAAE;EACtB,gBAAgB;EAChB;EACA,GAAI,eAAe,UAAa,EAAE,WAAW;EAC7C;CACF;AACF"}
+{"version":3,"file":"mergeQualifiedDictionaries.mjs","names":[],"sources":["../../../src/dictionaryManipulator/mergeQualifiedDictionaries.ts"],"sourcesContent":["import { log } from '@intlayer/config/built';\nimport { colorizeKey, getAppLogger } from '@intlayer/config/logger';\nimport type {\n  Dictionary,\n  DictionaryQualifierType,\n  QualifiedDictionaryGroup,\n} from '@intlayer/types/dictionary';\nimport { mergeDictionaries } from './mergeDictionaries';\nimport {\n  COMPOSITE_ID_SEPARATOR,\n  DEFAULT_VARIANT_ID,\n  getDictionaryCompositeIds,\n  getDictionaryQualifierTypes,\n  QUALIFIER_ORDER,\n} from './qualifiedDictionary';\n\n/**\n * Merges sibling dictionaries sharing the same key, honouring qualifiers.\n *\n * - No dictionary declares a qualifier → behaves exactly like\n *   `mergeDictionaries` (single merged dictionary).\n * - At least one dictionary declares a qualifier → the group's dimension set is\n *   the union of every declared dimension (in canonical order\n *   `variant → item`). Dictionaries are grouped by their composite id\n *   (one segment per dimension), merged within each group (locale completion /\n *   priority overrides preserved), and a `QualifiedDictionaryGroup` is returned.\n *   Unqualified siblings act as shared base content merged into every entry —\n *   and, on a variant-only key, also materialize the `default` entry when no\n *   declaration claims it. Every other variant entry then inherits from that\n *   `default` entry, so a variant only declares the fields it overrides.\n *\n * Every qualified entry must declare ALL dimensions of the group; an entry that\n * declares only a subset is ambiguous and is rejected with an error log.\n */\nexport const mergeQualifiedDictionaries = (\n  dictionaries: Dictionary[]\n): Dictionary | QualifiedDictionaryGroup => {\n  const perDictionaryTypes = dictionaries.map(getDictionaryQualifierTypes);\n\n  const declaredDimensions = new Set<DictionaryQualifierType>();\n  for (const types of perDictionaryTypes) {\n    for (const type of types) declaredDimensions.add(type);\n  }\n\n  // Canonical order, restricted to the dimensions actually declared.\n  const groupQualifierTypes = QUALIFIER_ORDER.filter((qualifierType) =>\n    declaredDimensions.has(qualifierType)\n  );\n\n  if (groupQualifierTypes.length === 0) {\n    return mergeDictionaries(dictionaries);\n  }\n\n  const appLogger = getAppLogger({ log });\n\n  const baseDictionaries: Dictionary[] = [];\n  const entriesDictionaries = new Map<string, Dictionary[]>();\n\n  dictionaries.forEach((dictionary, index) => {\n    if (perDictionaryTypes[index]?.length === 0) {\n      baseDictionaries.push(dictionary);\n      return;\n    }\n\n    // A dictionary may map to several composite ids (array variant fan-out):\n    // its content is registered under every id it lists.\n    const compositeIds = getDictionaryCompositeIds(\n      dictionary,\n      groupQualifierTypes\n    );\n\n    if (compositeIds === undefined) {\n      appLogger(\n        `Dictionary ${colorizeKey(dictionary.key)} declares (${perDictionaryTypes[index].join(', ')}) but the key's dimensions are (${groupQualifierTypes.join(', ')}); every entry must declare all of them. Entry ignored${dictionary.filePath ? ` - ${dictionary.filePath}` : ''}.`,\n        { level: 'error' }\n      );\n      return;\n    }\n\n    for (const compositeId of compositeIds) {\n      const existingEntries = entriesDictionaries.get(compositeId) ?? [];\n      existingEntries.push(dictionary);\n      entriesDictionaries.set(compositeId, existingEntries);\n    }\n  });\n\n  // Unqualified siblings are the key's base content. On a variant key they also\n  // materialize the `default` entry when no declaration claims it, so the key\n  // still resolves when no variant is selected — and so variants that declare\n  // no entry of their own can fall back to it. Registering an empty entry list\n  // is enough: the merge loop below appends the base dictionaries to it.\n  //\n  // Composite (variant × item) keys are excluded: base content carries no item\n  // index, so it cannot be placed on the collection axis.\n  const isVariantOnlyGroup =\n    groupQualifierTypes.length === 1 && groupQualifierTypes[0] === 'variant';\n\n  if (\n    isVariantOnlyGroup &&\n    baseDictionaries.length > 0 &&\n    !entriesDictionaries.has(DEFAULT_VARIANT_ID)\n  ) {\n    entriesDictionaries.set(DEFAULT_VARIANT_ID, []);\n  }\n\n  // `content` maps each composite id to its resolved content node directly; the\n  // qualifier coordinates live in the key, not in a per-entry wrapper. For an\n  // object variant the variant segment is the canonical serialization of the\n  // object, so it fully identifies the entry — no side-map is needed.\n  const content: Record<string, unknown> = {};\n\n  let importMode: Dictionary['importMode'];\n\n  const variantIndex = groupQualifierTypes.indexOf('variant');\n\n  /**\n   * The id of the entry a composite id inherits from — itself with its variant\n   * segment swapped for `default` (`'promo/2'` → `'default/2'`). `undefined`\n   * for the default entries themselves and for keys with no variant dimension.\n   */\n  const getInheritedEntryId = (compositeId: string): string | undefined => {\n    if (variantIndex === -1) return undefined;\n\n    const segments = compositeId.split(COMPOSITE_ID_SEPARATOR);\n    if (segments[variantIndex] === DEFAULT_VARIANT_ID) return undefined;\n\n    segments[variantIndex] = DEFAULT_VARIANT_ID;\n    return segments.join(COMPOSITE_ID_SEPARATOR);\n  };\n\n  for (const [compositeId, qualifiedDictionaries] of entriesDictionaries) {\n    // Precedence, highest first: the entry's own declarations, then the\n    // `default` variant it inherits from, then the unqualified siblings shared\n    // by the whole key (mergeDictionaries prefers the first occurrence).\n    //\n    // Inheriting from `default` is what makes a variant declaration partial: it\n    // only has to declare the fields whose wording actually differs, and every\n    // other field is completed from the default entry.\n    const inheritedEntryId = getInheritedEntryId(compositeId);\n    const inheritedDictionaries = inheritedEntryId\n      ? (entriesDictionaries.get(inheritedEntryId) ?? [])\n      : [];\n\n    const mergedEntry = mergeDictionaries([\n      ...qualifiedDictionaries,\n      ...inheritedDictionaries,\n      ...baseDictionaries,\n    ]);\n\n    content[compositeId] = mergedEntry.content;\n\n    const [firstQualified] = qualifiedDictionaries;\n\n    importMode ??= firstQualified?.importMode;\n  }\n\n  const localIds = Array.from(\n    new Set(\n      dictionaries\n        .filter((dictionary) => dictionary.localId)\n        .map((dictionary) => dictionary.localId!)\n    )\n  );\n\n  return {\n    key: dictionaries[0]!.key,\n    qualifierTypes: groupQualifierTypes,\n    content,\n    ...(importMode !== undefined && { importMode }),\n    localIds,\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAkCA,MAAa,8BACX,iBAC0C;CAC1C,MAAM,qBAAqB,aAAa,IAAI,2BAA2B;CAEvE,MAAM,qCAAqB,IAAI,IAA6B;CAC5D,KAAK,MAAM,SAAS,oBAClB,KAAK,MAAM,QAAQ,OAAO,mBAAmB,IAAI,IAAI;CAIvD,MAAM,sBAAsB,gBAAgB,QAAQ,kBAClD,mBAAmB,IAAI,aAAa,CACtC;CAEA,IAAI,oBAAoB,WAAW,GACjC,OAAO,kBAAkB,YAAY;CAGvC,MAAM,YAAY,aAAa,EAAE,IAAI,CAAC;CAEtC,MAAM,mBAAiC,CAAC;CACxC,MAAM,sCAAsB,IAAI,IAA0B;CAE1D,aAAa,SAAS,YAAY,UAAU;EAC1C,IAAI,mBAAmB,MAAM,EAAE,WAAW,GAAG;GAC3C,iBAAiB,KAAK,UAAU;GAChC;EACF;EAIA,MAAM,eAAe,0BACnB,YACA,mBACF;EAEA,IAAI,iBAAiB,QAAW;GAC9B,UACE,cAAc,YAAY,WAAW,GAAG,EAAE,aAAa,mBAAmB,MAAM,CAAC,KAAK,IAAI,EAAE,kCAAkC,oBAAoB,KAAK,IAAI,EAAE,wDAAwD,WAAW,WAAW,MAAM,WAAW,aAAa,GAAG,IAC5Q,EAAE,OAAO,QAAQ,CACnB;GACA;EACF;EAEA,KAAK,MAAM,eAAe,cAAc;GACtC,MAAM,kBAAkB,oBAAoB,IAAI,WAAW,KAAK,CAAC;GACjE,gBAAgB,KAAK,UAAU;GAC/B,oBAAoB,IAAI,aAAa,eAAe;EACtD;CACF,CAAC;CAaD,IAFE,oBAAoB,WAAW,KAAK,oBAAoB,OAAO,aAI/D,iBAAiB,SAAS,KAC1B,CAAC,oBAAoB,aAAsB,GAE3C,oBAAoB,IAAI,oBAAoB,CAAC,CAAC;CAOhD,MAAM,UAAmC,CAAC;CAE1C,IAAI;CAEJ,MAAM,eAAe,oBAAoB,QAAQ,SAAS;;;;;;CAO1D,MAAM,uBAAuB,gBAA4C;EACvE,IAAI,iBAAiB,IAAI,OAAO;EAEhC,MAAM,WAAW,YAAY,SAA4B;EACzD,IAAI,SAAS,6BAAsC,OAAO;EAE1D,SAAS,gBAAgB;EACzB,OAAO,SAAS,QAA2B;CAC7C;CAEA,KAAK,MAAM,CAAC,aAAa,0BAA0B,qBAAqB;EAQtE,MAAM,mBAAmB,oBAAoB,WAAW;EACxD,MAAM,wBAAwB,mBACzB,oBAAoB,IAAI,gBAAgB,KAAK,CAAC,IAC/C,CAAC;EAQL,QAAQ,eANY,kBAAkB;GACpC,GAAG;GACH,GAAG;GACH,GAAG;EACL,CAEiC,CAAC,CAAC;EAEnC,MAAM,CAAC,kBAAkB;EAEzB,eAAe,gBAAgB;CACjC;CAEA,MAAM,WAAW,MAAM,KACrB,IAAI,IACF,aACG,QAAQ,eAAe,WAAW,OAAO,CAAC,CAC1C,KAAK,eAAe,WAAW,OAAQ,CAC5C,CACF;CAEA,OAAO;EACL,KAAK,aAAa,EAAE,CAAE;EACtB,gBAAgB;EAChB;EACA,GAAI,eAAe,UAAa,EAAE,WAAW;EAC7C;CACF;AACF"}

package/dist/esm/dictionaryManipulator/qualifiedDictionary.mjs

@@ -11,6 +11,12 @@ const QUALIFIER_ORDER = ["variant", "item"];
 */
 const COMPOSITE_ID_SEPARATOR = "/";
 /**
+* Identity of the implicit fallback variant. A selector that pins no variant
+* resolves to it, and a variant that declares no entry of its own falls back to
+* it — so a key only has to ship the entries that actually differ.
+*/
+const DEFAULT_VARIANT_ID = "default";
+/**
 * Characters kept verbatim in an encoded qualifier segment. Everything else is
 * percent-encoded so a segment can never contain the composite-id separator
 * (`/`), path-hostile characters (`\` `:` `*` `?` `"` `<` `>` `|`, control
@@ -49,7 +55,7 @@ const encodeSegmentText = (raw, unsafeChars) => {
 * an object variant in a selector must equal the one declared on the dictionary.
 */
 const serializeVariant = (variant) => {
-	if (variant === void 0) return "default";
+	if (variant === void 0) return DEFAULT_VARIANT_ID;
 	if (typeof variant === "string") return encodeSegmentText(variant, SEGMENT_UNSAFE_CHARS);
 	return Object.keys(variant).sort().map((field) => `${encodeSegmentText(field, COMPONENT_UNSAFE_CHARS)}=${encodeSegmentText(String(variant[field]), COMPONENT_UNSAFE_CHARS)}`).join("&");
 };
@@ -105,16 +111,53 @@ const getDictionaryCompositeIds = (dictionary, qualifierTypes) => {
 	return compositeIds;
 };
 /**
+* Serializes the variant coordinate of a selector into the ordered list of
+* candidate ids to try, so a single value and a preference chain share one code
+* path downstream.
+*
+* - `undefined` → `['default']`
+* - a single value → its one serialization
+* - a chain → one serialization per entry, order preserved
+*
+* An empty chain is treated as "no variant pinned" (`['default']`) rather than
+* as an unsatisfiable request.
+*/
+const serializeVariantChain = (variant) => {
+	if (!Array.isArray(variant)) return [serializeVariant(variant)];
+	if (variant.length === 0) return [DEFAULT_VARIANT_ID];
+	return variant.map(serializeVariant);
+};
+/**
+* Resolves the variant id a selector actually targets among the ids a key
+* declares — the sparse-override fallback.
+*
+* Candidates are tried in order and the first one the key declares wins.
+* Otherwise the key falls back to its `default` entry, so a variant only has to
+* be declared where its wording differs. When the key declares no `default`
+* either, the first candidate is returned unchanged and the caller resolves to
+* `null` / `[]`.
+*
+* @param requestedVariantIds - The serialized ids the selector asks for, in
+*                              preference order (a single value is a 1-element
+*                              list).
+* @param isVariantIdDeclared - Whether the key declares an entry for an id.
+*/
+const resolveEffectiveVariantId = (requestedVariantIds, isVariantIdDeclared) => {
+	for (const requestedVariantId of requestedVariantIds) if (isVariantIdDeclared(requestedVariantId)) return requestedVariantId;
+	return isVariantIdDeclared("default") ? DEFAULT_VARIANT_ID : requestedVariantIds[0] ?? "default";
+};
+/**
 * Tests whether a composite entry id matches a selector across every declared
 * dimension. Segments are compared in their encoded form (both the stored id
 * and the selector go through {@link serializeVariant}). The `item` dimension
 * matches any value when the selector does not provide one (open collection
-* axis).
+* axis); the `variant` dimension is compared against the already-resolved
+* effective id, so the fallback is applied consistently across dimensions.
 */
-const compositeIdMatchesSelector = (compositeId, qualifierTypes, selector) => {
+const compositeIdMatchesSelector = (compositeId, qualifierTypes, selector, effectiveVariantId) => {
 	const segments = compositeId.split("/");
 	return qualifierTypes.every((qualifierType, index) => {
-		if (qualifierType === "variant") return segments[index] === serializeVariant(selector?.variant);
+		if (qualifierType === "variant") return segments[index] === effectiveVariantId;
 		return selector?.item === void 0 || segments[index] === String(selector.item);
 	});
 };
@@ -154,8 +197,10 @@ const reconstructQualifiedEntry = (group, compositeId) => {
 * - Plain dictionary → returned as-is (selector ignored)
 * - `item` declared but not selected → every matching entry ordered by index
 * - `item` selected → the matching entry or null
-* - `variant` defaults to the `default` entry when not selected; an object
-*   variant resolves only when the selector provides an equal object
+* - `variant` defaults to the `default` entry when not selected, and falls back
+*   to it when the selected variant declares no entry of its own; an object
+*   variant resolves only when the selector provides an equal object (or, again,
+*   through the `default` fallback)
 *
 * Dimensions compose: e.g. a variant × item key with `{ variant: 'promo' }`
 * returns every promo item as an array; adding `{ item: 2 }` narrows to one.
@@ -164,7 +209,10 @@ const resolveQualifiedDictionary = (dictionaryOrGroup, selector) => {
 	if (!isQualifiedDictionaryGroup(dictionaryOrGroup)) return dictionaryOrGroup;
 	const { qualifierTypes, content } = dictionaryOrGroup;
 	const itemAxisOpen = qualifierTypes.includes("item") && selector?.item === void 0;
-	const matchedEntries = Object.keys(content).filter((compositeId) => compositeIdMatchesSelector(compositeId, qualifierTypes, selector)).map((compositeId) => reconstructQualifiedEntry(dictionaryOrGroup, compositeId));
+	const compositeIds = Object.keys(content);
+	const variantIndex = qualifierTypes.indexOf("variant");
+	const effectiveVariantId = variantIndex === -1 ? DEFAULT_VARIANT_ID : resolveEffectiveVariantId(serializeVariantChain(selector?.variant), (variantId) => compositeIds.some((compositeId) => compositeId.split("/")[variantIndex] === variantId));
+	const matchedEntries = compositeIds.filter((compositeId) => compositeIdMatchesSelector(compositeId, qualifierTypes, selector, effectiveVariantId)).map((compositeId) => reconstructQualifiedEntry(dictionaryOrGroup, compositeId));
 	if (itemAxisOpen) return matchedEntries.sort((left, right) => (left.item ?? 0) - (right.item ?? 0));
 	return matchedEntries[0] ?? null;
 };
@@ -180,6 +228,56 @@ const parseDictionarySelector = (localeOrSelector) => {
 	return { locale: localeOrSelector };
 };
 /**
+* Resolves the variant a provider pins for one dictionary key.
+*
+* A string or a chain applies to every key as-is. A plain object is the per-key
+* map: the entry for `dictionaryKey` wins, falling back to the reserved
+* `default` entry, and `undefined` when neither is present (the key then
+* resolves to its own `default` variant, i.e. the behaviour without a provider
+* variant at all).
+*
+* A plain object is **always** the map here — never a structured variant value,
+* which is why a structured variant has to be nested (`{ default: { id } }`).
+*
+* @param providerVariant - The `variant` prop of the surrounding provider.
+* @param dictionaryKey - The key being read.
+*/
+const resolveProviderVariant = (providerVariant, dictionaryKey) => {
+	if (providerVariant === void 0) return void 0;
+	if (typeof providerVariant === "string" || Array.isArray(providerVariant)) return providerVariant;
+	const variantMap = providerVariant;
+	return variantMap[dictionaryKey] ?? variantMap["default"];
+};
+/**
+* Builds the effective second argument of a dictionary read by layering the
+* provider defaults under the call-site one — the single place the `locale` and
+* `variant` context defaults are applied, shared by every framework binding.
+*
+* Precedence, per dimension independently:
+* - a call-site selector always wins; `{ variant: 'x' }` **replaces** the
+*   provider chain rather than extending it
+* - otherwise the provider value applies
+*
+* Returns a bare locale (not a selector object) whenever no variant is in play,
+* so the existing fast path — and the cache keys built from it — are unchanged
+* for projects that never use variants.
+*/
+const resolveDictionaryArgument = (params) => {
+	const { localeOrSelector, contextLocale, contextVariant, dictionaryKey } = params;
+	const callSelector = typeof localeOrSelector === "object" && localeOrSelector !== null ? localeOrSelector : void 0;
+	const locale = (callSelector ? callSelector.locale : localeOrSelector) ?? contextLocale;
+	const variant = callSelector?.variant ?? resolveProviderVariant(contextVariant, dictionaryKey);
+	if (variant === void 0) return callSelector ? {
+		...callSelector,
+		locale
+	} : locale;
+	return {
+		...callSelector,
+		locale,
+		variant
+	};
+};
+/**
 * Builds a stable string identity of a selector (excluding `locale`), suitable
 * for cache keys and memoization dependencies.
 */
@@ -187,7 +285,7 @@ const getDictionarySelectorCacheKey = (selector) => {
 	if (!selector) return "";
 	return Object.keys(selector).filter((selectorKey) => selectorKey !== "locale").sort().map((selectorKey) => {
 		const value = selector[selectorKey];
-		return `${selectorKey}:${selectorKey === "variant" ? serializeVariant(value) : String(value)}`;
+		return `${selectorKey}:${selectorKey === "variant" ? serializeVariantChain(value).join(",") : String(value)}`;
 	}).join("|");
 };
 /**
@@ -231,7 +329,7 @@ const collectQualifiedChunks = (loaderMap, key, locale, selector) => {
 			for (const segment of Object.keys(tree).sort((left, right) => Number(left) - Number(right))) walk(tree[segment], rest, [...segments, segment]);
 			return true;
 		}
-		const segment = dimension === "variant" ? serializeVariant(selector?.variant) : String(selector?.item);
+		const segment = dimension === "variant" ? resolveEffectiveVariantId(serializeVariantChain(selector?.variant), (variantId) => tree[variantId] !== void 0) : String(selector?.item);
 		const child = tree[segment];
 		if (!child) return false;
 		return walk(child, rest, [...segments, segment]);
@@ -247,11 +345,11 @@ const collectQualifiedChunks = (loaderMap, key, locale, selector) => {
 * loading only the chunk(s) the selector actually targets.
 *
 * Walks the nested loader tree one dimension at a time (canonical order
-* `variant → item`): `variant` defaults to `default` (or descends by the
-* serialized object identity), and `item` either narrows to the selected index
-* or — when no item is given — expands into every sibling chunk (the collection
-* axis). Semantics mirror {@link resolveQualifiedDictionary} so dynamic and
-* static modes behave alike.
+* `variant → item`): `variant` descends by the serialized id, falling back to
+* `default` when the selected variant has no chunk of its own, and `item`
+* either narrows to the selected index or — when no item is given — expands
+* into every sibling chunk (the collection axis). Semantics mirror
+* {@link resolveQualifiedDictionary} so dynamic and static modes behave alike.
 *
 * The Suspense mechanism is injected through `loadChunk` so the same logic
 * serves both the client (suspender cache) and the server (`react.use`). Every
@@ -296,5 +394,5 @@ const resolveQualifiedDynamicContentAsync = async (params) => {
 };
 
 //#endregion
-export { COMPOSITE_ID_SEPARATOR, QUALIFIER_DYNAMIC_TYPES_KEY, QUALIFIER_ORDER, getDictionaryCompositeIds, getDictionaryQualifierIds, getDictionaryQualifierTypes, getDictionarySelectorCacheKey, getVariantIds, isQualifiedDictionaryGroup, isQualifiedDynamicLoaderMap, parseDictionarySelector, reconstructQualifiedEntry, resolveQualifiedDictionary, resolveQualifiedDynamicContent, resolveQualifiedDynamicContentAsync, serializeVariant };
+export { COMPOSITE_ID_SEPARATOR, DEFAULT_VARIANT_ID, QUALIFIER_DYNAMIC_TYPES_KEY, QUALIFIER_ORDER, getDictionaryCompositeIds, getDictionaryQualifierIds, getDictionaryQualifierTypes, getDictionarySelectorCacheKey, getVariantIds, isQualifiedDictionaryGroup, isQualifiedDynamicLoaderMap, parseDictionarySelector, reconstructQualifiedEntry, resolveDictionaryArgument, resolveProviderVariant, resolveQualifiedDictionary, resolveQualifiedDynamicContent, resolveQualifiedDynamicContentAsync, serializeVariant, serializeVariantChain };
 //# sourceMappingURL=qualifiedDictionary.mjs.map

package/dist/esm/dictionaryManipulator/qualifiedDictionary.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"qualifiedDictionary.mjs","names":[],"sources":["../../../src/dictionaryManipulator/qualifiedDictionary.ts"],"sourcesContent":["import type {\n  Dictionary,\n  DictionaryQualifierType,\n  DictionarySelector,\n  DictionaryVariantValue,\n  QualifiedDictionaryGroup,\n} from '@intlayer/types/dictionary';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\n\n/**\n * Canonical order of qualifier dimensions. A key that declares both dimensions\n * always nests them in this order, with `item` innermost so it can act as the\n * collection (array) axis.\n */\nexport const QUALIFIER_ORDER = [\n  'variant',\n  'item',\n] as const satisfies readonly DictionaryQualifierType[];\n\n/**\n * Separator joining per-dimension ids into a composite entry id. Also used as\n * the chunk path separator in dynamic mode.\n */\nexport const COMPOSITE_ID_SEPARATOR = '/';\n\n/**\n * Characters kept verbatim in an encoded qualifier segment. Everything else is\n * percent-encoded so a segment can never contain the composite-id separator\n * (`/`), path-hostile characters (`\\` `:` `*` `?` `\"` `<` `>` `|`, control\n * chars), or characters that would break the generated loader modules (`'`).\n */\nconst SEGMENT_UNSAFE_CHARS = /[^A-Za-z0-9._&=-]/g;\n\n/**\n * Stricter set for the components of an object variant: also encodes `&` and\n * `=` so the `field=value&field=value` serialization stays unambiguous.\n */\nconst COMPONENT_UNSAFE_CHARS = /[^A-Za-z0-9._-]/g;\n\n/** Percent-encodes one UTF-16 code unit as a fixed-width `%XXXX` run. */\nconst percentEncodeChar = (char: string): string =>\n  `%${char.charCodeAt(0).toString(16).toUpperCase().padStart(4, '0')}`;\n\nconst encodeSegmentText = (raw: string, unsafeChars: RegExp): string => {\n  // Bare '%' cannot be produced by encoding (every encoded run is %XXXX),\n  // so it is a safe stand-in for the empty string.\n  if (raw === '') return '%';\n\n  const encoded = raw.replace(unsafeChars, percentEncodeChar);\n\n  // '.' and '..' are path navigation on every filesystem — encode the dots.\n  if (encoded === '.' || encoded === '..') {\n    return encoded.replace(/\\./g, '%002E');\n  }\n\n  return encoded;\n};\n\n/**\n * Canonical serialization of a single variant value into its identity string —\n * the variant segment of a composite id, the chunk directory name in dynamic\n * mode, and the runtime matching key.\n *\n * - `undefined` → `'default'` (the implicit fallback variant)\n * - a string → the string itself (a named variant)\n * - an object → its sorted `key=value` pairs joined by `&`\n *   (e.g. `{ userId: '123', id: 'abc' }` → `'id=abc&userId=123'`)\n *\n * Characters that are unsafe in file paths or generated code are\n * percent-encoded (fixed-width `%XXXX` runs, injective). Common names —\n * letters, digits, `-` `_` `.` — are left untouched. Both the declaration and\n * the selector go through this function, so encoding never affects matching.\n *\n * Two variants resolve to the same entry iff their serializations are equal, so\n * an object variant in a selector must equal the one declared on the dictionary.\n */\nexport const serializeVariant = (\n  variant: DictionaryVariantValue | undefined\n): string => {\n  if (variant === undefined) return 'default';\n  if (typeof variant === 'string') {\n    return encodeSegmentText(variant, SEGMENT_UNSAFE_CHARS);\n  }\n\n  return Object.keys(variant)\n    .sort()\n    .map(\n      (field) =>\n        `${encodeSegmentText(field, COMPONENT_UNSAFE_CHARS)}=${encodeSegmentText(String(variant[field]), COMPONENT_UNSAFE_CHARS)}`\n    )\n    .join('&');\n};\n\n/**\n * Normalizes the `variant` field of a dictionary into the list of variant ids\n * the declaration registers under. A single value yields one id; an **array**\n * fans out into one id per element (duplicates collapsed). Returns `undefined`\n * when the dictionary does not declare the variant dimension (no `variant`\n * field, or an empty array).\n */\nexport const getVariantIds = (\n  variant: Dictionary['variant']\n): string[] | undefined => {\n  if (variant === undefined) return undefined;\n\n  const values = Array.isArray(variant) ? variant : [variant];\n  if (values.length === 0) return undefined;\n\n  return [...new Set(values.map(serializeVariant))];\n};\n\n/**\n * Returns the qualifier dimensions declared on a dictionary, in canonical\n * order (`variant → item`). Empty when the dictionary is unqualified\n * (plain dictionary or shared base content of a qualified group).\n */\nexport const getDictionaryQualifierTypes = (\n  dictionary: Dictionary\n): DictionaryQualifierType[] => {\n  const declaredQualifiers: DictionaryQualifierType[] = [];\n\n  if (getVariantIds(dictionary.variant) !== undefined) {\n    declaredQualifiers.push('variant');\n  }\n  if (typeof dictionary.item === 'number') declaredQualifiers.push('item');\n\n  return declaredQualifiers;\n};\n\n/**\n * Returns the qualifier identifiers of a dictionary for the given qualifier\n * dimension — the candidate segments of the composite entry ids.\n *\n * - 'variant' → the serialized variant id(s); an array variant yields one id\n *   per element (declaration-side fan-out)\n * - 'item' → the item index as a single-element list\n */\nexport const getDictionaryQualifierIds = (\n  dictionary: Dictionary,\n  qualifierType: DictionaryQualifierType\n): string[] | undefined => {\n  if (qualifierType === 'variant') {\n    return getVariantIds(dictionary.variant);\n  }\n  return dictionary.item === undefined ? undefined : [String(dictionary.item)];\n};\n\n/**\n * Builds every composite entry id of a dictionary — the cartesian product of\n * its per-dimension id lists, joined in canonical order. A dictionary with a\n * plain (non-array) variant yields exactly one id; an array variant fans out\n * into one id per element. `undefined` when a dimension of the set is missing.\n */\nexport const getDictionaryCompositeIds = (\n  dictionary: Dictionary,\n  qualifierTypes: DictionaryQualifierType[]\n): string[] | undefined => {\n  let compositeIds: string[] = [''];\n\n  for (const qualifierType of qualifierTypes) {\n    const ids = getDictionaryQualifierIds(dictionary, qualifierType);\n    if (ids === undefined) return undefined;\n\n    compositeIds = compositeIds.flatMap((prefix) =>\n      ids.map((id) =>\n        prefix === '' ? id : `${prefix}${COMPOSITE_ID_SEPARATOR}${id}`\n      )\n    );\n  }\n\n  return compositeIds;\n};\n\n/**\n * Tests whether a composite entry id matches a selector across every declared\n * dimension. Segments are compared in their encoded form (both the stored id\n * and the selector go through {@link serializeVariant}). The `item` dimension\n * matches any value when the selector does not provide one (open collection\n * axis).\n */\nconst compositeIdMatchesSelector = (\n  compositeId: string,\n  qualifierTypes: DictionaryQualifierType[],\n  selector: DictionarySelector | undefined\n): boolean => {\n  const segments = compositeId.split(COMPOSITE_ID_SEPARATOR);\n\n  return qualifierTypes.every((qualifierType, index) => {\n    if (qualifierType === 'variant') {\n      return segments[index] === serializeVariant(selector?.variant);\n    }\n\n    // qualifierType === 'item'\n    return (\n      selector?.item === undefined || segments[index] === String(selector.item)\n    );\n  });\n};\n\n/**\n * Type guard discriminating a `QualifiedDictionaryGroup` (merge output of a\n * qualified key) from a plain `Dictionary`. Both carry a `content` field; only\n * the group declares `qualifierTypes`, which is therefore the discriminator.\n */\nexport const isQualifiedDictionaryGroup = (\n  value: unknown\n): value is QualifiedDictionaryGroup =>\n  typeof value === 'object' &&\n  value !== null &&\n  'qualifierTypes' in value &&\n  Array.isArray((value as { qualifierTypes: unknown }).qualifierTypes) &&\n  'content' in value;\n\n/**\n * Reconstructs a resolvable {@link Dictionary} from a single entry of a\n * qualified group: the content node stored under its composite id, plus the\n * qualifier coordinates decoded from that id (`variant`, `item`).\n *\n * This keeps the resolver's transform code unchanged: it still sees a\n * `{ key, content, variant?, item? }` shape, even though the stored format no\n * longer duplicates those fields per entry. The `variant` coordinate stays in\n * its serialized (encoded) form, e.g. `'id=abc&userId=123'` — matching happens\n * on the composite id segments, never on this reconstructed field.\n */\nexport const reconstructQualifiedEntry = (\n  group: QualifiedDictionaryGroup,\n  compositeId: string\n): Dictionary => {\n  const segments = compositeId.split(COMPOSITE_ID_SEPARATOR);\n\n  const entry = {\n    key: group.key,\n    content: group.content[compositeId],\n  } as Dictionary;\n\n  group.qualifierTypes.forEach((qualifierType, index) => {\n    if (qualifierType === 'variant') {\n      entry.variant = segments[index];\n    } else if (qualifierType === 'item') {\n      entry.item = Number(segments[index]);\n    }\n  });\n\n  return entry;\n};\n\n/**\n * Resolves a dictionary (or qualified dictionary group) against a selector,\n * across every declared dimension.\n *\n * - Plain dictionary → returned as-is (selector ignored)\n * - `item` declared but not selected → every matching entry ordered by index\n * - `item` selected → the matching entry or null\n * - `variant` defaults to the `default` entry when not selected; an object\n *   variant resolves only when the selector provides an equal object\n *\n * Dimensions compose: e.g. a variant × item key with `{ variant: 'promo' }`\n * returns every promo item as an array; adding `{ item: 2 }` narrows to one.\n */\nexport const resolveQualifiedDictionary = (\n  dictionaryOrGroup: Dictionary | QualifiedDictionaryGroup,\n  selector?: DictionarySelector\n): Dictionary | Dictionary[] | null => {\n  if (!isQualifiedDictionaryGroup(dictionaryOrGroup)) {\n    return dictionaryOrGroup;\n  }\n\n  const { qualifierTypes, content } = dictionaryOrGroup;\n\n  const itemAxisOpen =\n    qualifierTypes.includes('item') && selector?.item === undefined;\n\n  const matchedEntries = Object.keys(content)\n    .filter((compositeId) =>\n      compositeIdMatchesSelector(compositeId, qualifierTypes, selector)\n    )\n    .map((compositeId) =>\n      reconstructQualifiedEntry(dictionaryOrGroup, compositeId)\n    );\n\n  if (itemAxisOpen) {\n    return matchedEntries.sort(\n      (left, right) => (left.item ?? 0) - (right.item ?? 0)\n    );\n  }\n\n  return matchedEntries[0] ?? null;\n};\n\n/**\n * Splits the second argument of `getIntlayer` / `getDictionary` into the\n * effective locale and the selector object (if any).\n */\nexport const parseDictionarySelector = <L extends LocalesValues>(\n  localeOrSelector?: L | DictionarySelector\n): { locale?: L; selector?: DictionarySelector } => {\n  if (typeof localeOrSelector === 'object' && localeOrSelector !== null) {\n    return {\n      locale: localeOrSelector.locale as L | undefined,\n      selector: localeOrSelector,\n    };\n  }\n\n  return { locale: localeOrSelector };\n};\n\n/**\n * Builds a stable string identity of a selector (excluding `locale`), suitable\n * for cache keys and memoization dependencies.\n */\nexport const getDictionarySelectorCacheKey = (\n  selector?: DictionarySelector\n): string => {\n  if (!selector) return '';\n\n  return Object.keys(selector)\n    .filter((selectorKey) => selectorKey !== 'locale')\n    .sort()\n    .map((selectorKey) => {\n      const value = selector[selectorKey as keyof DictionarySelector];\n      const serialized =\n        selectorKey === 'variant'\n          ? serializeVariant(value as Parameters<typeof serializeVariant>[0])\n          : String(value);\n      return `${selectorKey}:${serialized}`;\n    })\n    .join('|');\n};\n\n/**\n * Marker property carrying the ordered qualifier dimensions on a dynamic loader\n * map. Its presence distinguishes a qualified group loader map (a nested tree\n * of chunks) from a plain dynamic loader map (one chunk per `locale`). Prefixed\n * and unlikely to collide with a real locale code.\n */\nexport const QUALIFIER_DYNAMIC_TYPES_KEY = '__intlayerQualifierTypes';\n\n/**\n * A lazily-imported per-locale dictionary chunk loader.\n */\nexport type DynamicDictionaryLoader = () => Promise<Dictionary>;\n\n/**\n * Nested tree of chunk loaders: one nesting level per declared dimension (in\n * canonical order), leaves are loaders.\n */\nexport type QualifiedDynamicLoaderTree = {\n  [segment: string]: QualifiedDynamicLoaderTree | DynamicDictionaryLoader;\n};\n\n/**\n * Default export shape of a generated dynamic entry point for a qualified key.\n * One nesting level per dimension under each locale, plus the dimension marker.\n *\n * ```ts\n * {\n *   __intlayerQualifierTypes: ['variant', 'item'],\n *   en: { promo: { '1': () => import('./json/x/promo/1/en.json'), … }, … },\n *   fr: { … },\n * }\n * ```\n */\nexport type QualifiedDynamicLoaderMap = {\n  [QUALIFIER_DYNAMIC_TYPES_KEY]: DictionaryQualifierType[];\n  [locale: string]: QualifiedDynamicLoaderTree | DictionaryQualifierType[];\n};\n\n/**\n * Type guard discriminating a qualified dynamic loader map (collections /\n * variants, possibly combined) from a plain dynamic loader map.\n */\nexport const isQualifiedDynamicLoaderMap = (\n  value: unknown\n): value is QualifiedDynamicLoaderMap =>\n  typeof value === 'object' &&\n  value !== null &&\n  QUALIFIER_DYNAMIC_TYPES_KEY in value;\n\n/**\n/** One targeted chunk: its stable cache key and lazy loader. */\ntype CollectedChunk = {\n  cacheKey: string;\n  loader: DynamicDictionaryLoader;\n};\n\ntype CollectedChunks = {\n  /** True when the `item` axis is open (collection result → array). */\n  itemAxisOpen: boolean;\n  /** True when a required coordinate is absent (result → [] or null). */\n  missed: boolean;\n  /** The chunks the selector targets (in collection order for the item axis). */\n  chunks: CollectedChunk[];\n};\n\n/**\n * Walks the loader tree following the selector and collects the chunk loaders\n * it targets — shared by the sync ({@link resolveQualifiedDynamicContent}) and\n * async ({@link resolveQualifiedDynamicContentAsync}) resolvers.\n */\nconst collectQualifiedChunks = (\n  loaderMap: QualifiedDynamicLoaderMap,\n  key: string,\n  locale: string,\n  selector: DictionarySelector | undefined\n): CollectedChunks => {\n  const qualifierTypes = loaderMap[QUALIFIER_DYNAMIC_TYPES_KEY];\n  const localeTree = loaderMap[locale] as\n    | QualifiedDynamicLoaderTree\n    | undefined;\n\n  const itemAxisOpen =\n    qualifierTypes.includes('item') && selector?.item === undefined;\n\n  if (!localeTree) return { itemAxisOpen, missed: true, chunks: [] };\n\n  const chunks: CollectedChunk[] = [];\n\n  const walk = (\n    node: QualifiedDynamicLoaderTree | DynamicDictionaryLoader,\n    dimensions: DictionaryQualifierType[],\n    segments: string[]\n  ): boolean => {\n    if (dimensions.length === 0) {\n      chunks.push({\n        cacheKey: `${key}.${locale}.${segments.join(COMPOSITE_ID_SEPARATOR)}`,\n        loader: node as DynamicDictionaryLoader,\n      });\n      return true;\n    }\n\n    const [dimension, ...rest] = dimensions;\n    const tree = node as QualifiedDynamicLoaderTree;\n\n    if (dimension === 'item' && selector?.item === undefined) {\n      // Open collection axis: fan out into every sibling chunk, ordered.\n      for (const segment of Object.keys(tree).sort(\n        (left, right) => Number(left) - Number(right)\n      )) {\n        walk(tree[segment]!, rest, [...segments, segment]);\n      }\n      return true;\n    }\n\n    const segment =\n      dimension === 'variant'\n        ? serializeVariant(selector?.variant)\n        : String(selector?.item);\n\n    const child = tree[segment];\n    if (!child) return false;\n\n    return walk(child, rest, [...segments, segment]);\n  };\n\n  const found = walk(localeTree, qualifierTypes, []);\n\n  return { itemAxisOpen, missed: !found, chunks };\n};\n\n/**\n * Resolves the content of a qualified dynamic loader map against a selector,\n * loading only the chunk(s) the selector actually targets.\n *\n * Walks the nested loader tree one dimension at a time (canonical order\n * `variant → item`): `variant` defaults to `default` (or descends by the\n * serialized object identity), and `item` either narrows to the selected index\n * or — when no item is given — expands into every sibling chunk (the collection\n * axis). Semantics mirror {@link resolveQualifiedDictionary} so dynamic and\n * static modes behave alike.\n *\n * The Suspense mechanism is injected through `loadChunk` so the same logic\n * serves both the client (suspender cache) and the server (`react.use`). Every\n * targeted loader is started before the first chunk is read, so sibling chunks\n * load in parallel rather than waterfalling.\n *\n * @param loaderMap - The qualified dynamic loader map (entry point default export).\n * @param key - The dictionary key (used to build stable chunk cache keys).\n * @param locale - The resolved locale to load chunks for.\n * @param selector - The selector splitting the qualifier dimensions.\n * @param loadChunk - Reads a started chunk promise, suspending until it resolves.\n * @param transform - Turns a resolved chunk dictionary into final content.\n */\nexport const resolveQualifiedDynamicContent = <Content>(params: {\n  loaderMap: QualifiedDynamicLoaderMap;\n  key: string;\n  locale: string;\n  selector: DictionarySelector | undefined;\n  loadChunk: (cacheKey: string, promise: Promise<Dictionary>) => Dictionary;\n  transform: (dictionary: Dictionary) => Content;\n}): Content | Content[] | null => {\n  const { loaderMap, key, locale, selector, loadChunk, transform } = params;\n\n  const { itemAxisOpen, missed, chunks } = collectQualifiedChunks(\n    loaderMap,\n    key,\n    locale,\n    selector\n  );\n\n  if (missed) return itemAxisOpen ? [] : null;\n\n  // Start every loader before reading, so siblings load in parallel.\n  const dictionaries = chunks.map(({ cacheKey, loader }) =>\n    loadChunk(cacheKey, loader())\n  );\n\n  if (itemAxisOpen) return dictionaries.map(transform);\n\n  const [dictionary] = dictionaries;\n  return dictionary ? transform(dictionary) : null;\n};\n\n/**\n * Async counterpart of {@link resolveQualifiedDynamicContent} for frameworks\n * that load dictionaries with `await` instead of Suspense (Vue, Svelte, Lit,\n * vanilla). Awaits every targeted chunk in parallel, then resolves identically.\n *\n * @param loaderMap - The qualified dynamic loader map.\n * @param key - The dictionary key (used to build stable chunk cache keys).\n * @param locale - The resolved locale to load chunks for.\n * @param selector - The selector splitting the qualifier dimensions.\n * @param transform - Turns a resolved chunk dictionary into final content.\n */\nexport const resolveQualifiedDynamicContentAsync = async <Content>(params: {\n  loaderMap: QualifiedDynamicLoaderMap;\n  key: string;\n  locale: string;\n  selector: DictionarySelector | undefined;\n  transform: (dictionary: Dictionary) => Content;\n}): Promise<Content | Content[] | null> => {\n  const { loaderMap, key, locale, selector, transform } = params;\n\n  const { itemAxisOpen, missed, chunks } = collectQualifiedChunks(\n    loaderMap,\n    key,\n    locale,\n    selector\n  );\n\n  if (missed) return itemAxisOpen ? [] : null;\n\n  const dictionaries = await Promise.all(chunks.map(({ loader }) => loader()));\n\n  if (itemAxisOpen) return dictionaries.map(transform);\n\n  const [dictionary] = dictionaries;\n  return dictionary ? transform(dictionary) : null;\n};\n"],"mappings":"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"}
+{"version":3,"file":"qualifiedDictionary.mjs","names":[],"sources":["../../../src/dictionaryManipulator/qualifiedDictionary.ts"],"sourcesContent":["import type {\n  Dictionary,\n  DictionaryQualifierType,\n  DictionarySelector,\n  DictionaryVariantChain,\n  DictionaryVariantValue,\n  ProviderVariant,\n  ProviderVariantMap,\n  QualifiedDictionaryGroup,\n} from '@intlayer/types/dictionary';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\n\n/**\n * Canonical order of qualifier dimensions. A key that declares both dimensions\n * always nests them in this order, with `item` innermost so it can act as the\n * collection (array) axis.\n */\nexport const QUALIFIER_ORDER = [\n  'variant',\n  'item',\n] as const satisfies readonly DictionaryQualifierType[];\n\n/**\n * Separator joining per-dimension ids into a composite entry id. Also used as\n * the chunk path separator in dynamic mode.\n */\nexport const COMPOSITE_ID_SEPARATOR = '/';\n\n/**\n * Identity of the implicit fallback variant. A selector that pins no variant\n * resolves to it, and a variant that declares no entry of its own falls back to\n * it — so a key only has to ship the entries that actually differ.\n */\nexport const DEFAULT_VARIANT_ID = 'default';\n\n/**\n * Characters kept verbatim in an encoded qualifier segment. Everything else is\n * percent-encoded so a segment can never contain the composite-id separator\n * (`/`), path-hostile characters (`\\` `:` `*` `?` `\"` `<` `>` `|`, control\n * chars), or characters that would break the generated loader modules (`'`).\n */\nconst SEGMENT_UNSAFE_CHARS = /[^A-Za-z0-9._&=-]/g;\n\n/**\n * Stricter set for the components of an object variant: also encodes `&` and\n * `=` so the `field=value&field=value` serialization stays unambiguous.\n */\nconst COMPONENT_UNSAFE_CHARS = /[^A-Za-z0-9._-]/g;\n\n/** Percent-encodes one UTF-16 code unit as a fixed-width `%XXXX` run. */\nconst percentEncodeChar = (char: string): string =>\n  `%${char.charCodeAt(0).toString(16).toUpperCase().padStart(4, '0')}`;\n\nconst encodeSegmentText = (raw: string, unsafeChars: RegExp): string => {\n  // Bare '%' cannot be produced by encoding (every encoded run is %XXXX),\n  // so it is a safe stand-in for the empty string.\n  if (raw === '') return '%';\n\n  const encoded = raw.replace(unsafeChars, percentEncodeChar);\n\n  // '.' and '..' are path navigation on every filesystem — encode the dots.\n  if (encoded === '.' || encoded === '..') {\n    return encoded.replace(/\\./g, '%002E');\n  }\n\n  return encoded;\n};\n\n/**\n * Canonical serialization of a single variant value into its identity string —\n * the variant segment of a composite id, the chunk directory name in dynamic\n * mode, and the runtime matching key.\n *\n * - `undefined` → `'default'` (the implicit fallback variant)\n * - a string → the string itself (a named variant)\n * - an object → its sorted `key=value` pairs joined by `&`\n *   (e.g. `{ userId: '123', id: 'abc' }` → `'id=abc&userId=123'`)\n *\n * Characters that are unsafe in file paths or generated code are\n * percent-encoded (fixed-width `%XXXX` runs, injective). Common names —\n * letters, digits, `-` `_` `.` — are left untouched. Both the declaration and\n * the selector go through this function, so encoding never affects matching.\n *\n * Two variants resolve to the same entry iff their serializations are equal, so\n * an object variant in a selector must equal the one declared on the dictionary.\n */\nexport const serializeVariant = (\n  variant: DictionaryVariantValue | undefined\n): string => {\n  if (variant === undefined) return DEFAULT_VARIANT_ID;\n  if (typeof variant === 'string') {\n    return encodeSegmentText(variant, SEGMENT_UNSAFE_CHARS);\n  }\n\n  return Object.keys(variant)\n    .sort()\n    .map(\n      (field) =>\n        `${encodeSegmentText(field, COMPONENT_UNSAFE_CHARS)}=${encodeSegmentText(String(variant[field]), COMPONENT_UNSAFE_CHARS)}`\n    )\n    .join('&');\n};\n\n/**\n * Normalizes the `variant` field of a dictionary into the list of variant ids\n * the declaration registers under. A single value yields one id; an **array**\n * fans out into one id per element (duplicates collapsed). Returns `undefined`\n * when the dictionary does not declare the variant dimension (no `variant`\n * field, or an empty array).\n */\nexport const getVariantIds = (\n  variant: Dictionary['variant']\n): string[] | undefined => {\n  if (variant === undefined) return undefined;\n\n  const values = Array.isArray(variant) ? variant : [variant];\n  if (values.length === 0) return undefined;\n\n  return [...new Set(values.map(serializeVariant))];\n};\n\n/**\n * Returns the qualifier dimensions declared on a dictionary, in canonical\n * order (`variant → item`). Empty when the dictionary is unqualified\n * (plain dictionary or shared base content of a qualified group).\n */\nexport const getDictionaryQualifierTypes = (\n  dictionary: Dictionary\n): DictionaryQualifierType[] => {\n  const declaredQualifiers: DictionaryQualifierType[] = [];\n\n  if (getVariantIds(dictionary.variant) !== undefined) {\n    declaredQualifiers.push('variant');\n  }\n  if (typeof dictionary.item === 'number') declaredQualifiers.push('item');\n\n  return declaredQualifiers;\n};\n\n/**\n * Returns the qualifier identifiers of a dictionary for the given qualifier\n * dimension — the candidate segments of the composite entry ids.\n *\n * - 'variant' → the serialized variant id(s); an array variant yields one id\n *   per element (declaration-side fan-out)\n * - 'item' → the item index as a single-element list\n */\nexport const getDictionaryQualifierIds = (\n  dictionary: Dictionary,\n  qualifierType: DictionaryQualifierType\n): string[] | undefined => {\n  if (qualifierType === 'variant') {\n    return getVariantIds(dictionary.variant);\n  }\n  return dictionary.item === undefined ? undefined : [String(dictionary.item)];\n};\n\n/**\n * Builds every composite entry id of a dictionary — the cartesian product of\n * its per-dimension id lists, joined in canonical order. A dictionary with a\n * plain (non-array) variant yields exactly one id; an array variant fans out\n * into one id per element. `undefined` when a dimension of the set is missing.\n */\nexport const getDictionaryCompositeIds = (\n  dictionary: Dictionary,\n  qualifierTypes: DictionaryQualifierType[]\n): string[] | undefined => {\n  let compositeIds: string[] = [''];\n\n  for (const qualifierType of qualifierTypes) {\n    const ids = getDictionaryQualifierIds(dictionary, qualifierType);\n    if (ids === undefined) return undefined;\n\n    compositeIds = compositeIds.flatMap((prefix) =>\n      ids.map((id) =>\n        prefix === '' ? id : `${prefix}${COMPOSITE_ID_SEPARATOR}${id}`\n      )\n    );\n  }\n\n  return compositeIds;\n};\n\n/**\n * Serializes the variant coordinate of a selector into the ordered list of\n * candidate ids to try, so a single value and a preference chain share one code\n * path downstream.\n *\n * - `undefined` → `['default']`\n * - a single value → its one serialization\n * - a chain → one serialization per entry, order preserved\n *\n * An empty chain is treated as \"no variant pinned\" (`['default']`) rather than\n * as an unsatisfiable request.\n */\nexport const serializeVariantChain = (\n  variant: DictionaryVariantChain | undefined\n): string[] => {\n  if (!Array.isArray(variant)) {\n    return [serializeVariant(variant as DictionaryVariantValue | undefined)];\n  }\n\n  if (variant.length === 0) return [DEFAULT_VARIANT_ID];\n\n  return variant.map(serializeVariant);\n};\n\n/**\n * Resolves the variant id a selector actually targets among the ids a key\n * declares — the sparse-override fallback.\n *\n * Candidates are tried in order and the first one the key declares wins.\n * Otherwise the key falls back to its `default` entry, so a variant only has to\n * be declared where its wording differs. When the key declares no `default`\n * either, the first candidate is returned unchanged and the caller resolves to\n * `null` / `[]`.\n *\n * @param requestedVariantIds - The serialized ids the selector asks for, in\n *                              preference order (a single value is a 1-element\n *                              list).\n * @param isVariantIdDeclared - Whether the key declares an entry for an id.\n */\nconst resolveEffectiveVariantId = (\n  requestedVariantIds: string[],\n  isVariantIdDeclared: (variantId: string) => boolean\n): string => {\n  for (const requestedVariantId of requestedVariantIds) {\n    if (isVariantIdDeclared(requestedVariantId)) return requestedVariantId;\n  }\n\n  return isVariantIdDeclared(DEFAULT_VARIANT_ID)\n    ? DEFAULT_VARIANT_ID\n    : (requestedVariantIds[0] ?? DEFAULT_VARIANT_ID);\n};\n\n/**\n * Tests whether a composite entry id matches a selector across every declared\n * dimension. Segments are compared in their encoded form (both the stored id\n * and the selector go through {@link serializeVariant}). The `item` dimension\n * matches any value when the selector does not provide one (open collection\n * axis); the `variant` dimension is compared against the already-resolved\n * effective id, so the fallback is applied consistently across dimensions.\n */\nconst compositeIdMatchesSelector = (\n  compositeId: string,\n  qualifierTypes: DictionaryQualifierType[],\n  selector: DictionarySelector | undefined,\n  effectiveVariantId: string\n): boolean => {\n  const segments = compositeId.split(COMPOSITE_ID_SEPARATOR);\n\n  return qualifierTypes.every((qualifierType, index) => {\n    if (qualifierType === 'variant') {\n      return segments[index] === effectiveVariantId;\n    }\n\n    // qualifierType === 'item'\n    return (\n      selector?.item === undefined || segments[index] === String(selector.item)\n    );\n  });\n};\n\n/**\n * Type guard discriminating a `QualifiedDictionaryGroup` (merge output of a\n * qualified key) from a plain `Dictionary`. Both carry a `content` field; only\n * the group declares `qualifierTypes`, which is therefore the discriminator.\n */\nexport const isQualifiedDictionaryGroup = (\n  value: unknown\n): value is QualifiedDictionaryGroup =>\n  typeof value === 'object' &&\n  value !== null &&\n  'qualifierTypes' in value &&\n  Array.isArray((value as { qualifierTypes: unknown }).qualifierTypes) &&\n  'content' in value;\n\n/**\n * Reconstructs a resolvable {@link Dictionary} from a single entry of a\n * qualified group: the content node stored under its composite id, plus the\n * qualifier coordinates decoded from that id (`variant`, `item`).\n *\n * This keeps the resolver's transform code unchanged: it still sees a\n * `{ key, content, variant?, item? }` shape, even though the stored format no\n * longer duplicates those fields per entry. The `variant` coordinate stays in\n * its serialized (encoded) form, e.g. `'id=abc&userId=123'` — matching happens\n * on the composite id segments, never on this reconstructed field.\n */\nexport const reconstructQualifiedEntry = (\n  group: QualifiedDictionaryGroup,\n  compositeId: string\n): Dictionary => {\n  const segments = compositeId.split(COMPOSITE_ID_SEPARATOR);\n\n  const entry = {\n    key: group.key,\n    content: group.content[compositeId],\n  } as Dictionary;\n\n  group.qualifierTypes.forEach((qualifierType, index) => {\n    if (qualifierType === 'variant') {\n      entry.variant = segments[index];\n    } else if (qualifierType === 'item') {\n      entry.item = Number(segments[index]);\n    }\n  });\n\n  return entry;\n};\n\n/**\n * Resolves a dictionary (or qualified dictionary group) against a selector,\n * across every declared dimension.\n *\n * - Plain dictionary → returned as-is (selector ignored)\n * - `item` declared but not selected → every matching entry ordered by index\n * - `item` selected → the matching entry or null\n * - `variant` defaults to the `default` entry when not selected, and falls back\n *   to it when the selected variant declares no entry of its own; an object\n *   variant resolves only when the selector provides an equal object (or, again,\n *   through the `default` fallback)\n *\n * Dimensions compose: e.g. a variant × item key with `{ variant: 'promo' }`\n * returns every promo item as an array; adding `{ item: 2 }` narrows to one.\n */\nexport const resolveQualifiedDictionary = (\n  dictionaryOrGroup: Dictionary | QualifiedDictionaryGroup,\n  selector?: DictionarySelector\n): Dictionary | Dictionary[] | null => {\n  if (!isQualifiedDictionaryGroup(dictionaryOrGroup)) {\n    return dictionaryOrGroup;\n  }\n\n  const { qualifierTypes, content } = dictionaryOrGroup;\n\n  const itemAxisOpen =\n    qualifierTypes.includes('item') && selector?.item === undefined;\n\n  const compositeIds = Object.keys(content);\n  const variantIndex = qualifierTypes.indexOf('variant');\n\n  const effectiveVariantId =\n    variantIndex === -1\n      ? DEFAULT_VARIANT_ID\n      : resolveEffectiveVariantId(\n          serializeVariantChain(selector?.variant),\n          (variantId) =>\n            compositeIds.some(\n              (compositeId) =>\n                compositeId.split(COMPOSITE_ID_SEPARATOR)[variantIndex] ===\n                variantId\n            )\n        );\n\n  const matchedEntries = compositeIds\n    .filter((compositeId) =>\n      compositeIdMatchesSelector(\n        compositeId,\n        qualifierTypes,\n        selector,\n        effectiveVariantId\n      )\n    )\n    .map((compositeId) =>\n      reconstructQualifiedEntry(dictionaryOrGroup, compositeId)\n    );\n\n  if (itemAxisOpen) {\n    return matchedEntries.sort(\n      (left, right) => (left.item ?? 0) - (right.item ?? 0)\n    );\n  }\n\n  return matchedEntries[0] ?? null;\n};\n\n/**\n * Splits the second argument of `getIntlayer` / `getDictionary` into the\n * effective locale and the selector object (if any).\n */\nexport const parseDictionarySelector = <L extends LocalesValues>(\n  localeOrSelector?: L | DictionarySelector\n): { locale?: L; selector?: DictionarySelector } => {\n  if (typeof localeOrSelector === 'object' && localeOrSelector !== null) {\n    return {\n      locale: localeOrSelector.locale as L | undefined,\n      selector: localeOrSelector,\n    };\n  }\n\n  return { locale: localeOrSelector };\n};\n\n/**\n * Resolves the variant a provider pins for one dictionary key.\n *\n * A string or a chain applies to every key as-is. A plain object is the per-key\n * map: the entry for `dictionaryKey` wins, falling back to the reserved\n * `default` entry, and `undefined` when neither is present (the key then\n * resolves to its own `default` variant, i.e. the behaviour without a provider\n * variant at all).\n *\n * A plain object is **always** the map here — never a structured variant value,\n * which is why a structured variant has to be nested (`{ default: { id } }`).\n *\n * @param providerVariant - The `variant` prop of the surrounding provider.\n * @param dictionaryKey - The key being read.\n */\nexport const resolveProviderVariant = (\n  providerVariant: ProviderVariant | undefined,\n  dictionaryKey: string\n): DictionaryVariantChain | undefined => {\n  if (providerVariant === undefined) return undefined;\n\n  if (typeof providerVariant === 'string' || Array.isArray(providerVariant)) {\n    return providerVariant as DictionaryVariantChain;\n  }\n\n  const variantMap = providerVariant as ProviderVariantMap;\n\n  return variantMap[dictionaryKey] ?? variantMap[DEFAULT_VARIANT_ID];\n};\n\n/**\n * Builds the effective second argument of a dictionary read by layering the\n * provider defaults under the call-site one — the single place the `locale` and\n * `variant` context defaults are applied, shared by every framework binding.\n *\n * Precedence, per dimension independently:\n * - a call-site selector always wins; `{ variant: 'x' }` **replaces** the\n *   provider chain rather than extending it\n * - otherwise the provider value applies\n *\n * Returns a bare locale (not a selector object) whenever no variant is in play,\n * so the existing fast path — and the cache keys built from it — are unchanged\n * for projects that never use variants.\n */\nexport const resolveDictionaryArgument = (params: {\n  localeOrSelector?: LocalesValues | DictionarySelector;\n  contextLocale?: LocalesValues;\n  contextVariant?: ProviderVariant;\n  dictionaryKey: string;\n}): LocalesValues | DictionarySelector | undefined => {\n  const { localeOrSelector, contextLocale, contextVariant, dictionaryKey } =\n    params;\n\n  const callSelector =\n    typeof localeOrSelector === 'object' && localeOrSelector !== null\n      ? localeOrSelector\n      : undefined;\n\n  const callLocale = callSelector\n    ? callSelector.locale\n    : (localeOrSelector as LocalesValues | undefined);\n\n  // The context locale is typed as widely as the runtime allows, while a\n  // selector narrows `locale` to the declared ones — the value is the same.\n  const locale = (callLocale ?? contextLocale) as DictionarySelector['locale'];\n\n  // A call-site variant is authoritative; the provider only fills the gap.\n  const variant =\n    callSelector?.variant ??\n    resolveProviderVariant(contextVariant, dictionaryKey);\n\n  if (variant === undefined) {\n    // Nothing to add: keep the argument in its original shape so the identity\n    // built from it stays byte-identical to the pre-variant behaviour.\n    return callSelector\n      ? { ...callSelector, locale }\n      : (locale as LocalesValues | undefined);\n  }\n\n  return { ...callSelector, locale, variant };\n};\n\n/**\n * Builds a stable string identity of a selector (excluding `locale`), suitable\n * for cache keys and memoization dependencies.\n */\nexport const getDictionarySelectorCacheKey = (\n  selector?: DictionarySelector\n): string => {\n  if (!selector) return '';\n\n  return Object.keys(selector)\n    .filter((selectorKey) => selectorKey !== 'locale')\n    .sort()\n    .map((selectorKey) => {\n      const value = selector[selectorKey as keyof DictionarySelector];\n      const serialized =\n        selectorKey === 'variant'\n          ? serializeVariantChain(\n              value as DictionaryVariantChain | undefined\n            ).join(',')\n          : String(value);\n      return `${selectorKey}:${serialized}`;\n    })\n    .join('|');\n};\n\n/**\n * Marker property carrying the ordered qualifier dimensions on a dynamic loader\n * map. Its presence distinguishes a qualified group loader map (a nested tree\n * of chunks) from a plain dynamic loader map (one chunk per `locale`). Prefixed\n * and unlikely to collide with a real locale code.\n */\nexport const QUALIFIER_DYNAMIC_TYPES_KEY = '__intlayerQualifierTypes';\n\n/**\n * A lazily-imported per-locale dictionary chunk loader.\n */\nexport type DynamicDictionaryLoader = () => Promise<Dictionary>;\n\n/**\n * Nested tree of chunk loaders: one nesting level per declared dimension (in\n * canonical order), leaves are loaders.\n */\nexport type QualifiedDynamicLoaderTree = {\n  [segment: string]: QualifiedDynamicLoaderTree | DynamicDictionaryLoader;\n};\n\n/**\n * Default export shape of a generated dynamic entry point for a qualified key.\n * One nesting level per dimension under each locale, plus the dimension marker.\n *\n * ```ts\n * {\n *   __intlayerQualifierTypes: ['variant', 'item'],\n *   en: { promo: { '1': () => import('./json/x/promo/1/en.json'), … }, … },\n *   fr: { … },\n * }\n * ```\n */\nexport type QualifiedDynamicLoaderMap = {\n  [QUALIFIER_DYNAMIC_TYPES_KEY]: DictionaryQualifierType[];\n  [locale: string]: QualifiedDynamicLoaderTree | DictionaryQualifierType[];\n};\n\n/**\n * Type guard discriminating a qualified dynamic loader map (collections /\n * variants, possibly combined) from a plain dynamic loader map.\n */\nexport const isQualifiedDynamicLoaderMap = (\n  value: unknown\n): value is QualifiedDynamicLoaderMap =>\n  typeof value === 'object' &&\n  value !== null &&\n  QUALIFIER_DYNAMIC_TYPES_KEY in value;\n\n/**\n/** One targeted chunk: its stable cache key and lazy loader. */\ntype CollectedChunk = {\n  cacheKey: string;\n  loader: DynamicDictionaryLoader;\n};\n\ntype CollectedChunks = {\n  /** True when the `item` axis is open (collection result → array). */\n  itemAxisOpen: boolean;\n  /** True when a required coordinate is absent (result → [] or null). */\n  missed: boolean;\n  /** The chunks the selector targets (in collection order for the item axis). */\n  chunks: CollectedChunk[];\n};\n\n/**\n * Walks the loader tree following the selector and collects the chunk loaders\n * it targets — shared by the sync ({@link resolveQualifiedDynamicContent}) and\n * async ({@link resolveQualifiedDynamicContentAsync}) resolvers.\n */\nconst collectQualifiedChunks = (\n  loaderMap: QualifiedDynamicLoaderMap,\n  key: string,\n  locale: string,\n  selector: DictionarySelector | undefined\n): CollectedChunks => {\n  const qualifierTypes = loaderMap[QUALIFIER_DYNAMIC_TYPES_KEY];\n  const localeTree = loaderMap[locale] as\n    | QualifiedDynamicLoaderTree\n    | undefined;\n\n  const itemAxisOpen =\n    qualifierTypes.includes('item') && selector?.item === undefined;\n\n  if (!localeTree) return { itemAxisOpen, missed: true, chunks: [] };\n\n  const chunks: CollectedChunk[] = [];\n\n  const walk = (\n    node: QualifiedDynamicLoaderTree | DynamicDictionaryLoader,\n    dimensions: DictionaryQualifierType[],\n    segments: string[]\n  ): boolean => {\n    if (dimensions.length === 0) {\n      chunks.push({\n        cacheKey: `${key}.${locale}.${segments.join(COMPOSITE_ID_SEPARATOR)}`,\n        loader: node as DynamicDictionaryLoader,\n      });\n      return true;\n    }\n\n    const [dimension, ...rest] = dimensions;\n    const tree = node as QualifiedDynamicLoaderTree;\n\n    if (dimension === 'item' && selector?.item === undefined) {\n      // Open collection axis: fan out into every sibling chunk, ordered.\n      for (const segment of Object.keys(tree).sort(\n        (left, right) => Number(left) - Number(right)\n      )) {\n        walk(tree[segment]!, rest, [...segments, segment]);\n      }\n      return true;\n    }\n\n    // A variant with no chunk of its own falls back to the `default` chunk, so\n    // only the entries that actually differ need to be emitted.\n    const segment =\n      dimension === 'variant'\n        ? resolveEffectiveVariantId(\n            serializeVariantChain(selector?.variant),\n            (variantId) => tree[variantId] !== undefined\n          )\n        : String(selector?.item);\n\n    const child = tree[segment];\n    if (!child) return false;\n\n    return walk(child, rest, [...segments, segment]);\n  };\n\n  const found = walk(localeTree, qualifierTypes, []);\n\n  return { itemAxisOpen, missed: !found, chunks };\n};\n\n/**\n * Resolves the content of a qualified dynamic loader map against a selector,\n * loading only the chunk(s) the selector actually targets.\n *\n * Walks the nested loader tree one dimension at a time (canonical order\n * `variant → item`): `variant` descends by the serialized id, falling back to\n * `default` when the selected variant has no chunk of its own, and `item`\n * either narrows to the selected index or — when no item is given — expands\n * into every sibling chunk (the collection axis). Semantics mirror\n * {@link resolveQualifiedDictionary} so dynamic and static modes behave alike.\n *\n * The Suspense mechanism is injected through `loadChunk` so the same logic\n * serves both the client (suspender cache) and the server (`react.use`). Every\n * targeted loader is started before the first chunk is read, so sibling chunks\n * load in parallel rather than waterfalling.\n *\n * @param loaderMap - The qualified dynamic loader map (entry point default export).\n * @param key - The dictionary key (used to build stable chunk cache keys).\n * @param locale - The resolved locale to load chunks for.\n * @param selector - The selector splitting the qualifier dimensions.\n * @param loadChunk - Reads a started chunk promise, suspending until it resolves.\n * @param transform - Turns a resolved chunk dictionary into final content.\n */\nexport const resolveQualifiedDynamicContent = <Content>(params: {\n  loaderMap: QualifiedDynamicLoaderMap;\n  key: string;\n  locale: string;\n  selector: DictionarySelector | undefined;\n  loadChunk: (cacheKey: string, promise: Promise<Dictionary>) => Dictionary;\n  transform: (dictionary: Dictionary) => Content;\n}): Content | Content[] | null => {\n  const { loaderMap, key, locale, selector, loadChunk, transform } = params;\n\n  const { itemAxisOpen, missed, chunks } = collectQualifiedChunks(\n    loaderMap,\n    key,\n    locale,\n    selector\n  );\n\n  if (missed) return itemAxisOpen ? [] : null;\n\n  // Start every loader before reading, so siblings load in parallel.\n  const dictionaries = chunks.map(({ cacheKey, loader }) =>\n    loadChunk(cacheKey, loader())\n  );\n\n  if (itemAxisOpen) return dictionaries.map(transform);\n\n  const [dictionary] = dictionaries;\n  return dictionary ? transform(dictionary) : null;\n};\n\n/**\n * Async counterpart of {@link resolveQualifiedDynamicContent} for frameworks\n * that load dictionaries with `await` instead of Suspense (Vue, Svelte, Lit,\n * vanilla). Awaits every targeted chunk in parallel, then resolves identically.\n *\n * @param loaderMap - The qualified dynamic loader map.\n * @param key - The dictionary key (used to build stable chunk cache keys).\n * @param locale - The resolved locale to load chunks for.\n * @param selector - The selector splitting the qualifier dimensions.\n * @param transform - Turns a resolved chunk dictionary into final content.\n */\nexport const resolveQualifiedDynamicContentAsync = async <Content>(params: {\n  loaderMap: QualifiedDynamicLoaderMap;\n  key: string;\n  locale: string;\n  selector: DictionarySelector | undefined;\n  transform: (dictionary: Dictionary) => Content;\n}): Promise<Content | Content[] | null> => {\n  const { loaderMap, key, locale, selector, transform } = params;\n\n  const { itemAxisOpen, missed, chunks } = collectQualifiedChunks(\n    loaderMap,\n    key,\n    locale,\n    selector\n  );\n\n  if (missed) return itemAxisOpen ? [] : null;\n\n  const dictionaries = await Promise.all(chunks.map(({ loader }) => loader()));\n\n  if (itemAxisOpen) return dictionaries.map(transform);\n\n  const [dictionary] = dictionaries;\n  return dictionary ? transform(dictionary) : null;\n};\n"],"mappings":"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"}

package/dist/esm/dictionaryManipulator/qualifiedDictionary.test-d.mjs

@@ -0,0 +1,92 @@
+import { describe, expectTypeOf, it } from "vitest";
+
+//#region src/dictionaryManipulator/qualifiedDictionary.test-d.ts
+describe("ResolveQualifiedDictionaryContent", () => {
+	it("should resolve a plain dictionary to its content, ignoring the selector", () => {
+		expectTypeOf().toEqualTypeOf();
+	});
+	describe("variant", () => {
+		it("should resolve to the default entry when no variant is selected", () => {
+			expectTypeOf().toEqualTypeOf();
+		});
+		it("should resolve a locale-only selector like no selector", () => {
+			expectTypeOf().toEqualTypeOf();
+		});
+		it("should resolve a declared variant to its own entry", () => {
+			expectTypeOf().toEqualTypeOf();
+		});
+		it("should fall back to the default entry for an undeclared variant", () => {
+			expectTypeOf().toEqualTypeOf();
+		});
+		it("should resolve to null when no default entry is declared", () => {
+			expectTypeOf().toEqualTypeOf();
+		});
+		it("should resolve an object variant to its entry", () => {
+			expectTypeOf().toEqualTypeOf();
+		});
+		it("should resolve to null when an object-variant key has no default", () => {
+			expectTypeOf().toEqualTypeOf();
+		});
+	});
+	describe("item", () => {
+		it("should resolve to an array of every item when the axis is left open", () => {
+			expectTypeOf().toEqualTypeOf();
+		});
+		it("should narrow to the selected item", () => {
+			expectTypeOf().toEqualTypeOf();
+		});
+	});
+	describe("composite (variant × item)", () => {
+		it("should narrow to a single entry when both dimensions are pinned", () => {
+			expectTypeOf().toEqualTypeOf();
+		});
+		it("should fan the item axis out for the selected variant", () => {
+			expectTypeOf().toEqualTypeOf();
+		});
+		it("should fall back to the default variant then fan out its items", () => {
+			expectTypeOf().toEqualTypeOf();
+		});
+	});
+});
+describe("DictionarySelectorForGroup", () => {
+	it("should accept a variant this key declares", () => {
+		expectTypeOf().toExtend();
+	});
+	it("should accept a variant declared elsewhere in the project", () => {
+		expectTypeOf().toExtend();
+	});
+	it("should reject a variant no dictionary declares", () => {
+		expectTypeOf().not.toExtend();
+	});
+	it("should reject an object variant on a key that declares none", () => {
+		expectTypeOf().not.toExtend();
+	});
+	describe("object variants", () => {
+		it("should accept the object the key declares", () => {
+			expectTypeOf().toExtend();
+		});
+		it("should reject the serialized form as a string", () => {
+			expectTypeOf().not.toExtend();
+		});
+		it("should reject a partial or mismatched object", () => {
+			expectTypeOf().not.toExtend();
+			expectTypeOf().not.toExtend();
+		});
+	});
+	it("should reject an undeclared locale", () => {
+		expectTypeOf().not.toExtend();
+	});
+});
+describe("DictionarySelectorForGroup — keys without a default entry", () => {
+	it("should reject a project variant on a key with no default entry", () => {
+		expectTypeOf().not.toExtend();
+		expectTypeOf().not.toExtend();
+		expectTypeOf().not.toExtend();
+	});
+	it("should still accept the names such a key declares itself", () => {
+		expectTypeOf().toExtend();
+	});
+});
+
+//#endregion
+//# sourceMappingURL=qualifiedDictionary.test-d.mjs.map

package/dist/esm/dictionaryManipulator/qualifiedDictionary.test-d.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"qualifiedDictionary.test-d.mjs","names":[],"sources":["../../../src/dictionaryManipulator/qualifiedDictionary.test-d.ts"],"sourcesContent":["import type {\n  DictionarySelectorForGroup,\n  ResolveQualifiedDictionaryContent,\n} from '@intlayer/types/dictionary';\nimport { describe, expectTypeOf, it } from 'vitest';\n\n/**\n * Compile-time counterpart of `qualifiedDictionary.test.ts`. The runtime\n * resolver and `ResolveQualifiedDictionaryContent` implement the same rules\n * twice — once in value space, once in type space — so a divergence between\n * them is invisible to the runtime suite. These assertions pin the type side.\n *\n * Groups are written the way `createTypes` emits them (`as const`, hence\n * readonly tuples of qualifier dimensions and literal composite-id keys).\n */\n\ntype LessonGroup = {\n  key: 'lesson';\n  qualifierTypes: readonly ['variant'];\n  content: {\n    default: { title: 'Lesson'; teacher: 'Teacher' };\n    preschool: { title: 'Lesson'; teacher: 'Pedagogue' };\n  };\n};\n\ntype NoDefaultGroup = {\n  key: 'promoOnly';\n  qualifierTypes: readonly ['variant'];\n  content: { promo: { title: 'Promo' } };\n};\n\ntype BannerGroup = {\n  key: 'banner';\n  qualifierTypes: readonly ['variant', 'item'];\n  content: {\n    'default/1': { title: 'D1' };\n    'promo/1': { title: 'P1' };\n    'promo/2': { title: 'P2' };\n  };\n};\n\ntype FaqGroup = {\n  key: 'faq';\n  qualifierTypes: readonly ['item'];\n  content: { '1': { question: 'Q1' }; '2': { question: 'Q2' } };\n};\n\ntype ProductGroup = {\n  key: 'product';\n  qualifierTypes: readonly ['variant'];\n  content: { 'id=abc&userId=123': { name: 'ABC' } };\n};\n\ndescribe('ResolveQualifiedDictionaryContent', () => {\n  it('should resolve a plain dictionary to its content, ignoring the selector', () => {\n    expectTypeOf<\n      ResolveQualifiedDictionaryContent<{ key: 'home'; content: { a: 'b' } }>\n    >().toEqualTypeOf<{ a: 'b' }>();\n  });\n\n  describe('variant', () => {\n    it('should resolve to the default entry when no variant is selected', () => {\n      expectTypeOf<\n        ResolveQualifiedDictionaryContent<LessonGroup>\n      >().toEqualTypeOf<{ title: 'Lesson'; teacher: 'Teacher' }>();\n    });\n\n    it('should resolve a locale-only selector like no selector', () => {\n      expectTypeOf<\n        ResolveQualifiedDictionaryContent<LessonGroup, { locale: 'sv' }>\n      >().toEqualTypeOf<{ title: 'Lesson'; teacher: 'Teacher' }>();\n    });\n\n    it('should resolve a declared variant to its own entry', () => {\n      expectTypeOf<\n        ResolveQualifiedDictionaryContent<LessonGroup, { variant: 'preschool' }>\n      >().toEqualTypeOf<{ title: 'Lesson'; teacher: 'Pedagogue' }>();\n    });\n\n    it('should fall back to the default entry for an undeclared variant', () => {\n      expectTypeOf<\n        ResolveQualifiedDictionaryContent<\n          LessonGroup,\n          { variant: 'upperSecondary' }\n        >\n      >().toEqualTypeOf<{ title: 'Lesson'; teacher: 'Teacher' }>();\n    });\n\n    it('should resolve to null when no default entry is declared', () => {\n      expectTypeOf<\n        ResolveQualifiedDictionaryContent<\n          NoDefaultGroup,\n          { variant: 'unknown' }\n        >\n      >().toEqualTypeOf<null>();\n    });\n\n    it('should resolve an object variant to its entry', () => {\n      expectTypeOf<\n        ResolveQualifiedDictionaryContent<\n          ProductGroup,\n          { variant: { id: 'abc'; userId: '123' } }\n        >\n      >().toEqualTypeOf<{ name: 'ABC' }>();\n    });\n\n    it('should resolve to null when an object-variant key has no default', () => {\n      expectTypeOf<\n        ResolveQualifiedDictionaryContent<ProductGroup>\n      >().toEqualTypeOf<null>();\n    });\n  });\n\n  describe('item', () => {\n    it('should resolve to an array of every item when the axis is left open', () => {\n      expectTypeOf<ResolveQualifiedDictionaryContent<FaqGroup>>().toEqualTypeOf<\n        ({ question: 'Q1' } | { question: 'Q2' })[]\n      >();\n    });\n\n    it('should narrow to the selected item', () => {\n      expectTypeOf<\n        ResolveQualifiedDictionaryContent<FaqGroup, { item: 2 }>\n      >().toEqualTypeOf<{ question: 'Q2' }>();\n    });\n  });\n\n  describe('composite (variant × item)', () => {\n    it('should narrow to a single entry when both dimensions are pinned', () => {\n      expectTypeOf<\n        ResolveQualifiedDictionaryContent<\n          BannerGroup,\n          { variant: 'promo'; item: 2 }\n        >\n      >().toEqualTypeOf<{ title: 'P2' }>();\n    });\n\n    it('should fan the item axis out for the selected variant', () => {\n      expectTypeOf<\n        ResolveQualifiedDictionaryContent<BannerGroup, { variant: 'promo' }>\n      >().toEqualTypeOf<({ title: 'P1' } | { title: 'P2' })[]>();\n    });\n\n    it('should fall back to the default variant then fan out its items', () => {\n      expectTypeOf<\n        ResolveQualifiedDictionaryContent<BannerGroup, { variant: 'unknown' }>\n      >().toEqualTypeOf<{ title: 'D1' }[]>();\n    });\n  });\n});\n\ndescribe('DictionarySelectorForGroup', () => {\n  /** Stands in for the project-wide variant vocabulary (`DeclaredVariants`). */\n  type ProjectVariants = 'default' | 'preschool' | 'promo';\n\n  type LessonSelector = DictionarySelectorForGroup<\n    LessonGroup,\n    ProjectVariants\n  >;\n\n  it('should accept a variant this key declares', () => {\n    expectTypeOf<{ variant: 'preschool' }>().toExtend<LessonSelector>();\n  });\n\n  it('should accept a variant declared elsewhere in the project', () => {\n    // `LessonGroup` has no `promo` entry — it resolves to `default` at runtime,\n    // which is what makes one session-wide variant usable across every key.\n    expectTypeOf<{ variant: 'promo' }>().toExtend<LessonSelector>();\n  });\n\n  it('should reject a variant no dictionary declares', () => {\n    expectTypeOf<{ variant: 'promoo' }>().not.toExtend<LessonSelector>();\n  });\n\n  it('should reject an object variant on a key that declares none', () => {\n    expectTypeOf<{ variant: { id: 'abc' } }>().not.toExtend<LessonSelector>();\n  });\n\n  describe('object variants', () => {\n    // `ProductGroup` stores `'id=abc&userId=123'` — the serialized form of\n    // `{ id: 'abc', userId: '123' }`.\n    type ProductSelector = DictionarySelectorForGroup<\n      ProductGroup,\n      ProjectVariants\n    >;\n\n    it('should accept the object the key declares', () => {\n      expectTypeOf<{\n        variant: { id: 'abc'; userId: '123' };\n      }>().toExtend<ProductSelector>();\n    });\n\n    it('should reject the serialized form as a string', () => {\n      // `'id=abc&userId=123'` is a storage encoding, not part of the API.\n      expectTypeOf<{\n        variant: 'id=abc&userId=123';\n      }>().not.toExtend<ProductSelector>();\n    });\n\n    it('should reject a partial or mismatched object', () => {\n      expectTypeOf<{\n        variant: { id: 'abc' };\n      }>().not.toExtend<ProductSelector>();\n      expectTypeOf<{\n        variant: { id: 'abc'; userId: 'other' };\n      }>().not.toExtend<ProductSelector>();\n    });\n  });\n\n  it('should reject an undeclared locale', () => {\n    expectTypeOf<{ locale: 'not-a-locale' }>().not.toExtend<LessonSelector>();\n  });\n});\n\ndescribe('DictionarySelectorForGroup — keys without a default entry', () => {\n  type ProjectVariants = 'default' | 'preschool' | 'promo';\n\n  // Declares only object variants: an undeclared name resolves to `null`, so\n  // the project vocabulary must not be accepted here.\n  type ProductSelector = DictionarySelectorForGroup<\n    ProductGroup,\n    ProjectVariants\n  >;\n\n  // Declares `promo` but no `default` — same reasoning.\n  type NoDefaultSelector = DictionarySelectorForGroup<\n    NoDefaultGroup,\n    ProjectVariants\n  >;\n\n  it('should reject a project variant on a key with no default entry', () => {\n    expectTypeOf<{ variant: 'promo' }>().not.toExtend<ProductSelector>();\n    expectTypeOf<{ variant: 'default' }>().not.toExtend<ProductSelector>();\n    expectTypeOf<{ variant: 'preschool' }>().not.toExtend<NoDefaultSelector>();\n  });\n\n  it('should still accept the names such a key declares itself', () => {\n    expectTypeOf<{ variant: 'promo' }>().toExtend<NoDefaultSelector>();\n  });\n});\n"],"mappings":";;;AAqDA,SAAS,2CAA2C;CAClD,GAAG,iFAAiF;EAClF,aAEE,CAAC,CAAC,cAA0B;CAChC,CAAC;CAED,SAAS,iBAAiB;EACxB,GAAG,yEAAyE;GAC1E,aAEE,CAAC,CAAC,cAAuD;EAC7D,CAAC;EAED,GAAG,gEAAgE;GACjE,aAEE,CAAC,CAAC,cAAuD;EAC7D,CAAC;EAED,GAAG,4DAA4D;GAC7D,aAEE,CAAC,CAAC,cAAyD;EAC/D,CAAC;EAED,GAAG,yEAAyE;GAC1E,aAKE,CAAC,CAAC,cAAuD;EAC7D,CAAC;EAED,GAAG,kEAAkE;GACnE,aAKE,CAAC,CAAC,cAAoB;EAC1B,CAAC;EAED,GAAG,uDAAuD;GACxD,aAKE,CAAC,CAAC,cAA+B;EACrC,CAAC;EAED,GAAG,0EAA0E;GAC3E,aAEE,CAAC,CAAC,cAAoB;EAC1B,CAAC;CACH,CAAC;CAED,SAAS,cAAc;EACrB,GAAG,6EAA6E;GAC9E,aAA0D,CAAC,CAAC,cAE1D;EACJ,CAAC;EAED,GAAG,4CAA4C;GAC7C,aAEE,CAAC,CAAC,cAAkC;EACxC,CAAC;CACH,CAAC;CAED,SAAS,oCAAoC;EAC3C,GAAG,yEAAyE;GAC1E,aAKE,CAAC,CAAC,cAA+B;EACrC,CAAC;EAED,GAAG,+DAA+D;GAChE,aAEE,CAAC,CAAC,cAAqD;EAC3D,CAAC;EAED,GAAG,wEAAwE;GACzE,aAEE,CAAC,CAAC,cAAiC;EACvC,CAAC;CACH,CAAC;AACH,CAAC;AAED,SAAS,oCAAoC;CAS3C,GAAG,mDAAmD;EACpD,aAAuC,CAAC,CAAC,SAAyB;CACpE,CAAC;CAED,GAAG,mEAAmE;EAGpE,aAAmC,CAAC,CAAC,SAAyB;CAChE,CAAC;CAED,GAAG,wDAAwD;EACzD,aAAoC,CAAC,CAAC,IAAI,SAAyB;CACrE,CAAC;CAED,GAAG,qEAAqE;EACtE,aAAyC,CAAC,CAAC,IAAI,SAAyB;CAC1E,CAAC;CAED,SAAS,yBAAyB;EAQhC,GAAG,mDAAmD;GACpD,aAEG,CAAC,CAAC,SAA0B;EACjC,CAAC;EAED,GAAG,uDAAuD;GAExD,aAEG,CAAC,CAAC,IAAI,SAA0B;EACrC,CAAC;EAED,GAAG,sDAAsD;GACvD,aAEG,CAAC,CAAC,IAAI,SAA0B;GACnC,aAEG,CAAC,CAAC,IAAI,SAA0B;EACrC,CAAC;CACH,CAAC;CAED,GAAG,4CAA4C;EAC7C,aAAyC,CAAC,CAAC,IAAI,SAAyB;CAC1E,CAAC;AACH,CAAC;AAED,SAAS,mEAAmE;CAgB1E,GAAG,wEAAwE;EACzE,aAAmC,CAAC,CAAC,IAAI,SAA0B;EACnE,aAAqC,CAAC,CAAC,IAAI,SAA0B;EACrE,aAAuC,CAAC,CAAC,IAAI,SAA4B;CAC3E,CAAC;CAED,GAAG,kEAAkE;EACnE,aAAmC,CAAC,CAAC,SAA4B;CACnE,CAAC;AACH,CAAC"}