@intlayer/core 9.2.0 → 9.3.1

package/dist/cjs/dictionaryManipulator/getNestedDictionaryReferences.cjs

@@ -0,0 +1,153 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let _intlayer_types_nodeType = require("@intlayer/types/nodeType");
+
+//#region src/dictionaryManipulator/getNestedDictionaryReferences.ts
+/**
+* Compact alias some minified pipelines emit in place of `nodeType: 'nested'`.
+* Matched defensively so the scan keeps working on already-minified content.
+*/
+const MINIFIED_NESTED_NODE_TYPE = "n";
+/**
+* Narrows a value to a traversable object (plain object or array). `null` is
+* excluded even though `typeof null === 'object'`.
+*/
+const isTraversable = (value) => typeof value === "object" && value !== null;
+/**
+* Records one `nest()` reference, widening the entry to `'all'` as soon as a
+* reference targets the whole dictionary.
+*/
+const addNestedReference = (references, dictionaryKey, path) => {
+	const existingReference = references.get(dictionaryKey);
+	if (existingReference === "all") return;
+	const rootField = path?.split(".")[0];
+	if (!rootField) {
+		references.set(dictionaryKey, "all");
+		return;
+	}
+	if (existingReference) {
+		existingReference.add(rootField);
+		return;
+	}
+	references.set(dictionaryKey, /* @__PURE__ */ new Set([rootField]));
+};
+/**
+* Walks a dictionary tree and collects every dictionary referenced through a
+* `nest()` node, together with the top-level fields those references read.
+*
+* The walk is iterative (no recursion depth limit) and guards against shared
+* or circular references, so it is safe on both compiled JSON and in-memory
+* dictionaries.
+*
+* @param dictionaries - Dictionary objects (or any content subtree) to scan.
+* @returns Map of nest-target dictionary key → referenced top-level fields.
+*
+* @example
+* ```ts
+* // dashboard.content.ts → { period: nest('common', 'period') }
+* getNestedDictionaryReferences([dashboardDictionary]);
+* // Map { 'common' => Set { 'period' } }
+* ```
+*/
+const getNestedDictionaryReferences = (dictionaries) => {
+	const references = /* @__PURE__ */ new Map();
+	const stack = [...dictionaries];
+	const visitedNodes = /* @__PURE__ */ new Set();
+	while (stack.length > 0) {
+		const node = stack.pop();
+		if (!isTraversable(node)) continue;
+		if (visitedNodes.has(node)) continue;
+		visitedNodes.add(node);
+		if (Array.isArray(node)) {
+			stack.push(...node);
+			continue;
+		}
+		const { nodeType } = node;
+		if (nodeType === _intlayer_types_nodeType.NESTED || nodeType === MINIFIED_NESTED_NODE_TYPE) {
+			const nestedState = node[nodeType];
+			if (isTraversable(nestedState)) {
+				const { dictionaryKey, path } = nestedState;
+				if (typeof dictionaryKey === "string") addNestedReference(references, dictionaryKey, typeof path === "string" ? path : void 0);
+			}
+			continue;
+		}
+		stack.push(...Object.values(node));
+	}
+	return references;
+};
+/**
+* Keys of every dictionary referenced through a `nest()` node.
+*
+* @param dictionaries - Dictionary objects (or any content subtree) to scan.
+* @returns Set of nest-target dictionary keys.
+*/
+const getNestedDictionaryKeys = (dictionaries) => new Set(getNestedDictionaryReferences(dictionaries).keys());
+/**
+* Expands direct nest edges into their transitive closure, so a consumer that
+* nests a dictionary which itself nests another ends up depending on both.
+*
+* Self-references and cycles are absorbed: a key never appears in its own
+* dependency set, and the walk terminates on cyclic graphs.
+*/
+const closeOverNestedEdges = (directEdges) => {
+	const closedEdges = /* @__PURE__ */ new Map();
+	for (const [consumerKey, directTargets] of directEdges) {
+		const allTargets = /* @__PURE__ */ new Set();
+		const pending = [...directTargets];
+		while (pending.length > 0) {
+			const targetKey = pending.pop();
+			if (targetKey === consumerKey) continue;
+			if (allTargets.has(targetKey)) continue;
+			allTargets.add(targetKey);
+			const transitiveTargets = directEdges.get(targetKey);
+			if (transitiveTargets) pending.push(...transitiveTargets);
+		}
+		closedEdges.set(consumerKey, allTargets);
+	}
+	return closedEdges;
+};
+/**
+* Builds the `nest()` dependency graph of a set of dictionaries: for each
+* dictionary key, the keys of every dictionary it needs in order to resolve its
+* nested nodes, transitively.
+*
+* The build optimization uses this to attach the nest targets to the dictionary
+* artifact itself, so `nest()` resolves from a local reference and the target
+* lands in the same chunk (or the same lazy per-locale loader) as the
+* dictionary referencing it.
+*
+* Dictionaries without nested nodes are absent from the result.
+*
+* @param dictionaries - Compiled dictionaries to scan; each must carry its `key`.
+* @returns Map of dictionary key → keys it depends on through `nest()`.
+*
+* @example
+* ```ts
+* // dashboard nests common, common nests labels
+* getNestedDictionaryGraph([dashboard, common]);
+* // Map { 'dashboard' => Set { 'common', 'labels' }, 'common' => Set { 'labels' } }
+* ```
+*/
+const getNestedDictionaryGraph = (dictionaries) => {
+	const directEdges = /* @__PURE__ */ new Map();
+	for (const dictionary of dictionaries) {
+		if (!isTraversable(dictionary)) continue;
+		const { key } = dictionary;
+		if (typeof key !== "string") continue;
+		const targets = getNestedDictionaryKeys([dictionary]);
+		targets.delete(key);
+		if (targets.size === 0) continue;
+		const existingTargets = directEdges.get(key);
+		if (existingTargets) {
+			for (const target of targets) existingTargets.add(target);
+			continue;
+		}
+		directEdges.set(key, targets);
+	}
+	return closeOverNestedEdges(directEdges);
+};
+
+//#endregion
+exports.getNestedDictionaryGraph = getNestedDictionaryGraph;
+exports.getNestedDictionaryKeys = getNestedDictionaryKeys;
+exports.getNestedDictionaryReferences = getNestedDictionaryReferences;
+//# sourceMappingURL=getNestedDictionaryReferences.cjs.map

