@intlayer/core 8.12.5-canary.0 → 9.0.0-canary.0

package/dist/cjs/deepTransformPlugins/getEditedContent.cjs

@@ -0,0 +1,96 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+let _intlayer_types_nodeType = require("@intlayer/types/nodeType");
+_intlayer_types_nodeType = require_runtime.__toESM(_intlayer_types_nodeType);
+
+//#region src/deepTransformPlugins/getEditedContent.ts
+const isTranslationNode = (node) => typeof node === "object" && node !== null && node.nodeType === _intlayer_types_nodeType.TRANSLATION;
+const isTypedNode = (node) => typeof node === "object" && node !== null && !Array.isArray(node) && typeof node.nodeType === "string";
+/** Structural equality for leaf source values (string / number / nested objects). */
+const isSameValue = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+/**
+* Recursively compares `next` against `previous` and returns the sub-tree of
+* `next` that holds only the nodes whose source-locale value was added or
+* changed. Returns `undefined` when nothing changed at this node.
+*/
+const getEditedNode = (previous, next, defaultLocale) => {
+	if (isTranslationNode(next)) {
+		const nextValue = next[_intlayer_types_nodeType.TRANSLATION]?.[defaultLocale];
+		const previousValue = isTranslationNode(previous) ? previous[_intlayer_types_nodeType.TRANSLATION]?.[defaultLocale] : void 0;
+		if (typeof nextValue === "undefined") return;
+		if (isSameValue(previousValue, nextValue)) return;
+		return {
+			nodeType: _intlayer_types_nodeType.TRANSLATION,
+			[_intlayer_types_nodeType.TRANSLATION]: { [defaultLocale]: nextValue }
+		};
+	}
+	if (isTypedNode(next)) {
+		const { nodeType } = next;
+		const editedInner = getEditedNode(isTypedNode(previous) ? previous[nodeType] : void 0, next[nodeType], defaultLocale);
+		if (typeof editedInner === "undefined") return;
+		return {
+			nodeType,
+			[nodeType]: editedInner
+		};
+	}
+	if (Array.isArray(next)) {
+		const previousArray = Array.isArray(previous) ? previous : [];
+		let hasChange = false;
+		const result = next.map((child, index) => {
+			const editedChild = getEditedNode(previousArray[index], child, defaultLocale);
+			if (typeof editedChild !== "undefined") {
+				hasChange = true;
+				return editedChild;
+			}
+			return child;
+		});
+		return hasChange ? result : void 0;
+	}
+	if (typeof next === "object" && next !== null) {
+		const previousObject = typeof previous === "object" && previous !== null && !Array.isArray(previous) ? previous : void 0;
+		const result = {};
+		let hasChange = false;
+		for (const key of Object.keys(next)) {
+			const editedChild = getEditedNode(previousObject?.[key], next[key], defaultLocale);
+			if (typeof editedChild !== "undefined") {
+				result[key] = editedChild;
+				hasChange = true;
+			}
+		}
+		return hasChange ? result : void 0;
+	}
+};
+/**
+* Returns the partial content holding only the `translation` nodes whose
+* source (`defaultLocale`) value was added or changed between `previousContent`
+* and `newContent`. Each changed node is reduced to its source locale so that
+* every target locale is regenerated when the partial is translated.
+*
+* Returns `{}` (empty content) when no source value changed.
+*
+* @example
+* // default value of `title` changed → only `title` is returned, source-only
+* getEditedContent(
+*   { title: t({ en: 'Old', fr: 'Vieux' }), body: t({ en: 'B', fr: 'B' }) },
+*   { title: t({ en: 'New', fr: 'Vieux' }), body: t({ en: 'B', fr: 'B' }) },
+*   'en'
+* ); // → { title: { nodeType: 'translation', translation: { en: 'New' } } }
+*/
+const getEditedContent = (previousContent, newContent, defaultLocale) => getEditedNode(previousContent, newContent, defaultLocale) ?? {};
+/**
+* Dictionary-level wrapper around {@link getEditedContent}. Returns a partial
+* dictionary (same `key`) whose `content` holds only the changed source nodes.
+*
+* @param previousDictionary - Dictionary state before the edit.
+* @param newDictionary - Dictionary state after the edit.
+* @param defaultLocale - The source locale to diff against.
+*/
+const getEditedDictionary = (previousDictionary, newDictionary, defaultLocale) => ({
+	...newDictionary,
+	content: getEditedContent(previousDictionary?.content, newDictionary.content, defaultLocale)
+});
+
+//#endregion
+exports.getEditedContent = getEditedContent;
+exports.getEditedDictionary = getEditedDictionary;
+//# sourceMappingURL=getEditedContent.cjs.map

package/dist/cjs/deepTransformPlugins/getEditedContent.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"getEditedContent.cjs","names":["NodeTypes"],"sources":["../../../src/deepTransformPlugins/getEditedContent.ts"],"sourcesContent":["import type { ContentNode, Dictionary } from '@intlayer/types/dictionary';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport * as NodeTypes from '@intlayer/types/nodeType';\n\n/** A `translation` node, e.g. `{ nodeType: 'translation', translation: { en, fr } }`. */\ntype TranslationNode = {\n  nodeType: typeof NodeTypes.TRANSLATION;\n  [NodeTypes.TRANSLATION]: Record<string, unknown>;\n};\n\nconst isTranslationNode = (node: unknown): node is TranslationNode =>\n  typeof node === 'object' &&\n  node !== null &&\n  (node as { nodeType?: unknown }).nodeType === NodeTypes.TRANSLATION;\n\nconst isTypedNode = (\n  node: unknown\n): node is { nodeType: string; [key: string]: unknown } =>\n  typeof node === 'object' &&\n  node !== null &&\n  !Array.isArray(node) &&\n  typeof (node as { nodeType?: unknown }).nodeType === 'string';\n\n/** Structural equality for leaf source values (string / number / nested objects). */\nconst isSameValue = (a: unknown, b: unknown): boolean =>\n  JSON.stringify(a) === JSON.stringify(b);\n\n/**\n * Recursively compares `next` against `previous` and returns the sub-tree of\n * `next` that holds only the nodes whose source-locale value was added or\n * changed. Returns `undefined` when nothing changed at this node.\n */\nconst getEditedNode = (\n  previous: ContentNode | undefined,\n  next: ContentNode,\n  defaultLocale: LocalesValues\n): ContentNode | undefined => {\n  // Translation node: compare the default-locale leaf only.\n  if (isTranslationNode(next)) {\n    const nextValue = next[NodeTypes.TRANSLATION]?.[defaultLocale as string];\n    const previousValue = isTranslationNode(previous)\n      ? previous[NodeTypes.TRANSLATION]?.[defaultLocale as string]\n      : undefined;\n\n    // Nothing to (re)translate if the source locale is absent.\n    if (typeof nextValue === 'undefined') {\n      return undefined;\n    }\n\n    // Include only when the source value was added or changed.\n    if (isSameValue(previousValue, nextValue)) {\n      return undefined;\n    }\n\n    // Reduce to the source locale only, so every target locale is regenerated.\n    return {\n      nodeType: NodeTypes.TRANSLATION,\n      [NodeTypes.TRANSLATION]: { [defaultLocale as string]: nextValue },\n    } as ContentNode;\n  }\n\n  // Other typed nodes (enumeration, condition, nested, …): recurse into the\n  // wrapped value while preserving the wrapper so the partial stays valid.\n  if (isTypedNode(next)) {\n    const { nodeType } = next;\n    const previousInner = isTypedNode(previous)\n      ? (previous[nodeType] as ContentNode | undefined)\n      : undefined;\n    const editedInner = getEditedNode(\n      previousInner,\n      next[nodeType] as ContentNode,\n      defaultLocale\n    );\n\n    if (typeof editedInner === 'undefined') {\n      return undefined;\n    }\n\n    return {\n      nodeType,\n      [nodeType]: editedInner,\n    } as ContentNode;\n  }\n\n  // Arrays: keep changed items reduced to source-only, unchanged items as-is to\n  // preserve index alignment for `mergeDictionaries` (which merges by index).\n  if (Array.isArray(next)) {\n    const previousArray = Array.isArray(previous) ? previous : [];\n    let hasChange = false;\n\n    const result = next.map((child, index) => {\n      const editedChild = getEditedNode(\n        previousArray[index] as ContentNode | undefined,\n        child as ContentNode,\n        defaultLocale\n      );\n      if (typeof editedChild !== 'undefined') {\n        hasChange = true;\n        return editedChild;\n      }\n      // Unchanged item: keep the full node. It already has every locale, so the\n      // complete-mode translation pass skips it and the merge leaves it intact.\n      return child;\n    });\n\n    return hasChange ? (result as ContentNode) : undefined;\n  }\n\n  // Plain objects: recurse into each key, keeping only changed branches.\n  if (typeof next === 'object' && next !== null) {\n    const previousObject =\n      typeof previous === 'object' &&\n      previous !== null &&\n      !Array.isArray(previous)\n        ? (previous as Record<string, ContentNode>)\n        : undefined;\n\n    const result: Record<string, ContentNode> = {};\n    let hasChange = false;\n\n    for (const key of Object.keys(next as Record<string, ContentNode>)) {\n      const editedChild = getEditedNode(\n        previousObject?.[key],\n        (next as Record<string, ContentNode>)[key],\n        defaultLocale\n      );\n      if (typeof editedChild !== 'undefined') {\n        result[key] = editedChild;\n        hasChange = true;\n      }\n    }\n\n    return hasChange ? (result as ContentNode) : undefined;\n  }\n\n  // Primitive leaves are not locale-aware on their own — nothing to translate.\n  return undefined;\n};\n\n/**\n * Returns the partial content holding only the `translation` nodes whose\n * source (`defaultLocale`) value was added or changed between `previousContent`\n * and `newContent`. Each changed node is reduced to its source locale so that\n * every target locale is regenerated when the partial is translated.\n *\n * Returns `{}` (empty content) when no source value changed.\n *\n * @example\n * // default value of `title` changed → only `title` is returned, source-only\n * getEditedContent(\n *   { title: t({ en: 'Old', fr: 'Vieux' }), body: t({ en: 'B', fr: 'B' }) },\n *   { title: t({ en: 'New', fr: 'Vieux' }), body: t({ en: 'B', fr: 'B' }) },\n *   'en'\n * ); // → { title: { nodeType: 'translation', translation: { en: 'New' } } }\n */\nexport const getEditedContent = (\n  previousContent: ContentNode | undefined,\n  newContent: ContentNode,\n  defaultLocale: LocalesValues\n): ContentNode =>\n  getEditedNode(previousContent, newContent, defaultLocale) ??\n  ({} as ContentNode);\n\n/**\n * Dictionary-level wrapper around {@link getEditedContent}. Returns a partial\n * dictionary (same `key`) whose `content` holds only the changed source nodes.\n *\n * @param previousDictionary - Dictionary state before the edit.\n * @param newDictionary - Dictionary state after the edit.\n * @param defaultLocale - The source locale to diff against.\n */\nexport const getEditedDictionary = (\n  previousDictionary: Dictionary | undefined,\n  newDictionary: Dictionary,\n  defaultLocale: LocalesValues\n): Dictionary => ({\n  ...newDictionary,\n  content: getEditedContent(\n    previousDictionary?.content,\n    newDictionary.content,\n    defaultLocale\n  ),\n});\n"],"mappings":";;;;;;AAUA,MAAM,qBAAqB,SACzB,OAAO,SAAS,YAChB,SAAS,QACR,KAAgC,aAAaA,yBAAU;AAE1D,MAAM,eACJ,SAEA,OAAO,SAAS,YAChB,SAAS,QACT,CAAC,MAAM,QAAQ,KAAK,IACpB,OAAQ,KAAgC,aAAa;;AAGvD,MAAM,eAAe,GAAY,MAC/B,KAAK,UAAU,EAAE,KAAK,KAAK,UAAU,EAAE;;;;;;AAOzC,MAAM,iBACJ,UACA,MACA,kBAC4B;AAE5B,KAAI,kBAAkB,KAAK,EAAE;EAC3B,MAAM,YAAY,KAAKA,yBAAU,eAAe;EAChD,MAAM,gBAAgB,kBAAkB,SAAS,GAC7C,SAASA,yBAAU,eAAe,iBAClC;AAGJ,MAAI,OAAO,cAAc,YACvB;AAIF,MAAI,YAAY,eAAe,UAAU,CACvC;AAIF,SAAO;GACL,UAAUA,yBAAU;IACnBA,yBAAU,cAAc,GAAG,gBAA0B,WAAW;GAClE;;AAKH,KAAI,YAAY,KAAK,EAAE;EACrB,MAAM,EAAE,aAAa;EAIrB,MAAM,cAAc,cAHE,YAAY,SAAS,GACtC,SAAS,YACV,QAGF,KAAK,WACL,cACD;AAED,MAAI,OAAO,gBAAgB,YACzB;AAGF,SAAO;GACL;IACC,WAAW;GACb;;AAKH,KAAI,MAAM,QAAQ,KAAK,EAAE;EACvB,MAAM,gBAAgB,MAAM,QAAQ,SAAS,GAAG,WAAW,EAAE;EAC7D,IAAI,YAAY;EAEhB,MAAM,SAAS,KAAK,KAAK,OAAO,UAAU;GACxC,MAAM,cAAc,cAClB,cAAc,QACd,OACA,cACD;AACD,OAAI,OAAO,gBAAgB,aAAa;AACtC,gBAAY;AACZ,WAAO;;AAIT,UAAO;IACP;AAEF,SAAO,YAAa,SAAyB;;AAI/C,KAAI,OAAO,SAAS,YAAY,SAAS,MAAM;EAC7C,MAAM,iBACJ,OAAO,aAAa,YACpB,aAAa,QACb,CAAC,MAAM,QAAQ,SAAS,GACnB,WACD;EAEN,MAAM,SAAsC,EAAE;EAC9C,IAAI,YAAY;AAEhB,OAAK,MAAM,OAAO,OAAO,KAAK,KAAoC,EAAE;GAClE,MAAM,cAAc,cAClB,iBAAiB,MAChB,KAAqC,MACtC,cACD;AACD,OAAI,OAAO,gBAAgB,aAAa;AACtC,WAAO,OAAO;AACd,gBAAY;;;AAIhB,SAAO,YAAa,SAAyB;;;;;;;;;;;;;;;;;;;AAuBjD,MAAa,oBACX,iBACA,YACA,kBAEA,cAAc,iBAAiB,YAAY,cAAc,IACxD,EAAE;;;;;;;;;AAUL,MAAa,uBACX,oBACA,eACA,mBACgB;CAChB,GAAG;CACH,SAAS,iBACP,oBAAoB,SACpB,cAAc,SACd,cACD;CACF"}

package/dist/cjs/deepTransformPlugins/index.cjs

@@ -1,4 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_deepTransformPlugins_getEditedContent = require('./getEditedContent.cjs');
 const require_deepTransformPlugins_getFilteredLocalesContent = require('./getFilteredLocalesContent.cjs');
 const require_deepTransformPlugins_getFilterMissingTranslationsContent = require('./getFilterMissingTranslationsContent.cjs');
 const require_deepTransformPlugins_getFilterTranslationsOnlyContent = require('./getFilterTranslationsOnlyContent.cjs');
@@ -14,6 +15,8 @@ exports.buildMaskPlugin = require_deepTransformPlugins_getMaskContent.buildMaskP
 exports.checkMissingLocalesPlugin = require_deepTransformPlugins_getMissingLocalesContent.checkMissingLocalesPlugin;
 exports.filterMissingTranslationsOnlyPlugin = require_deepTransformPlugins_getFilterMissingTranslationsContent.filterMissingTranslationsOnlyPlugin;
 exports.filterTranslationsOnlyPlugin = require_deepTransformPlugins_getFilterTranslationsOnlyContent.filterTranslationsOnlyPlugin;
+exports.getEditedContent = require_deepTransformPlugins_getEditedContent.getEditedContent;
+exports.getEditedDictionary = require_deepTransformPlugins_getEditedContent.getEditedDictionary;
 exports.getFilterMissingTranslationsContent = require_deepTransformPlugins_getFilterMissingTranslationsContent.getFilterMissingTranslationsContent;
 exports.getFilterMissingTranslationsDictionary = require_deepTransformPlugins_getFilterMissingTranslationsContent.getFilterMissingTranslationsDictionary;
 exports.getFilterTranslationsOnlyContent = require_deepTransformPlugins_getFilterTranslationsOnlyContent.getFilterTranslationsOnlyContent;

package/dist/cjs/dictionaryManipulator/index.cjs

@@ -1,4 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_dictionaryManipulator_qualifiedDictionary = require('./qualifiedDictionary.cjs');
 const require_dictionaryManipulator_editDictionaryByKeyPath = require('./editDictionaryByKeyPath.cjs');
 const require_dictionaryManipulator_getContentNodeByKeyPath = require('./getContentNodeByKeyPath.cjs');
 const require_dictionaryManipulator_getDefaultNode = require('./getDefaultNode.cjs');
@@ -6,22 +7,39 @@ const require_dictionaryManipulator_getEmptyNode = require('./getEmptyNode.cjs')
 const require_dictionaryManipulator_getNodeChildren = require('./getNodeChildren.cjs');
 const require_dictionaryManipulator_getNodeType = require('./getNodeType.cjs');
 const require_dictionaryManipulator_mergeDictionaries = require('./mergeDictionaries.cjs');