package/dist/cjs/dictionaryManipulator/getNestedDictionaryReferences.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"getNestedDictionaryReferences.cjs","names":["NESTED"],"sources":["../../../src/dictionaryManipulator/getNestedDictionaryReferences.ts"],"sourcesContent":["import { NESTED } from '@intlayer/types/nodeType';\n\n/**\n * Top-level content fields of a nest target that are referenced through\n * `nest()` nodes.\n *\n * `'all'` means at least one reference targets the whole dictionary\n * (`nest('common')` without a path), so no field of that dictionary may be\n * dropped.\n */\nexport type NestedFieldReferences = Set<string> | 'all';\n\n/**\n * Compact alias some minified pipelines emit in place of `nodeType: 'nested'`.\n * Matched defensively so the scan keeps working on already-minified content.\n */\nconst MINIFIED_NESTED_NODE_TYPE = 'n';\n\ntype UnknownRecord = Record<string, unknown>;\n\n/**\n * Narrows a value to a traversable object (plain object or array). `null` is\n * excluded even though `typeof null === 'object'`.\n */\nconst isTraversable = (value: unknown): value is UnknownRecord =>\n  typeof value === 'object' && value !== null;\n\n/**\n * Records one `nest()` reference, widening the entry to `'all'` as soon as a\n * reference targets the whole dictionary.\n */\nconst addNestedReference = (\n  references: Map<string, NestedFieldReferences>,\n  dictionaryKey: string,\n  path: string | undefined\n): void => {\n  const existingReference = references.get(dictionaryKey);\n\n  if (existingReference === 'all') return;\n\n  // `getNesting` returns the whole dictionary when no path is given, and also\n  // falls back to it when the path cannot be resolved — both cases require\n  // every field to stay available.\n  const rootField = path?.split('.')[0];\n\n  if (!rootField) {\n    references.set(dictionaryKey, 'all');\n    return;\n  }\n\n  if (existingReference) {\n    existingReference.add(rootField);\n    return;\n  }\n\n  references.set(dictionaryKey, new Set([rootField]));\n};\n\n/**\n * Walks a dictionary tree and collects every dictionary referenced through a\n * `nest()` node, together with the top-level fields those references read.\n *\n * The walk is iterative (no recursion depth limit) and guards against shared\n * or circular references, so it is safe on both compiled JSON and in-memory\n * dictionaries.\n *\n * @param dictionaries - Dictionary objects (or any content subtree) to scan.\n * @returns Map of nest-target dictionary key → referenced top-level fields.\n *\n * @example\n * ```ts\n * // dashboard.content.ts → { period: nest('common', 'period') }\n * getNestedDictionaryReferences([dashboardDictionary]);\n * // Map { 'common' => Set { 'period' } }\n * ```\n */\nexport const getNestedDictionaryReferences = (\n  dictionaries: Iterable<unknown>\n): Map<string, NestedFieldReferences> => {\n  const references = new Map<string, NestedFieldReferences>();\n  const stack: unknown[] = [...dictionaries];\n  const visitedNodes = new Set<object>();\n\n  while (stack.length > 0) {\n    const node = stack.pop();\n\n    if (!isTraversable(node)) continue;\n    if (visitedNodes.has(node)) continue;\n    visitedNodes.add(node);\n\n    if (Array.isArray(node)) {\n      stack.push(...node);\n      continue;\n    }\n\n    const { nodeType } = node;\n\n    if (nodeType === NESTED || nodeType === MINIFIED_NESTED_NODE_TYPE) {\n      const nestedState = node[nodeType];\n\n      if (isTraversable(nestedState)) {\n        const { dictionaryKey, path } = nestedState;\n\n        if (typeof dictionaryKey === 'string') {\n          addNestedReference(\n            references,\n            dictionaryKey,\n            typeof path === 'string' ? path : undefined\n          );\n        }\n      }\n\n      // A nested node only carries the reference descriptor — no sub-content.\n      continue;\n    }\n\n    stack.push(...Object.values(node));\n  }\n\n  return references;\n};\n\n/**\n * Keys of every dictionary referenced through a `nest()` node.\n *\n * @param dictionaries - Dictionary objects (or any content subtree) to scan.\n * @returns Set of nest-target dictionary keys.\n */\nexport const getNestedDictionaryKeys = (\n  dictionaries: Iterable<unknown>\n): Set<string> => new Set(getNestedDictionaryReferences(dictionaries).keys());\n\n/**\n * Expands direct nest edges into their transitive closure, so a consumer that\n * nests a dictionary which itself nests another ends up depending on both.\n *\n * Self-references and cycles are absorbed: a key never appears in its own\n * dependency set, and the walk terminates on cyclic graphs.\n */\nconst closeOverNestedEdges = (\n  directEdges: Map<string, Set<string>>\n): Map<string, Set<string>> => {\n  const closedEdges = new Map<string, Set<string>>();\n\n  for (const [consumerKey, directTargets] of directEdges) {\n    const allTargets = new Set<string>();\n    const pending = [...directTargets];\n\n    while (pending.length > 0) {\n      const targetKey = pending.pop()!;\n\n      if (targetKey === consumerKey) continue;\n      if (allTargets.has(targetKey)) continue;\n      allTargets.add(targetKey);\n\n      const transitiveTargets = directEdges.get(targetKey);\n      if (transitiveTargets) pending.push(...transitiveTargets);\n    }\n\n    closedEdges.set(consumerKey, allTargets);\n  }\n\n  return closedEdges;\n};\n\n/**\n * Builds the `nest()` dependency graph of a set of dictionaries: for each\n * dictionary key, the keys of every dictionary it needs in order to resolve its\n * nested nodes, transitively.\n *\n * The build optimization uses this to attach the nest targets to the dictionary\n * artifact itself, so `nest()` resolves from a local reference and the target\n * lands in the same chunk (or the same lazy per-locale loader) as the\n * dictionary referencing it.\n *\n * Dictionaries without nested nodes are absent from the result.\n *\n * @param dictionaries - Compiled dictionaries to scan; each must carry its `key`.\n * @returns Map of dictionary key → keys it depends on through `nest()`.\n *\n * @example\n * ```ts\n * // dashboard nests common, common nests labels\n * getNestedDictionaryGraph([dashboard, common]);\n * // Map { 'dashboard' => Set { 'common', 'labels' }, 'common' => Set { 'labels' } }\n * ```\n */\nexport const getNestedDictionaryGraph = (\n  dictionaries: Iterable<unknown>\n): Map<string, Set<string>> => {\n  const directEdges = new Map<string, Set<string>>();\n\n  for (const dictionary of dictionaries) {\n    if (!isTraversable(dictionary)) continue;\n\n    const { key } = dictionary;\n    if (typeof key !== 'string') continue;\n\n    const targets = getNestedDictionaryKeys([dictionary]);\n    targets.delete(key);\n\n    if (targets.size === 0) continue;\n\n    // Several compiled entries can share a key (qualified groups); merge them.\n    const existingTargets = directEdges.get(key);\n    if (existingTargets) {\n      for (const target of targets) existingTargets.add(target);\n      continue;\n    }\n\n    directEdges.set(key, targets);\n  }\n\n  return closeOverNestedEdges(directEdges);\n};\n"],"mappings":";;;;;;;;AAgBA,MAAM,4BAA4B;;;;;AAQlC,MAAM,iBAAiB,UACrB,OAAO,UAAU,YAAY,UAAU;;;;;AAMzC,MAAM,sBACJ,YACA,eACA,SACS;CACT,MAAM,oBAAoB,WAAW,IAAI,aAAa;CAEtD,IAAI,sBAAsB,OAAO;CAKjC,MAAM,YAAY,MAAM,MAAM,GAAG,CAAC,CAAC;CAEnC,IAAI,CAAC,WAAW;EACd,WAAW,IAAI,eAAe,KAAK;EACnC;CACF;CAEA,IAAI,mBAAmB;EACrB,kBAAkB,IAAI,SAAS;EAC/B;CACF;CAEA,WAAW,IAAI,+BAAe,IAAI,IAAI,CAAC,SAAS,CAAC,CAAC;AACpD;;;;;;;;;;;;;;;;;;;AAoBA,MAAa,iCACX,iBACuC;CACvC,MAAM,6BAAa,IAAI,IAAmC;CAC1D,MAAM,QAAmB,CAAC,GAAG,YAAY;CACzC,MAAM,+BAAe,IAAI,IAAY;CAErC,OAAO,MAAM,SAAS,GAAG;EACvB,MAAM,OAAO,MAAM,IAAI;EAEvB,IAAI,CAAC,cAAc,IAAI,GAAG;EAC1B,IAAI,aAAa,IAAI,IAAI,GAAG;EAC5B,aAAa,IAAI,IAAI;EAErB,IAAI,MAAM,QAAQ,IAAI,GAAG;GACvB,MAAM,KAAK,GAAG,IAAI;GAClB;EACF;EAEA,MAAM,EAAE,aAAa;EAErB,IAAI,aAAaA,mCAAU,aAAa,2BAA2B;GACjE,MAAM,cAAc,KAAK;GAEzB,IAAI,cAAc,WAAW,GAAG;IAC9B,MAAM,EAAE,eAAe,SAAS;IAEhC,IAAI,OAAO,kBAAkB,UAC3B,mBACE,YACA,eACA,OAAO,SAAS,WAAW,OAAO,MACpC;GAEJ;GAGA;EACF;EAEA,MAAM,KAAK,GAAG,OAAO,OAAO,IAAI,CAAC;CACnC;CAEA,OAAO;AACT;;;;;;;AAQA,MAAa,2BACX,iBACgB,IAAI,IAAI,8BAA8B,YAAY,CAAC,CAAC,KAAK,CAAC;;;;;;;;AAS5E,MAAM,wBACJ,gBAC6B;CAC7B,MAAM,8BAAc,IAAI,IAAyB;CAEjD,KAAK,MAAM,CAAC,aAAa,kBAAkB,aAAa;EACtD,MAAM,6BAAa,IAAI,IAAY;EACnC,MAAM,UAAU,CAAC,GAAG,aAAa;EAEjC,OAAO,QAAQ,SAAS,GAAG;GACzB,MAAM,YAAY,QAAQ,IAAI;GAE9B,IAAI,cAAc,aAAa;GAC/B,IAAI,WAAW,IAAI,SAAS,GAAG;GAC/B,WAAW,IAAI,SAAS;GAExB,MAAM,oBAAoB,YAAY,IAAI,SAAS;GACnD,IAAI,mBAAmB,QAAQ,KAAK,GAAG,iBAAiB;EAC1D;EAEA,YAAY,IAAI,aAAa,UAAU;CACzC;CAEA,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;AAwBA,MAAa,4BACX,iBAC6B;CAC7B,MAAM,8BAAc,IAAI,IAAyB;CAEjD,KAAK,MAAM,cAAc,cAAc;EACrC,IAAI,CAAC,cAAc,UAAU,GAAG;EAEhC,MAAM,EAAE,QAAQ;EAChB,IAAI,OAAO,QAAQ,UAAU;EAE7B,MAAM,UAAU,wBAAwB,CAAC,UAAU,CAAC;EACpD,QAAQ,OAAO,GAAG;EAElB,IAAI,QAAQ,SAAS,GAAG;EAGxB,MAAM,kBAAkB,YAAY,IAAI,GAAG;EAC3C,IAAI,iBAAiB;GACnB,KAAK,MAAM,UAAU,SAAS,gBAAgB,IAAI,MAAM;GACxD;EACF;EAEA,YAAY,IAAI,KAAK,OAAO;CAC9B;CAEA,OAAO,qBAAqB,WAAW;AACzC"}