+const require_dictionaryManipulator_mergeQualifiedDictionaries = require('./mergeQualifiedDictionaries.cjs');
 const require_dictionaryManipulator_orderDictionaries = require('./orderDictionaries.cjs');
 const require_dictionaryManipulator_normalizeDictionary = require('./normalizeDictionary.cjs');
 const require_dictionaryManipulator_removeContentNodeByKeyPath = require('./removeContentNodeByKeyPath.cjs');
 const require_dictionaryManipulator_renameContentNodeByKeyPath = require('./renameContentNodeByKeyPath.cjs');
 const require_dictionaryManipulator_updateNodeChildren = require('./updateNodeChildren.cjs');
 
+exports.COMPOSITE_ID_SEPARATOR = require_dictionaryManipulator_qualifiedDictionary.COMPOSITE_ID_SEPARATOR;
+exports.QUALIFIER_DYNAMIC_TYPES_KEY = require_dictionaryManipulator_qualifiedDictionary.QUALIFIER_DYNAMIC_TYPES_KEY;
+exports.QUALIFIER_ORDER = require_dictionaryManipulator_qualifiedDictionary.QUALIFIER_ORDER;
 exports.editDictionaryByKeyPath = require_dictionaryManipulator_editDictionaryByKeyPath.editDictionaryByKeyPath;
 exports.getContentNodeByKeyPath = require_dictionaryManipulator_getContentNodeByKeyPath.getContentNodeByKeyPath;
 exports.getDefaultNode = require_dictionaryManipulator_getDefaultNode.getDefaultNode;
+exports.getDictionaryCompositeId = require_dictionaryManipulator_qualifiedDictionary.getDictionaryCompositeId;
+exports.getDictionaryQualifierId = require_dictionaryManipulator_qualifiedDictionary.getDictionaryQualifierId;
+exports.getDictionaryQualifierSegments = require_dictionaryManipulator_qualifiedDictionary.getDictionaryQualifierSegments;
+exports.getDictionaryQualifierTypes = require_dictionaryManipulator_qualifiedDictionary.getDictionaryQualifierTypes;
+exports.getDictionarySelectorCacheKey = require_dictionaryManipulator_qualifiedDictionary.getDictionarySelectorCacheKey;
 exports.getEmptyNode = require_dictionaryManipulator_getEmptyNode.getEmptyNode;
 exports.getNodeChildren = require_dictionaryManipulator_getNodeChildren.getNodeChildren;
 exports.getNodeType = require_dictionaryManipulator_getNodeType.getNodeType;
+exports.isQualifiedDictionaryGroup = require_dictionaryManipulator_qualifiedDictionary.isQualifiedDictionaryGroup;
+exports.isQualifiedDynamicLoaderMap = require_dictionaryManipulator_qualifiedDictionary.isQualifiedDynamicLoaderMap;
 exports.mergeDictionaries = require_dictionaryManipulator_mergeDictionaries.mergeDictionaries;
+exports.mergeQualifiedDictionaries = require_dictionaryManipulator_mergeQualifiedDictionaries.mergeQualifiedDictionaries;
 exports.normalizeDictionaries = require_dictionaryManipulator_normalizeDictionary.normalizeDictionaries;
 exports.normalizeDictionary = require_dictionaryManipulator_normalizeDictionary.normalizeDictionary;
 exports.orderDictionaries = require_dictionaryManipulator_orderDictionaries.orderDictionaries;
+exports.parseDictionarySelector = require_dictionaryManipulator_qualifiedDictionary.parseDictionarySelector;
+exports.reconstructQualifiedEntry = require_dictionaryManipulator_qualifiedDictionary.reconstructQualifiedEntry;
 exports.removeContentNodeByKeyPath = require_dictionaryManipulator_removeContentNodeByKeyPath.removeContentNodeByKeyPath;
 exports.renameContentNodeByKeyPath = require_dictionaryManipulator_renameContentNodeByKeyPath.renameContentNodeByKeyPath;
+exports.resolveQualifiedDictionary = require_dictionaryManipulator_qualifiedDictionary.resolveQualifiedDictionary;
+exports.resolveQualifiedDynamicContent = require_dictionaryManipulator_qualifiedDictionary.resolveQualifiedDynamicContent;
+exports.resolveQualifiedDynamicContentAsync = require_dictionaryManipulator_qualifiedDictionary.resolveQualifiedDynamicContentAsync;
 exports.updateNodeChildren = require_dictionaryManipulator_updateNodeChildren.updateNodeChildren;

package/dist/cjs/dictionaryManipulator/mergeDictionaries.cjs

@@ -49,11 +49,14 @@ const arrayMerge = (destinationArray, sourceArray) => {
 };
 const mergeDictionaries = (dictionaries) => {
 	const localIds = Array.from(new Set(dictionaries.filter((dict) => dict.localId).map((dict) => dict.localId)));
+	if (!dictionaries[0] || dictionaries.length <= 1) return dictionaries[0];
 	const dictionariesKeys = dictionaries.map((dict) => dict.key);
 	if (new Set(dictionariesKeys).size !== 1) throw new Error("All dictionaries must have the same key");
 	let mergedContent = dictionaries[0].content;
 	for (let i = 1; i < dictionaries.length; i++) {
-		const currentDictionary = require_deepTransformPlugins_getMultilingualDictionary.getMultilingualDictionary(dictionaries[i]);
+		const dict = dictionaries[i];
+		if (!dict) continue;
+		const currentDictionary = require_deepTransformPlugins_getMultilingualDictionary.getMultilingualDictionary(dict);
 		checkTypesMatch(mergedContent, currentDictionary.content, currentDictionary.localId, currentDictionary.key, []);
 		mergedContent = customMerge(mergedContent, currentDictionary.content);
 	}

package/dist/cjs/dictionaryManipulator/mergeDictionaries.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"mergeDictionaries.cjs","names":["getNodeType","getMultilingualDictionary"],"sources":["../../../src/dictionaryManipulator/mergeDictionaries.ts"],"sourcesContent":["import { log } from '@intlayer/config/built';\nimport { colorizeKey, getAppLogger } from '@intlayer/config/logger';\nimport type {\n  ContentNode,\n  Dictionary,\n  LocalDictionaryId,\n} from '@intlayer/types/dictionary';\nimport { getMultilingualDictionary } from '../deepTransformPlugins';\nimport { getNodeType } from './getNodeType';\n\n// Extended type that includes arrays for internal merge operations\ntype MergeableContent = ContentNode | ContentNode[];\n\nconst checkTypesMatch = (\n  object1: ContentNode,\n  object2: ContentNode,\n  object2LocalId: LocalDictionaryId | undefined,\n  dictionaryKey: string,\n  path: string[] = []\n): void => {\n  const appLogger = getAppLogger({ log });\n\n  // If either side is missing/undefined, allow merge without error\n  if (\n    object1 === undefined ||\n    object1 === null ||\n    object2 === undefined ||\n    object2 === null\n  )\n    return;\n\n  const type1 = getNodeType(object1);\n  const type2 = getNodeType(object2);\n\n  // Unknown types are treated as flexible; skip strict mismatch reporting\n  if (type1 === 'unknown' || type2 === 'unknown') return;\n\n  if (type1 !== type2) {\n    appLogger(\n      [\n        `Error: Dictionary ${colorizeKey(dictionaryKey)} has a multiple content files with type mismatch at path \"${path.join('.')}\": Cannot merge ${type1} with ${type2} while merging ${object2LocalId}`,\n      ],\n      {\n        level: 'error',\n      }\n    );\n\n    return;\n  }\n};\n\n// Custom merge function that prefers destination (first dictionary) values\nconst customMerge = (\n  destination: ContentNode,\n  source: ContentNode\n): MergeableContent => {\n  // If destination is undefined/null, use source\n  if (destination === undefined || destination === null) {\n    return source;\n  }\n\n  // If source is undefined/null, use destination\n  if (source === undefined || source === null) {\n    return destination;\n  }\n\n  // For primitive values, prefer destination (first dictionary)\n  if (typeof destination !== 'object' || typeof source !== 'object') {\n    return destination;\n  }\n\n  // For arrays, use our custom array merge\n  if (Array.isArray(destination) && Array.isArray(source)) {\n    return arrayMerge(\n      destination as ContentNode[],\n      source as ContentNode[]\n    ) as MergeableContent;\n  }\n\n  // For objects, recursively merge with our custom logic\n  if (typeof destination === 'object' && typeof source === 'object') {\n    const result: Record<string, MergeableContent> = {};\n    const allKeys = new Set([\n      ...Object.keys(destination as unknown as Record<string, ContentNode>),\n      ...Object.keys(source as unknown as Record<string, ContentNode>),\n    ]);\n\n    for (const key of allKeys) {\n      result[key] = customMerge(\n        (destination as unknown as Record<string, ContentNode>)[key],\n        (source as unknown as Record<string, ContentNode>)[key]\n      );\n    }\n\n    return result as unknown as MergeableContent;\n  }\n\n  // Fallback to destination\n  return destination;\n};\n\n// Custom array merge strategy that merges arrays by key when present, otherwise by index\nconst arrayMerge = (\n  destinationArray: ContentNode[],\n  sourceArray: ContentNode[]\n): MergeableContent[] => {\n  // Check if both arrays contain only primitives\n  const destHasOnlyPrimitives = destinationArray.every(\n    (item) => typeof item !== 'object' || item === null\n  );\n  const sourceHasOnlyPrimitives = sourceArray.every(\n    (item) => typeof item !== 'object' || item === null\n  );\n\n  // If both arrays contain only primitives, use the source array (second dictionary)\n  if (destHasOnlyPrimitives && sourceHasOnlyPrimitives) {\n    return sourceArray;\n  }\n\n  // Otherwise, merge by index with object merging logic\n  const result: MergeableContent[] = [];\n  const maxLength = Math.max(destinationArray.length, sourceArray.length);\n\n  for (let i = 0; i < maxLength; i++) {\n    const destItem = destinationArray[i];\n    const sourceItem = sourceArray[i];\n\n    if (destItem === undefined && sourceItem === undefined) {\n    } else if (destItem === undefined) {\n      // Only source exists, add it\n      result.push(sourceItem);\n    } else if (sourceItem === undefined) {\n      // Only destination exists, add it\n      result.push(destItem);\n    } else {\n      // Both exist, merge them\n      if (\n        typeof destItem === 'object' &&\n        typeof sourceItem === 'object' &&\n        destItem !== null &&\n        sourceItem !== null\n      ) {\n        // Check if both objects have a 'key' property for keyed merging\n        if (\n          'key' in destItem &&\n          'key' in sourceItem &&\n          (destItem as Record<string, string>).key ===\n            (sourceItem as Record<string, string>).key\n        ) {\n          // Merge objects with same key, preferring destination (first dictionary) values\n          result.push(customMerge(destItem, sourceItem));\n        } else {\n          // Merge objects by index, preferring destination (first dictionary) values\n          result.push(customMerge(destItem, sourceItem));\n        }\n      } else {\n        // For primitives or non-objects, use destination value (first dictionary)\n        result.push(destItem);\n      }\n    }\n  }\n\n  return result;\n};\n\nexport const mergeDictionaries = (dictionaries: Dictionary[]): Dictionary => {\n  const localIds = Array.from(\n    new Set<LocalDictionaryId>(\n      dictionaries.filter((dict) => dict.localId).map((dict) => dict.localId!)\n    )\n  );\n\n  const dictionariesKeys = dictionaries.map((dict) => dict.key);\n\n  // Check if all dictionaries have the same key\n  if (new Set(dictionariesKeys).size !== 1) {\n    throw new Error('All dictionaries must have the same key');\n  }\n\n  let mergedContent: Dictionary['content'] = dictionaries[0].content;\n\n  for (let i = 1; i < dictionaries.length; i++) {\n    // If the dictionary is a per-locale dictionary, transform it to a partial multilingual dictionary\n    const currentDictionary = getMultilingualDictionary(dictionaries[i]);\n\n    // Check types before merging\n    checkTypesMatch(\n      mergedContent,\n      currentDictionary.content,\n      currentDictionary.localId,\n      currentDictionary.key,\n      []\n    );\n\n    mergedContent = customMerge(\n      mergedContent,\n      currentDictionary.content\n    ) as ContentNode;\n  }\n\n  const mergedDictionary: Dictionary = {\n    key: dictionaries[0].key,\n    content: mergedContent,\n    localIds,\n  };\n\n  return mergedDictionary;\n};\n"],"mappings":";;;;;;;;AAaA,MAAM,mBACJ,SACA,SACA,gBACA,eACA,OAAiB,EAAE,KACV;CACT,MAAM,sDAAyB,EAAE,iCAAK,CAAC;AAGvC,KACE,YAAY,UACZ,YAAY,QACZ,YAAY,UACZ,YAAY,KAEZ;CAEF,MAAM,QAAQA,sDAAY,QAAQ;CAClC,MAAM,QAAQA,sDAAY,QAAQ;AAGlC,KAAI,UAAU,aAAa,UAAU,UAAW;AAEhD,KAAI,UAAU,OAAO;AACnB,YACE,CACE,8DAAiC,cAAc,CAAC,4DAA4D,KAAK,KAAK,IAAI,CAAC,kBAAkB,MAAM,QAAQ,MAAM,iBAAiB,iBACnL,EACD,EACE,OAAO,SACR,CACF;AAED;;;AAKJ,MAAM,eACJ,aACA,WACqB;AAErB,KAAI,gBAAgB,UAAa,gBAAgB,KAC/C,QAAO;AAIT,KAAI,WAAW,UAAa,WAAW,KACrC,QAAO;AAIT,KAAI,OAAO,gBAAgB,YAAY,OAAO,WAAW,SACvD,QAAO;AAIT,KAAI,MAAM,QAAQ,YAAY,IAAI,MAAM,QAAQ,OAAO,CACrD,QAAO,WACL,aACA,OACD;AAIH,KAAI,OAAO,gBAAgB,YAAY,OAAO,WAAW,UAAU;EACjE,MAAM,SAA2C,EAAE;EACnD,MAAM,UAAU,IAAI,IAAI,CACtB,GAAG,OAAO,KAAK,YAAsD,EACrE,GAAG,OAAO,KAAK,OAAiD,CACjE,CAAC;AAEF,OAAK,MAAM,OAAO,QAChB,QAAO,OAAO,YACX,YAAuD,MACvD,OAAkD,KACpD;AAGH,SAAO;;AAIT,QAAO;;AAIT,MAAM,cACJ,kBACA,gBACuB;CAEvB,MAAM,wBAAwB,iBAAiB,OAC5C,SAAS,OAAO,SAAS,YAAY,SAAS,KAChD;CACD,MAAM,0BAA0B,YAAY,OACzC,SAAS,OAAO,SAAS,YAAY,SAAS,KAChD;AAGD,KAAI,yBAAyB,wBAC3B,QAAO;CAIT,MAAM,SAA6B,EAAE;CACrC,MAAM,YAAY,KAAK,IAAI,iBAAiB,QAAQ,YAAY,OAAO;AAEvE,MAAK,IAAI,IAAI,GAAG,IAAI,WAAW,KAAK;EAClC,MAAM,WAAW,iBAAiB;EAClC,MAAM,aAAa,YAAY;AAE/B,MAAI,aAAa,UAAa,eAAe,QAAW,YAC7C,aAAa,OAEtB,QAAO,KAAK,WAAW;WACd,eAAe,OAExB,QAAO,KAAK,SAAS;WAInB,OAAO,aAAa,YACpB,OAAO,eAAe,YACtB,aAAa,QACb,eAAe,KAGf,KACE,SAAS,YACT,SAAS,cACR,SAAoC,QAClC,WAAsC,IAGzC,QAAO,KAAK,YAAY,UAAU,WAAW,CAAC;MAG9C,QAAO,KAAK,YAAY,UAAU,WAAW,CAAC;MAIhD,QAAO,KAAK,SAAS;;AAK3B,QAAO;;AAGT,MAAa,qBAAqB,iBAA2C;CAC3E,MAAM,WAAW,MAAM,KACrB,IAAI,IACF,aAAa,QAAQ,SAAS,KAAK,QAAQ,CAAC,KAAK,SAAS,KAAK,QAAS,CACzE,CACF;CAED,MAAM,mBAAmB,aAAa,KAAK,SAAS,KAAK,IAAI;AAG7D,KAAI,IAAI,IAAI,iBAAiB,CAAC,SAAS,EACrC,OAAM,IAAI,MAAM,0CAA0C;CAG5D,IAAI,gBAAuC,aAAa,GAAG;AAE3D,MAAK,IAAI,IAAI,GAAG,IAAI,aAAa,QAAQ,KAAK;EAE5C,MAAM,oBAAoBC,iFAA0B,aAAa,GAAG;AAGpE,kBACE,eACA,kBAAkB,SAClB,kBAAkB,SAClB,kBAAkB,KAClB,EAAE,CACH;AAED,kBAAgB,YACd,eACA,kBAAkB,QACnB;;AASH,QAAO;EALL,KAAK,aAAa,GAAG;EACrB,SAAS;EACT;EAGqB"}
+{"version":3,"file":"mergeDictionaries.cjs","names":["getNodeType","getMultilingualDictionary"],"sources":["../../../src/dictionaryManipulator/mergeDictionaries.ts"],"sourcesContent":["import { log } from '@intlayer/config/built';\nimport { colorizeKey, getAppLogger } from '@intlayer/config/logger';\nimport type {\n  ContentNode,\n  Dictionary,\n  LocalDictionaryId,\n} from '@intlayer/types/dictionary';\nimport { getMultilingualDictionary } from '../deepTransformPlugins';\nimport { getNodeType } from './getNodeType';\n\n// Extended type that includes arrays for internal merge operations\ntype MergeableContent = ContentNode | ContentNode[];\n\nconst checkTypesMatch = (\n  object1: ContentNode,\n  object2: ContentNode,\n  object2LocalId: LocalDictionaryId | undefined,\n  dictionaryKey: string,\n  path: string[] = []\n): void => {\n  const appLogger = getAppLogger({ log });\n\n  // If either side is missing/undefined, allow merge without error\n  if (\n    object1 === undefined ||\n    object1 === null ||\n    object2 === undefined ||\n    object2 === null\n  )\n    return;\n\n  const type1 = getNodeType(object1);\n  const type2 = getNodeType(object2);\n\n  // Unknown types are treated as flexible; skip strict mismatch reporting\n  if (type1 === 'unknown' || type2 === 'unknown') return;\n\n  if (type1 !== type2) {\n    appLogger(\n      [\n        `Error: Dictionary ${colorizeKey(dictionaryKey)} has a multiple content files with type mismatch at path \"${path.join('.')}\": Cannot merge ${type1} with ${type2} while merging ${object2LocalId}`,\n      ],\n      {\n        level: 'error',\n      }\n    );\n\n    return;\n  }\n};\n\n// Custom merge function that prefers destination (first dictionary) values\nconst customMerge = (\n  destination: ContentNode,\n  source: ContentNode\n): MergeableContent => {\n  // If destination is undefined/null, use source\n  if (destination === undefined || destination === null) {\n    return source;\n  }\n\n  // If source is undefined/null, use destination\n  if (source === undefined || source === null) {\n    return destination;\n  }\n\n  // For primitive values, prefer destination (first dictionary)\n  if (typeof destination !== 'object' || typeof source !== 'object') {\n    return destination;\n  }\n\n  // For arrays, use our custom array merge\n  if (Array.isArray(destination) && Array.isArray(source)) {\n    return arrayMerge(\n      destination as ContentNode[],\n      source as ContentNode[]\n    ) as MergeableContent;\n  }\n\n  // For objects, recursively merge with our custom logic\n  if (typeof destination === 'object' && typeof source === 'object') {\n    const result: Record<string, MergeableContent> = {};\n    const allKeys = new Set([\n      ...Object.keys(destination as unknown as Record<string, ContentNode>),\n      ...Object.keys(source as unknown as Record<string, ContentNode>),\n    ]);\n\n    for (const key of allKeys) {\n      result[key] = customMerge(\n        (destination as unknown as Record<string, ContentNode>)[key],\n        (source as unknown as Record<string, ContentNode>)[key]\n      );\n    }\n\n    return result as unknown as MergeableContent;\n  }\n\n  // Fallback to destination\n  return destination;\n};\n\n// Custom array merge strategy that merges arrays by key when present, otherwise by index\nconst arrayMerge = (\n  destinationArray: ContentNode[],\n  sourceArray: ContentNode[]\n): MergeableContent[] => {\n  // Check if both arrays contain only primitives\n  const destHasOnlyPrimitives = destinationArray.every(\n    (item) => typeof item !== 'object' || item === null\n  );\n  const sourceHasOnlyPrimitives = sourceArray.every(\n    (item) => typeof item !== 'object' || item === null\n  );\n\n  // If both arrays contain only primitives, use the source array (second dictionary)\n  if (destHasOnlyPrimitives && sourceHasOnlyPrimitives) {\n    return sourceArray;\n  }\n\n  // Otherwise, merge by index with object merging logic\n  const result: MergeableContent[] = [];\n  const maxLength = Math.max(destinationArray.length, sourceArray.length);\n\n  for (let i = 0; i < maxLength; i++) {\n    const destItem = destinationArray[i];\n    const sourceItem = sourceArray[i];\n\n    if (destItem === undefined && sourceItem === undefined) {\n    } else if (destItem === undefined) {\n      // Only source exists, add it\n      result.push(sourceItem);\n    } else if (sourceItem === undefined) {\n      // Only destination exists, add it\n      result.push(destItem);\n    } else {\n      // Both exist, merge them\n      if (\n        typeof destItem === 'object' &&\n        typeof sourceItem === 'object' &&\n        destItem !== null &&\n        sourceItem !== null\n      ) {\n        // Check if both objects have a 'key' property for keyed merging\n        if (\n          'key' in destItem &&\n          'key' in sourceItem &&\n          (destItem as Record<string, string>).key ===\n            (sourceItem as Record<string, string>).key\n        ) {\n          // Merge objects with same key, preferring destination (first dictionary) values\n          result.push(customMerge(destItem, sourceItem));\n        } else {\n          // Merge objects by index, preferring destination (first dictionary) values\n          result.push(customMerge(destItem, sourceItem));\n        }\n      } else {\n        // For primitives or non-objects, use destination value (first dictionary)\n        result.push(destItem);\n      }\n    }\n  }\n\n  return result;\n};\n\nexport const mergeDictionaries = (dictionaries: Dictionary[]): Dictionary => {\n  const localIds = Array.from(\n    new Set<LocalDictionaryId>(\n      dictionaries.filter((dict) => dict.localId).map((dict) => dict.localId!)\n    )\n  );\n\n  if (!dictionaries[0] || dictionaries.length <= 1) {\n    return dictionaries[0]!;\n  }\n\n  const dictionariesKeys = dictionaries.map((dict) => dict.key);\n\n  // Check if all dictionaries have the same key\n  if (new Set(dictionariesKeys).size !== 1) {\n    throw new Error('All dictionaries must have the same key');\n  }\n\n  let mergedContent: Dictionary['content'] = dictionaries[0].content;\n\n  for (let i = 1; i < dictionaries.length; i++) {\n    const dict = dictionaries[i];\n\n    if (!dict) continue;\n\n    // If the dictionary is a per-locale dictionary, transform it to a partial multilingual dictionary\n    const currentDictionary = getMultilingualDictionary(dict);\n\n    // Check types before merging\n    checkTypesMatch(\n      mergedContent,\n      currentDictionary.content,\n      currentDictionary.localId,\n      currentDictionary.key,\n      []\n    );\n\n    mergedContent = customMerge(\n      mergedContent,\n      currentDictionary.content\n    ) as ContentNode;\n  }\n\n  const mergedDictionary: Dictionary = {\n    key: dictionaries[0].key,\n    content: mergedContent,\n    localIds,\n  };\n\n  return mergedDictionary;\n};\n"],"mappings":";;;;;;;;AAaA,MAAM,mBACJ,SACA,SACA,gBACA,eACA,OAAiB,EAAE,KACV;CACT,MAAM,sDAAyB,EAAE,iCAAK,CAAC;AAGvC,KACE,YAAY,UACZ,YAAY,QACZ,YAAY,UACZ,YAAY,KAEZ;CAEF,MAAM,QAAQA,sDAAY,QAAQ;CAClC,MAAM,QAAQA,sDAAY,QAAQ;AAGlC,KAAI,UAAU,aAAa,UAAU,UAAW;AAEhD,KAAI,UAAU,OAAO;AACnB,YACE,CACE,8DAAiC,cAAc,CAAC,4DAA4D,KAAK,KAAK,IAAI,CAAC,kBAAkB,MAAM,QAAQ,MAAM,iBAAiB,iBACnL,EACD,EACE,OAAO,SACR,CACF;AAED;;;AAKJ,MAAM,eACJ,aACA,WACqB;AAErB,KAAI,gBAAgB,UAAa,gBAAgB,KAC/C,QAAO;AAIT,KAAI,WAAW,UAAa,WAAW,KACrC,QAAO;AAIT,KAAI,OAAO,gBAAgB,YAAY,OAAO,WAAW,SACvD,QAAO;AAIT,KAAI,MAAM,QAAQ,YAAY,IAAI,MAAM,QAAQ,OAAO,CACrD,QAAO,WACL,aACA,OACD;AAIH,KAAI,OAAO,gBAAgB,YAAY,OAAO,WAAW,UAAU;EACjE,MAAM,SAA2C,EAAE;EACnD,MAAM,UAAU,IAAI,IAAI,CACtB,GAAG,OAAO,KAAK,YAAsD,EACrE,GAAG,OAAO,KAAK,OAAiD,CACjE,CAAC;AAEF,OAAK,MAAM,OAAO,QAChB,QAAO,OAAO,YACX,YAAuD,MACvD,OAAkD,KACpD;AAGH,SAAO;;AAIT,QAAO;;AAIT,MAAM,cACJ,kBACA,gBACuB;CAEvB,MAAM,wBAAwB,iBAAiB,OAC5C,SAAS,OAAO,SAAS,YAAY,SAAS,KAChD;CACD,MAAM,0BAA0B,YAAY,OACzC,SAAS,OAAO,SAAS,YAAY,SAAS,KAChD;AAGD,KAAI,yBAAyB,wBAC3B,QAAO;CAIT,MAAM,SAA6B,EAAE;CACrC,MAAM,YAAY,KAAK,IAAI,iBAAiB,QAAQ,YAAY,OAAO;AAEvE,MAAK,IAAI,IAAI,GAAG,IAAI,WAAW,KAAK;EAClC,MAAM,WAAW,iBAAiB;EAClC,MAAM,aAAa,YAAY;AAE/B,MAAI,aAAa,UAAa,eAAe,QAAW,YAC7C,aAAa,OAEtB,QAAO,KAAK,WAAW;WACd,eAAe,OAExB,QAAO,KAAK,SAAS;WAInB,OAAO,aAAa,YACpB,OAAO,eAAe,YACtB,aAAa,QACb,eAAe,KAGf,KACE,SAAS,YACT,SAAS,cACR,SAAoC,QAClC,WAAsC,IAGzC,QAAO,KAAK,YAAY,UAAU,WAAW,CAAC;MAG9C,QAAO,KAAK,YAAY,UAAU,WAAW,CAAC;MAIhD,QAAO,KAAK,SAAS;;AAK3B,QAAO;;AAGT,MAAa,qBAAqB,iBAA2C;CAC3E,MAAM,WAAW,MAAM,KACrB,IAAI,IACF,aAAa,QAAQ,SAAS,KAAK,QAAQ,CAAC,KAAK,SAAS,KAAK,QAAS,CACzE,CACF;AAED,KAAI,CAAC,aAAa,MAAM,aAAa,UAAU,EAC7C,QAAO,aAAa;CAGtB,MAAM,mBAAmB,aAAa,KAAK,SAAS,KAAK,IAAI;AAG7D,KAAI,IAAI,IAAI,iBAAiB,CAAC,SAAS,EACrC,OAAM,IAAI,MAAM,0CAA0C;CAG5D,IAAI,gBAAuC,aAAa,GAAG;AAE3D,MAAK,IAAI,IAAI,GAAG,IAAI,aAAa,QAAQ,KAAK;EAC5C,MAAM,OAAO,aAAa;AAE1B,MAAI,CAAC,KAAM;EAGX,MAAM,oBAAoBC,iFAA0B,KAAK;AAGzD,kBACE,eACA,kBAAkB,SAClB,kBAAkB,SAClB,kBAAkB,KAClB,EAAE,CACH;AAED,kBAAgB,YACd,eACA,kBAAkB,QACnB;;AASH,QAAO;EALL,KAAK,aAAa,GAAG;EACrB,SAAS;EACT;EAGqB"}