package/dist/cjs/dictionaryManipulator/index.cjs

@@ -4,33 +4,39 @@ const require_dictionaryManipulator_editDictionaryByKeyPath = require('./editDic
 const require_dictionaryManipulator_getContentNodeByKeyPath = require('./getContentNodeByKeyPath.cjs');
 const require_dictionaryManipulator_getDefaultNode = require('./getDefaultNode.cjs');
 const require_dictionaryManipulator_getEmptyNode = require('./getEmptyNode.cjs');
+const require_dictionaryManipulator_getNestedDictionaryReferences = require('./getNestedDictionaryReferences.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_qualifiedDictionaryDeclaration = require('./qualifiedDictionaryDeclaration.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_qualifiedDynamicLoader = require('./qualifiedDynamicLoader.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.DEFAULT_VARIANT_ID = require_dictionaryManipulator_qualifiedDictionary.DEFAULT_VARIANT_ID;
-exports.QUALIFIER_DYNAMIC_TYPES_KEY = require_dictionaryManipulator_qualifiedDictionary.QUALIFIER_DYNAMIC_TYPES_KEY;
-exports.QUALIFIER_ORDER = require_dictionaryManipulator_qualifiedDictionary.QUALIFIER_ORDER;
+exports.QUALIFIER_DYNAMIC_TYPES_KEY = require_dictionaryManipulator_qualifiedDynamicLoader.QUALIFIER_DYNAMIC_TYPES_KEY;
+exports.QUALIFIER_ORDER = require_dictionaryManipulator_qualifiedDictionaryDeclaration.QUALIFIER_ORDER;
 exports.editDictionaryByKeyPath = require_dictionaryManipulator_editDictionaryByKeyPath.editDictionaryByKeyPath;
 exports.getContentNodeByKeyPath = require_dictionaryManipulator_getContentNodeByKeyPath.getContentNodeByKeyPath;
 exports.getDefaultNode = require_dictionaryManipulator_getDefaultNode.getDefaultNode;
-exports.getDictionaryCompositeIds = require_dictionaryManipulator_qualifiedDictionary.getDictionaryCompositeIds;
-exports.getDictionaryQualifierIds = require_dictionaryManipulator_qualifiedDictionary.getDictionaryQualifierIds;
-exports.getDictionaryQualifierTypes = require_dictionaryManipulator_qualifiedDictionary.getDictionaryQualifierTypes;
+exports.getDictionaryCompositeIds = require_dictionaryManipulator_qualifiedDictionaryDeclaration.getDictionaryCompositeIds;
+exports.getDictionaryQualifierIds = require_dictionaryManipulator_qualifiedDictionaryDeclaration.getDictionaryQualifierIds;
+exports.getDictionaryQualifierTypes = require_dictionaryManipulator_qualifiedDictionaryDeclaration.getDictionaryQualifierTypes;
 exports.getDictionarySelectorCacheKey = require_dictionaryManipulator_qualifiedDictionary.getDictionarySelectorCacheKey;
 exports.getEmptyNode = require_dictionaryManipulator_getEmptyNode.getEmptyNode;
+exports.getNestedDictionaryGraph = require_dictionaryManipulator_getNestedDictionaryReferences.getNestedDictionaryGraph;
+exports.getNestedDictionaryKeys = require_dictionaryManipulator_getNestedDictionaryReferences.getNestedDictionaryKeys;
+exports.getNestedDictionaryReferences = require_dictionaryManipulator_getNestedDictionaryReferences.getNestedDictionaryReferences;
 exports.getNodeChildren = require_dictionaryManipulator_getNodeChildren.getNodeChildren;
 exports.getNodeType = require_dictionaryManipulator_getNodeType.getNodeType;
-exports.getVariantIds = require_dictionaryManipulator_qualifiedDictionary.getVariantIds;
+exports.getVariantIds = require_dictionaryManipulator_qualifiedDictionaryDeclaration.getVariantIds;
 exports.isQualifiedDictionaryGroup = require_dictionaryManipulator_qualifiedDictionary.isQualifiedDictionaryGroup;
-exports.isQualifiedDynamicLoaderMap = require_dictionaryManipulator_qualifiedDictionary.isQualifiedDynamicLoaderMap;
+exports.isQualifiedDynamicLoaderMap = require_dictionaryManipulator_qualifiedDynamicLoader.isQualifiedDynamicLoaderMap;
 exports.mergeDictionaries = require_dictionaryManipulator_mergeDictionaries.mergeDictionaries;
 exports.mergeQualifiedDictionaries = require_dictionaryManipulator_mergeQualifiedDictionaries.mergeQualifiedDictionaries;
 exports.normalizeDictionaries = require_dictionaryManipulator_normalizeDictionary.normalizeDictionaries;
@@ -41,10 +47,11 @@ exports.reconstructQualifiedEntry = require_dictionaryManipulator_qualifiedDicti
 exports.removeContentNodeByKeyPath = require_dictionaryManipulator_removeContentNodeByKeyPath.removeContentNodeByKeyPath;
 exports.renameContentNodeByKeyPath = require_dictionaryManipulator_renameContentNodeByKeyPath.renameContentNodeByKeyPath;
 exports.resolveDictionaryArgument = require_dictionaryManipulator_qualifiedDictionary.resolveDictionaryArgument;
+exports.resolveEffectiveVariantId = require_dictionaryManipulator_qualifiedDictionary.resolveEffectiveVariantId;
 exports.resolveProviderVariant = require_dictionaryManipulator_qualifiedDictionary.resolveProviderVariant;
 exports.resolveQualifiedDictionary = require_dictionaryManipulator_qualifiedDictionary.resolveQualifiedDictionary;
-exports.resolveQualifiedDynamicContent = require_dictionaryManipulator_qualifiedDictionary.resolveQualifiedDynamicContent;
-exports.resolveQualifiedDynamicContentAsync = require_dictionaryManipulator_qualifiedDictionary.resolveQualifiedDynamicContentAsync;
+exports.resolveQualifiedDynamicContent = require_dictionaryManipulator_qualifiedDynamicLoader.resolveQualifiedDynamicContent;
+exports.resolveQualifiedDynamicContentAsync = require_dictionaryManipulator_qualifiedDynamicLoader.resolveQualifiedDynamicContentAsync;
 exports.serializeVariant = require_dictionaryManipulator_qualifiedDictionary.serializeVariant;
 exports.serializeVariantChain = require_dictionaryManipulator_qualifiedDictionary.serializeVariantChain;
 exports.updateNodeChildren = require_dictionaryManipulator_updateNodeChildren.updateNodeChildren;

package/dist/cjs/dictionaryManipulator/mergeDictionaries.cjs

@@ -40,9 +40,10 @@ const arrayMerge = (destinationArray, sourceArray) => {
 		const sourceItem = sourceArray[i];
 		if (destItem === void 0 && sourceItem === void 0) {} else if (destItem === void 0) result.push(sourceItem);
 		else if (sourceItem === void 0) result.push(destItem);
-		else if (typeof destItem === "object" && typeof sourceItem === "object" && destItem !== null && sourceItem !== null) if ("key" in destItem && "key" in sourceItem && destItem.key === sourceItem.key) result.push(customMerge(destItem, sourceItem));
-		else result.push(customMerge(destItem, sourceItem));
-		else result.push(destItem);
+		else if (typeof destItem === "object" && typeof sourceItem === "object" && destItem !== null && sourceItem !== null) {
+			if ("key" in destItem && "key" in sourceItem && destItem.key === sourceItem.key) result.push(customMerge(destItem, sourceItem));
+			else result.push(customMerge(destItem, sourceItem));
+		} else result.push(destItem);
 	}
 	return result;
 };

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  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":"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"}
+{"version":3,"file":"mergeDictionaries.cjs","names":["getAppLogger","getNodeType","colorizeKey","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":"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"}

package/dist/cjs/dictionaryManipulator/mergeQualifiedDictionaries.cjs

@@ -1,6 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_dictionaryManipulator_qualifiedDictionary = require('./qualifiedDictionary.cjs');
 const require_dictionaryManipulator_mergeDictionaries = require('./mergeDictionaries.cjs');
+const require_dictionaryManipulator_qualifiedDictionaryDeclaration = require('./qualifiedDictionaryDeclaration.cjs');
 let _intlayer_config_built = require("@intlayer/config/built");
 let _intlayer_config_logger = require("@intlayer/config/logger");
 
@@ -24,10 +25,10 @@ let _intlayer_config_logger = require("@intlayer/config/logger");
 * 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 perDictionaryTypes = dictionaries.map(require_dictionaryManipulator_qualifiedDictionaryDeclaration.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));
+	const groupQualifierTypes = require_dictionaryManipulator_qualifiedDictionaryDeclaration.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 = [];
@@ -37,7 +38,7 @@ const mergeQualifiedDictionaries = (dictionaries) => {
 			baseDictionaries.push(dictionary);
 			return;
 		}
-		const compositeIds = require_dictionaryManipulator_qualifiedDictionary.getDictionaryCompositeIds(dictionary, groupQualifierTypes);
+		const compositeIds = require_dictionaryManipulator_qualifiedDictionaryDeclaration.getDictionaryCompositeIds(dictionary, groupQualifierTypes);
 		if (compositeIds === 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;

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

@@ -1 +1 @@
-{"version":3,"file":"mergeQualifiedDictionaries.cjs","names":["getDictionaryQualifierTypes","QUALIFIER_ORDER","mergeDictionaries","getDictionaryCompositeIds","DEFAULT_VARIANT_ID"],"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,IAAIA,6EAA2B;CAEvE,MAAM,qCAAqB,IAAI,IAA6B;CAC5D,KAAK,MAAM,SAAS,oBAClB,KAAK,MAAM,QAAQ,OAAO,mBAAmB,IAAI,IAAI;CAIvD,MAAM,sBAAsBC,kEAAgB,QAAQ,kBAClD,mBAAmB,IAAI,aAAa,CACtC;CAEA,IAAI,oBAAoB,WAAW,GACjC,OAAOC,kEAAkB,YAAY;CAGvC,MAAM,sDAAyB,EAAE,gCAAI,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,eAAeC,4EACnB,YACA,mBACF;EAEA,IAAI,iBAAiB,QAAW;GAC9B,UACE,uDAA0B,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,IAAIC,sEAAoB,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,gBAAgBA;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,eANYF,kEAAkB;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"}
+{"version":3,"file":"mergeQualifiedDictionaries.cjs","names":["getDictionaryQualifierTypes","QUALIFIER_ORDER","mergeDictionaries","getAppLogger","getDictionaryCompositeIds","colorizeKey","DEFAULT_VARIANT_ID"],"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} from './qualifiedDictionary';\nimport {\n  getDictionaryCompositeIds,\n  getDictionaryQualifierTypes,\n  QUALIFIER_ORDER,\n} from './qualifiedDictionaryDeclaration';\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":";;;;;;;;;;;;;;;;;;;;;;;;;;AAoCA,MAAa,8BACX,iBAC0C;CAC1C,MAAM,qBAAqB,aAAa,IAAIA,wFAA2B;CAEvE,MAAM,qCAAqB,IAAI,IAA6B;CAC5D,KAAK,MAAM,SAAS,oBAClB,KAAK,MAAM,QAAQ,OAAO,mBAAmB,IAAI,IAAI;CAIvD,MAAM,sBAAsBC,6EAAgB,QAAQ,kBAClD,mBAAmB,IAAI,aAAa,CACtC;CAEA,IAAI,oBAAoB,WAAW,GACjC,OAAOC,kEAAkB,YAAY;CAGvC,MAAM,gBAAYC,sCAAa,EAAE,gCAAI,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,eAAeC,uFACnB,YACA,mBACF;EAEA,IAAI,iBAAiB,QAAW;GAC9B,UACE,kBAAcC,qCAAY,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,IAAIC,sEAAoB,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,gBAAgBA;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,eANYJ,kEAAkB;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/cjs/dictionaryManipulator/qualifiedDictionary.cjs

@@ -1,13 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
 //#region src/dictionaryManipulator/qualifiedDictionary.ts
 /**
-* Canonical order of qualifier dimensions. A key that declares both dimensions
-* always nests them in this order, with `item` innermost so it can act as the
-* collection (array) axis.
-*/
-const QUALIFIER_ORDER = ["variant", "item"];
-/**
 * Separator joining per-dimension ids into a composite entry id. Also used as
 * the chunk path separator in dynamic mode.
 */
@@ -62,57 +55,6 @@ const serializeVariant = (variant) => {
 	return Object.keys(variant).sort().map((field) => `${encodeSegmentText(field, COMPONENT_UNSAFE_CHARS)}=${encodeSegmentText(String(variant[field]), COMPONENT_UNSAFE_CHARS)}`).join("&");
 };
 /**
-* Normalizes the `variant` field of a dictionary into the list of variant ids
-* the declaration registers under. A single value yields one id; an **array**
-* fans out into one id per element (duplicates collapsed). Returns `undefined`
-* when the dictionary does not declare the variant dimension (no `variant`
-* field, or an empty array).
-*/
-const getVariantIds = (variant) => {
-	if (variant === void 0) return void 0;
-	const values = Array.isArray(variant) ? variant : [variant];
-	if (values.length === 0) return void 0;
-	return [...new Set(values.map(serializeVariant))];
-};
-/**
-* Returns the qualifier dimensions declared on a dictionary, in canonical
-* order (`variant → item`). Empty when the dictionary is unqualified
-* (plain dictionary or shared base content of a qualified group).
-*/
-const getDictionaryQualifierTypes = (dictionary) => {
-	const declaredQualifiers = [];
-	if (getVariantIds(dictionary.variant) !== void 0) declaredQualifiers.push("variant");
-	if (typeof dictionary.item === "number") declaredQualifiers.push("item");
-	return declaredQualifiers;
-};
-/**
-* Returns the qualifier identifiers of a dictionary for the given qualifier
-* dimension — the candidate segments of the composite entry ids.
-*
-* - 'variant' → the serialized variant id(s); an array variant yields one id
-*   per element (declaration-side fan-out)
-* - 'item' → the item index as a single-element list
-*/
-const getDictionaryQualifierIds = (dictionary, qualifierType) => {
-	if (qualifierType === "variant") return getVariantIds(dictionary.variant);
-	return dictionary.item === void 0 ? void 0 : [String(dictionary.item)];
-};
-/**
-* Builds every composite entry id of a dictionary — the cartesian product of
-* its per-dimension id lists, joined in canonical order. A dictionary with a
-* plain (non-array) variant yields exactly one id; an array variant fans out
-* into one id per element. `undefined` when a dimension of the set is missing.
-*/
-const getDictionaryCompositeIds = (dictionary, qualifierTypes) => {
-	let compositeIds = [""];
-	for (const qualifierType of qualifierTypes) {
-		const ids = getDictionaryQualifierIds(dictionary, qualifierType);
-		if (ids === void 0) return void 0;
-		compositeIds = compositeIds.flatMap((prefix) => ids.map((id) => prefix === "" ? id : `${prefix}${"/"}${id}`));
-	}
-	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.
@@ -290,130 +232,18 @@ const getDictionarySelectorCacheKey = (selector) => {
 		return `${selectorKey}:${selectorKey === "variant" ? serializeVariantChain(value).join(",") : String(value)}`;
 	}).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, 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: []
-	};
-	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" ? 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]);
-	};
-	return {
-		itemAxisOpen,
-		missed: !walk(localeTree, qualifierTypes, []),
-		chunks
-	};
-};
-/**
-* 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 → 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
-* 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()));
-	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()));
-	if (itemAxisOpen) return dictionaries.map(transform);
-	const [dictionary] = dictionaries;
-	return dictionary ? transform(dictionary) : null;
-};
 
 //#endregion
 exports.COMPOSITE_ID_SEPARATOR = COMPOSITE_ID_SEPARATOR;
 exports.DEFAULT_VARIANT_ID = DEFAULT_VARIANT_ID;
-exports.QUALIFIER_DYNAMIC_TYPES_KEY = QUALIFIER_DYNAMIC_TYPES_KEY;
-exports.QUALIFIER_ORDER = QUALIFIER_ORDER;
-exports.getDictionaryCompositeIds = getDictionaryCompositeIds;
-exports.getDictionaryQualifierIds = getDictionaryQualifierIds;
-exports.getDictionaryQualifierTypes = getDictionaryQualifierTypes;
 exports.getDictionarySelectorCacheKey = getDictionarySelectorCacheKey;
-exports.getVariantIds = getVariantIds;
 exports.isQualifiedDictionaryGroup = isQualifiedDictionaryGroup;
-exports.isQualifiedDynamicLoaderMap = isQualifiedDynamicLoaderMap;
 exports.parseDictionarySelector = parseDictionarySelector;
 exports.reconstructQualifiedEntry = reconstructQualifiedEntry;
 exports.resolveDictionaryArgument = resolveDictionaryArgument;
+exports.resolveEffectiveVariantId = resolveEffectiveVariantId;
 exports.resolveProviderVariant = resolveProviderVariant;
 exports.resolveQualifiedDictionary = resolveQualifiedDictionary;
-exports.resolveQualifiedDynamicContent = resolveQualifiedDynamicContent;
-exports.resolveQualifiedDynamicContentAsync = resolveQualifiedDynamicContentAsync;
 exports.serializeVariant = serializeVariant;
 exports.serializeVariantChain = serializeVariantChain;
 //# sourceMappingURL=qualifiedDictionary.cjs.map