package/dist/cjs/dictionaryManipulator/mergeQualifiedDictionaries.cjs

@@ -0,0 +1,70 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+const require_dictionaryManipulator_qualifiedDictionary = require('./qualifiedDictionary.cjs');
+const require_dictionaryManipulator_mergeDictionaries = require('./mergeDictionaries.cjs');
+let _intlayer_config_built = require("@intlayer/config/built");
+let _intlayer_config_logger = require("@intlayer/config/logger");
+
+//#region src/dictionaryManipulator/mergeQualifiedDictionaries.ts
+/**
+* Merges sibling dictionaries sharing the same key, honouring qualifiers.
+*
+* - No dictionary declares a qualifier → behaves exactly like
+*   `mergeDictionaries` (single merged dictionary).
+* - At least one dictionary declares a qualifier → the group's dimension set is
+*   the union of every declared dimension (in canonical order
+*   `variant → meta → 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.
+*
+* 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.
+*/
+const mergeQualifiedDictionaries = (dictionaries) => {
+	const perDictionaryTypes = dictionaries.map(require_dictionaryManipulator_qualifiedDictionary.getDictionaryQualifierTypes);
+	const declaredDimensions = /* @__PURE__ */ new Set();
+	for (const types of perDictionaryTypes) for (const type of types) declaredDimensions.add(type);
+	const groupQualifierTypes = require_dictionaryManipulator_qualifiedDictionary.QUALIFIER_ORDER.filter((qualifierType) => declaredDimensions.has(qualifierType));
+	if (groupQualifierTypes.length === 0) return require_dictionaryManipulator_mergeDictionaries.mergeDictionaries(dictionaries);
+	const appLogger = (0, _intlayer_config_logger.getAppLogger)({ log: _intlayer_config_built.log });
+	const baseDictionaries = [];
+	const entriesDictionaries = /* @__PURE__ */ new Map();
+	dictionaries.forEach((dictionary, index) => {
+		if (perDictionaryTypes[index].length === 0) {
+			baseDictionaries.push(dictionary);
+			return;
+		}
+		const compositeId = require_dictionaryManipulator_qualifiedDictionary.getDictionaryCompositeId(dictionary, groupQualifierTypes);
+		if (compositeId === void 0) {
+			appLogger(`Dictionary ${(0, _intlayer_config_logger.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}` : ""}.`, { level: "error" });
+			return;
+		}
+		const existingEntries = entriesDictionaries.get(compositeId) ?? [];
+		existingEntries.push(dictionary);
+		entriesDictionaries.set(compositeId, existingEntries);
+	});
+	const content = {};
+	const metaByCompositeId = {};
+	const declaresMeta = groupQualifierTypes.includes("meta");
+	let importMode;
+	for (const [compositeId, qualifiedDictionaries] of entriesDictionaries) {
+		content[compositeId] = require_dictionaryManipulator_mergeDictionaries.mergeDictionaries([...qualifiedDictionaries, ...baseDictionaries]).content;
+		const [firstQualified] = qualifiedDictionaries;
+		if (declaresMeta && firstQualified?.meta !== void 0) metaByCompositeId[compositeId] = firstQualified.meta;
+		importMode ??= firstQualified?.importMode;
+	}
+	const localIds = Array.from(new Set(dictionaries.filter((dictionary) => dictionary.localId).map((dictionary) => dictionary.localId)));
+	return {
+		key: dictionaries[0].key,
+		qualifierTypes: groupQualifierTypes,
+		content,
+		...declaresMeta && { meta: metaByCompositeId },
+		...importMode !== void 0 && { importMode },
+		localIds
+	};
+};
+
+//#endregion
+exports.mergeQualifiedDictionaries = mergeQualifiedDictionaries;
+//# sourceMappingURL=mergeQualifiedDictionaries.cjs.map

package/dist/cjs/dictionaryManipulator/mergeQualifiedDictionaries.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mergeQualifiedDictionaries.cjs","names":["getDictionaryQualifierTypes","QUALIFIER_ORDER","mergeDictionaries","getDictionaryCompositeId"],"sources":["../../../src/dictionaryManipulator/mergeQualifiedDictionaries.ts"],"sourcesContent":["import { log } from '@intlayer/config/built';\nimport { colorizeKey, getAppLogger } from '@intlayer/config/logger';\nimport type {\n  Dictionary,\n  DictionaryMeta,\n  DictionaryQualifierType,\n  QualifiedDictionaryGroup,\n} from '@intlayer/types/dictionary';\nimport { mergeDictionaries } from './mergeDictionaries';\nimport {\n  getDictionaryCompositeId,\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 → meta → 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    const compositeId = getDictionaryCompositeId(\n      dictionary,\n      groupQualifierTypes\n    );\n\n    if (compositeId === 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    const existingEntries = entriesDictionaries.get(compositeId) ?? [];\n    existingEntries.push(dictionary);\n    entriesDictionaries.set(compositeId, existingEntries);\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. `meta`\n  // preserves the declared meta fields (composite id only encodes `meta.id`).\n  const content: Record<string, unknown> = {};\n  const metaByCompositeId: Record<string, DictionaryMeta> = {};\n  const declaresMeta = groupQualifierTypes.includes('meta');\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    if (declaresMeta && firstQualified?.meta !== undefined) {\n      metaByCompositeId[compositeId] = firstQualified.meta;\n    }\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    ...(declaresMeta && { meta: metaByCompositeId }),\n    ...(importMode !== undefined && { importMode }),\n    localIds,\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA8BA,MAAa,8BACX,iBAC0C;CAC1C,MAAM,qBAAqB,aAAa,IAAIA,8EAA4B;CAExE,MAAM,qCAAqB,IAAI,KAA8B;AAC7D,MAAK,MAAM,SAAS,mBAClB,MAAK,MAAM,QAAQ,MAAO,oBAAmB,IAAI,KAAK;CAIxD,MAAM,sBAAsBC,kEAAgB,QAAQ,kBAClD,mBAAmB,IAAI,cAAc,CACtC;AAED,KAAI,oBAAoB,WAAW,EACjC,QAAOC,kEAAkB,aAAa;CAGxC,MAAM,sDAAyB,EAAE,iCAAK,CAAC;CAEvC,MAAM,mBAAiC,EAAE;CACzC,MAAM,sCAAsB,IAAI,KAA2B;AAE3D,cAAa,SAAS,YAAY,UAAU;AAC1C,MAAI,mBAAmB,OAAO,WAAW,GAAG;AAC1C,oBAAiB,KAAK,WAAW;AACjC;;EAGF,MAAM,cAAcC,2EAClB,YACA,oBACD;AAED,MAAI,gBAAgB,QAAW;AAC7B,aACE,uDAA0B,WAAW,IAAI,CAAC,aAAa,mBAAmB,OAAO,KAAK,KAAK,CAAC,kCAAkC,oBAAoB,KAAK,KAAK,CAAC,wDAAwD,WAAW,WAAW,MAAM,WAAW,aAAa,GAAG,IAC5Q,EAAE,OAAO,SAAS,CACnB;AACD;;EAGF,MAAM,kBAAkB,oBAAoB,IAAI,YAAY,IAAI,EAAE;AAClE,kBAAgB,KAAK,WAAW;AAChC,sBAAoB,IAAI,aAAa,gBAAgB;GACrD;CAKF,MAAM,UAAmC,EAAE;CAC3C,MAAM,oBAAoD,EAAE;CAC5D,MAAM,eAAe,oBAAoB,SAAS,OAAO;CAEzD,IAAI;AAEJ,MAAK,MAAM,CAAC,aAAa,0BAA0B,qBAAqB;AAQtE,UAAQ,eALYD,kEAAkB,CACpC,GAAG,uBACH,GAAG,iBACJ,CAEiC,CAAC;EAEnC,MAAM,CAAC,kBAAkB;AAEzB,MAAI,gBAAgB,gBAAgB,SAAS,OAC3C,mBAAkB,eAAe,eAAe;AAGlD,iBAAe,gBAAgB;;CAGjC,MAAM,WAAW,MAAM,KACrB,IAAI,IACF,aACG,QAAQ,eAAe,WAAW,QAAQ,CAC1C,KAAK,eAAe,WAAW,QAAS,CAC5C,CACF;AAED,QAAO;EACL,KAAK,aAAa,GAAI;EACtB,gBAAgB;EAChB;EACA,GAAI,gBAAgB,EAAE,MAAM,mBAAmB;EAC/C,GAAI,eAAe,UAAa,EAAE,YAAY;EAC9C;EACD"}

package/dist/cjs/dictionaryManipulator/qualifiedDictionary.cjs

@@ -0,0 +1,302 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/dictionaryManipulator/qualifiedDictionary.ts
+/**
+* Selector keys that are reserved for dictionary resolution and therefore
+* excluded from meta field matching.
+*/
+const RESERVED_SELECTOR_KEYS = [
+	"locale",
+	"item",
+	"variant"
+];
+/**
+* Canonical order of qualifier dimensions. A key that declares several
+* dimensions always nests them in this order, with `item` innermost so it can
+* act as the collection (array) axis.
+*/
+const QUALIFIER_ORDER = [
+	"variant",
+	"meta",
+	"item"
+];
+/**
+* Separator joining per-dimension ids into a composite entry id. Also used as
+* the chunk path separator in dynamic mode.
+*/
+const COMPOSITE_ID_SEPARATOR = "/";
+/**
+* Returns the qualifier dimensions declared on a dictionary, in canonical
+* order (`variant → meta → item`). Empty when the dictionary is unqualified
+* (plain dictionary or shared base content of a qualified group).
+*/
+const getDictionaryQualifierTypes = (dictionary) => {
+	const declaredQualifiers = [];
+	if (typeof dictionary.variant === "string") declaredQualifiers.push("variant");
+	if (dictionary.meta !== void 0) declaredQualifiers.push("meta");
+	if (typeof dictionary.item === "number") declaredQualifiers.push("item");
+	return declaredQualifiers;
+};
+/**
+* Returns the qualifier identifier of a dictionary for the given qualifier
+* dimension — one segment of the composite entry id.
+*
+* - 'variant' → the variant name
+* - 'meta' → the `meta.id` discriminator
+* - 'item' → the item index as string
+*/
+const getDictionaryQualifierId = (dictionary, qualifierType) => {
+	if (qualifierType === "variant") return dictionary.variant;
+	if (qualifierType === "meta") {
+		const metaId = dictionary.meta?.id;
+		return metaId === void 0 ? void 0 : String(metaId);
+	}
+	return dictionary.item === void 0 ? void 0 : String(dictionary.item);
+};
+/**
+* Returns the per-dimension id segments of a dictionary for the given ordered
+* dimension set, or `undefined` when the dictionary does not declare every
+* dimension of the set.
+*/
+const getDictionaryQualifierSegments = (dictionary, qualifierTypes) => {
+	const segments = [];
+	for (const qualifierType of qualifierTypes) {
+		const id = getDictionaryQualifierId(dictionary, qualifierType);
+		if (id === void 0) return void 0;
+		segments.push(id);
+	}
+	return segments;
+};
+/**
+* Builds the composite entry id of a dictionary — its per-dimension id segments
+* joined in canonical order. `undefined` when a dimension is missing.
+*/
+const getDictionaryCompositeId = (dictionary, qualifierTypes) => getDictionaryQualifierSegments(dictionary, qualifierTypes)?.join("/");
+/**
+* Checks that every declared meta field is provided and equal in the selector.
+* Reserved keys (`locale`, `item`, `variant`) are skipped; `meta.id` is part of
+* the equality check.
+*/
+const metaFieldsMatch = (meta, selector) => {
+	if (!meta) return false;
+	return Object.entries(meta).every(([metaField, declaredValue]) => {
+		if (RESERVED_SELECTOR_KEYS.includes(metaField)) return true;
+		const providedValue = selector?.[metaField];
+		return providedValue !== void 0 && String(providedValue) === String(declaredValue);
+	});
+};
+/**
+* Tests whether a group entry matches a selector across every declared
+* dimension. The `item` dimension matches any value when the selector does not
+* provide one (open collection axis).
+*/
+const entryMatchesSelector = (entry, qualifierTypes, selector) => qualifierTypes.every((qualifierType) => {
+	if (qualifierType === "variant") return entry.variant === (selector?.variant ?? "default");
+	if (qualifierType === "item") return selector?.item === void 0 || String(entry.item) === String(selector.item);
+	return metaFieldsMatch(entry.meta, selector);
+});
+/**
+* Type guard discriminating a `QualifiedDictionaryGroup` (merge output of a
+* qualified key) from a plain `Dictionary`. Both carry a `content` field; only
+* the group declares `qualifierTypes`, which is therefore the discriminator.
+*/
+const isQualifiedDictionaryGroup = (value) => typeof value === "object" && value !== null && "qualifierTypes" in value && Array.isArray(value.qualifierTypes) && "content" in value;
+/**
+* Reconstructs a resolvable {@link Dictionary} from a single entry of a
+* qualified group: the content node stored under its composite id, plus the
+* qualifier coordinates decoded from that id (`variant`, `item`) and the
+* preserved `meta` object for the meta dimension.
+*
+* This keeps the resolver's matching/transform code unchanged: it still sees a
+* `{ key, content, variant?, item?, meta? }` shape, even though the stored
+* format no longer duplicates those fields per entry.
+*/
+const reconstructQualifiedEntry = (group, compositeId) => {
+	const segments = compositeId.split("/");
+	const entry = {
+		key: group.key,
+		content: group.content[compositeId]
+	};
+	group.qualifierTypes.forEach((qualifierType, index) => {
+		if (qualifierType === "variant") entry.variant = segments[index];
+		else if (qualifierType === "item") entry.item = Number(segments[index]);
+	});
+	if (group.qualifierTypes.includes("meta")) {
+		const metaIndex = group.qualifierTypes.indexOf("meta");
+		entry.meta = group.meta?.[compositeId] ?? { id: segments[metaIndex] };
+	}
+	return entry;
+};
+/**
+* Resolves a dictionary (or qualified dictionary group) against a selector,
+* across every declared dimension.
+*
+* - 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
+* - `meta` requires `{ id }` and every declared meta field to match
+*
+* Dimensions compose: e.g. a variant × item key with `{ variant: 'promo' }`
+* returns every promo item as an array; adding `{ item: 2 }` narrows to one.
+*/
+const resolveQualifiedDictionary = (dictionaryOrGroup, selector) => {
+	if (!isQualifiedDictionaryGroup(dictionaryOrGroup)) return dictionaryOrGroup;
+	const { qualifierTypes, content } = dictionaryOrGroup;
+	if (qualifierTypes.includes("meta") && selector?.id === void 0) return null;
+	const itemAxisOpen = qualifierTypes.includes("item") && selector?.item === void 0;
+	const matchedEntries = Object.keys(content).map((compositeId) => reconstructQualifiedEntry(dictionaryOrGroup, compositeId)).filter((entry) => entryMatchesSelector(entry, qualifierTypes, selector));
+	if (itemAxisOpen) return matchedEntries.sort((left, right) => (left.item ?? 0) - (right.item ?? 0));
+	return matchedEntries[0] ?? null;
+};
+/**
+* Splits the second argument of `getIntlayer` / `getDictionary` into the
+* effective locale and the selector object (if any).
+*/
+const parseDictionarySelector = (localeOrSelector) => {
+	if (typeof localeOrSelector === "object" && localeOrSelector !== null) return {
+		locale: localeOrSelector.locale,
+		selector: localeOrSelector
+	};
+	return { locale: localeOrSelector };
+};
+/**
+* Builds a stable string identity of a selector (excluding `locale`), suitable
+* for cache keys and memoization dependencies.
+*/
+const getDictionarySelectorCacheKey = (selector) => {
+	if (!selector) return "";
+	return Object.keys(selector).filter((selectorKey) => selectorKey !== "locale").sort().map((selectorKey) => `${selectorKey}:${String(selector[selectorKey])}`).join("|");
+};
+/**
+* Marker property carrying the ordered qualifier dimensions on a dynamic loader
+* map. Its presence distinguishes a qualified group loader map (a nested tree
+* of chunks) from a plain dynamic loader map (one chunk per `locale`). Prefixed
+* and unlikely to collide with a real locale code.
+*/
+const QUALIFIER_DYNAMIC_TYPES_KEY = "__intlayerQualifierTypes";
+/**
+* Type guard discriminating a qualified dynamic loader map (collections /
+* variants / meta records, possibly combined) from a plain dynamic loader map.
+*/
+const isQualifiedDynamicLoaderMap = (value) => typeof value === "object" && value !== null && "__intlayerQualifierTypes" in value;
+/**
+* Walks the loader tree following the selector and collects the chunk loaders
+* it targets — shared by the sync ({@link resolveQualifiedDynamicContent}) and
+* async ({@link resolveQualifiedDynamicContentAsync}) resolvers.
+*/
+const collectQualifiedChunks = (loaderMap, key, locale, selector) => {
+	const qualifierTypes = loaderMap[QUALIFIER_DYNAMIC_TYPES_KEY];
+	const localeTree = loaderMap[locale];
+	const itemAxisOpen = qualifierTypes.includes("item") && selector?.item === void 0;
+	if (!localeTree) return {
+		itemAxisOpen,
+		missed: true,
+		chunks: []
+	};
+	if (qualifierTypes.includes("meta") && selector?.id === void 0) return {
+		itemAxisOpen,
+		missed: true,
+		chunks: []
+	};
+	const chunks = [];
+	const walk = (node, dimensions, segments) => {
+		if (dimensions.length === 0) {
+			chunks.push({
+				cacheKey: `${key}.${locale}.${segments.join("/")}`,
+				loader: node
+			});
+			return true;
+		}
+		const [dimension, ...rest] = dimensions;
+		const tree = node;
+		if (dimension === "item" && selector?.item === void 0) {
+			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" ? selector?.variant ?? "default" : dimension === "meta" ? String(selector?.id) : String(selector?.item);
+		const child = tree[segment];
+		if (!child) return false;
+		return walk(child, rest, [...segments, segment]);
+	};
+	return {
+		itemAxisOpen,
+		missed: !walk(localeTree, qualifierTypes, []),
+		chunks
+	};
+};
+/**
+* Whether a loaded chunk satisfies the selector's meta fields (no-op unless the
+* key declares a `meta` dimension).
+*/
+const chunkMatchesMeta = (loaderMap, dictionary, selector) => !loaderMap["__intlayerQualifierTypes"].includes("meta") || metaFieldsMatch(dictionary.meta, selector);
+/**
+* Resolves the content of a qualified dynamic loader map against a selector,
+* loading only the chunk(s) the selector actually targets.
+*
+* Walks the nested loader tree one dimension at a time (canonical order
+* `variant → meta → item`): `variant` defaults to `default`, `meta` descends by
+* `id`, and `item` either narrows to the selected index or — when no item is
+* given — expands into every sibling chunk (the collection axis). Meta-equality
+* is verified on the loaded chunk. 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
+* targeted loader is started before the first chunk is read, so sibling chunks
+* load in parallel rather than waterfalling.
+*
+* @param loaderMap - The qualified dynamic loader map (entry point default export).
+* @param key - The dictionary key (used to build stable chunk cache keys).
+* @param locale - The resolved locale to load chunks for.
+* @param selector - The selector splitting the qualifier dimensions.
+* @param loadChunk - Reads a started chunk promise, suspending until it resolves.
+* @param transform - Turns a resolved chunk dictionary into final content.
+*/
+const resolveQualifiedDynamicContent = (params) => {
+	const { loaderMap, key, locale, selector, loadChunk, transform } = params;
+	const { itemAxisOpen, missed, chunks } = collectQualifiedChunks(loaderMap, key, locale, selector);
+	if (missed) return itemAxisOpen ? [] : null;
+	const dictionaries = chunks.map(({ cacheKey, loader }) => loadChunk(cacheKey, loader())).filter((dictionary) => chunkMatchesMeta(loaderMap, dictionary, selector));
+	if (itemAxisOpen) return dictionaries.map(transform);
+	const [dictionary] = dictionaries;
+	return dictionary ? transform(dictionary) : null;
+};
+/**
+* Async counterpart of {@link resolveQualifiedDynamicContent} for frameworks
+* that load dictionaries with `await` instead of Suspense (Vue, Svelte, Lit,
+* vanilla). Awaits every targeted chunk in parallel, then resolves identically.
+*
+* @param loaderMap - The qualified dynamic loader map.
+* @param key - The dictionary key (used to build stable chunk cache keys).
+* @param locale - The resolved locale to load chunks for.
+* @param selector - The selector splitting the qualifier dimensions.
+* @param transform - Turns a resolved chunk dictionary into final content.
+*/
+const resolveQualifiedDynamicContentAsync = async (params) => {
+	const { loaderMap, key, locale, selector, transform } = params;
+	const { itemAxisOpen, missed, chunks } = collectQualifiedChunks(loaderMap, key, locale, selector);
+	if (missed) return itemAxisOpen ? [] : null;
+	const dictionaries = (await Promise.all(chunks.map(({ loader }) => loader()))).filter((dictionary) => chunkMatchesMeta(loaderMap, dictionary, selector));
+	if (itemAxisOpen) return dictionaries.map(transform);
+	const [dictionary] = dictionaries;
+	return dictionary ? transform(dictionary) : null;
+};
+
+//#endregion
+exports.COMPOSITE_ID_SEPARATOR = COMPOSITE_ID_SEPARATOR;
+exports.QUALIFIER_DYNAMIC_TYPES_KEY = QUALIFIER_DYNAMIC_TYPES_KEY;
+exports.QUALIFIER_ORDER = QUALIFIER_ORDER;
+exports.getDictionaryCompositeId = getDictionaryCompositeId;
+exports.getDictionaryQualifierId = getDictionaryQualifierId;
+exports.getDictionaryQualifierSegments = getDictionaryQualifierSegments;
+exports.getDictionaryQualifierTypes = getDictionaryQualifierTypes;
+exports.getDictionarySelectorCacheKey = getDictionarySelectorCacheKey;
+exports.isQualifiedDictionaryGroup = isQualifiedDictionaryGroup;
+exports.isQualifiedDynamicLoaderMap = isQualifiedDynamicLoaderMap;
+exports.parseDictionarySelector = parseDictionarySelector;
+exports.reconstructQualifiedEntry = reconstructQualifiedEntry;
+exports.resolveQualifiedDictionary = resolveQualifiedDictionary;
+exports.resolveQualifiedDynamicContent = resolveQualifiedDynamicContent;
+exports.resolveQualifiedDynamicContentAsync = resolveQualifiedDynamicContentAsync;
+//# sourceMappingURL=qualifiedDictionary.cjs.map