@intlayer/core 9.0.2 → 9.1.1

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

@@ -1 +1 @@
-{"version":3,"file":"getEmptyNode.mjs","names":[],"sources":["../../../src/dictionaryManipulator/getEmptyNode.ts"],"sourcesContent":["import type { ContentNode, TypedNode } from '@intlayer/types/dictionary';\n\nimport * as NodeTypes from '@intlayer/types/nodeType';\n\nexport const getEmptyNode = (section: ContentNode): ContentNode => {\n  if (typeof section === 'string') {\n    return '';\n  }\n  if (typeof section === 'number') {\n    return 0;\n  }\n  if (typeof section === 'boolean') {\n    return true;\n  }\n  if (typeof (section as TypedNode)?.nodeType === 'string') {\n    const typedNode = section as TypedNode;\n    const content =\n      typedNode[typedNode.nodeType as unknown as keyof typeof typedNode];\n\n    if (\n      typedNode.nodeType === NodeTypes.TRANSLATION ||\n      typedNode.nodeType === NodeTypes.ENUMERATION ||\n      typedNode.nodeType === NodeTypes.PLURAL ||\n      typedNode.nodeType === NodeTypes.CONDITION ||\n      typedNode.nodeType === NodeTypes.INSERTION ||\n      typedNode.nodeType === NodeTypes.HTML\n    ) {\n      return getEmptyNode(content as ContentNode);\n    }\n\n    if (typedNode.nodeType === NodeTypes.NESTED) {\n      return 'dictionary-key';\n    }\n\n    if (typedNode.nodeType === NodeTypes.FILE) {\n      return 'file/path';\n    }\n\n    if (typedNode.nodeType === NodeTypes.MARKDOWN) {\n      return getEmptyNode(content as ContentNode);\n    }\n\n    return content;\n  }\n\n  if (!section || typeof section !== 'object') {\n    return section;\n  }\n\n  if (Array.isArray(section)) {\n    return (section as ContentNode[]).map(\n      getEmptyNode\n    ) as unknown as ContentNode;\n  }\n\n  const mappedSectionObject = Object.entries(section).map(([key, value]) => [\n    key,\n    getEmptyNode(value as ContentNode),\n  ]);\n\n  const mappedSectionArray = Object.fromEntries(mappedSectionObject);\n\n  return mappedSectionArray;\n};\n"],"mappings":";;;AAIA,MAAa,gBAAgB,YAAsC;CACjE,IAAI,OAAO,YAAY,UACrB,OAAO;CAET,IAAI,OAAO,YAAY,UACrB,OAAO;CAET,IAAI,OAAO,YAAY,WACrB,OAAO;CAET,IAAI,OAAQ,SAAuB,aAAa,UAAU;EACxD,MAAM,YAAY;EAClB,MAAM,UACJ,UAAU,UAAU;EAEtB,IACE,UAAU,aAAa,UAAU,eACjC,UAAU,aAAa,UAAU,eACjC,UAAU,aAAa,UAAU,UACjC,UAAU,aAAa,UAAU,aACjC,UAAU,aAAa,UAAU,aACjC,UAAU,aAAa,UAAU,MAEjC,OAAO,aAAa,OAAsB;EAG5C,IAAI,UAAU,aAAa,UAAU,QACnC,OAAO;EAGT,IAAI,UAAU,aAAa,UAAU,MACnC,OAAO;EAGT,IAAI,UAAU,aAAa,UAAU,UACnC,OAAO,aAAa,OAAsB;EAG5C,OAAO;CACT;CAEA,IAAI,CAAC,WAAW,OAAO,YAAY,UACjC,OAAO;CAGT,IAAI,MAAM,QAAQ,OAAO,GACvB,OAAQ,QAA0B,IAChC,YACF;CAGF,MAAM,sBAAsB,OAAO,QAAQ,OAAO,CAAC,CAAC,KAAK,CAAC,KAAK,WAAW,CACxE,KACA,aAAa,KAAoB,CACnC,CAAC;CAID,OAF2B,OAAO,YAAY,mBAEtB;AAC1B"}
+{"version":3,"file":"getEmptyNode.mjs","names":[],"sources":["../../../src/dictionaryManipulator/getEmptyNode.ts"],"sourcesContent":["import type { ContentNode, TypedNode } from '@intlayer/types/dictionary';\n\nimport * as NodeTypes from '@intlayer/types/nodeType';\n\nexport const getEmptyNode = (section: ContentNode): ContentNode => {\n  if (typeof section === 'string') {\n    return '';\n  }\n  if (typeof section === 'number') {\n    return 0;\n  }\n  if (typeof section === 'boolean') {\n    return true;\n  }\n  if (typeof (section as TypedNode)?.nodeType === 'string') {\n    const typedNode = section as TypedNode;\n    const content =\n      typedNode[typedNode.nodeType as unknown as keyof typeof typedNode];\n\n    if (\n      typedNode.nodeType === NodeTypes.TRANSLATION ||\n      typedNode.nodeType === NodeTypes.ENUMERATION ||\n      typedNode.nodeType === NodeTypes.PLURAL ||\n      typedNode.nodeType === NodeTypes.CONDITION ||\n      typedNode.nodeType === NodeTypes.INSERTION ||\n      typedNode.nodeType === NodeTypes.GENDER ||\n      typedNode.nodeType === NodeTypes.SELECT ||\n      typedNode.nodeType === NodeTypes.HTML\n    ) {\n      return getEmptyNode(content as ContentNode);\n    }\n\n    if (typedNode.nodeType === NodeTypes.NESTED) {\n      return 'dictionary-key';\n    }\n\n    if (typedNode.nodeType === NodeTypes.FILE) {\n      return 'file/path';\n    }\n\n    if (typedNode.nodeType === NodeTypes.MARKDOWN) {\n      return getEmptyNode(content as ContentNode);\n    }\n\n    return content;\n  }\n\n  if (!section || typeof section !== 'object') {\n    return section;\n  }\n\n  if (Array.isArray(section)) {\n    return (section as ContentNode[]).map(\n      getEmptyNode\n    ) as unknown as ContentNode;\n  }\n\n  const mappedSectionObject = Object.entries(section).map(([key, value]) => [\n    key,\n    getEmptyNode(value as ContentNode),\n  ]);\n\n  const mappedSectionArray = Object.fromEntries(mappedSectionObject);\n\n  return mappedSectionArray;\n};\n"],"mappings":";;;AAIA,MAAa,gBAAgB,YAAsC;CACjE,IAAI,OAAO,YAAY,UACrB,OAAO;CAET,IAAI,OAAO,YAAY,UACrB,OAAO;CAET,IAAI,OAAO,YAAY,WACrB,OAAO;CAET,IAAI,OAAQ,SAAuB,aAAa,UAAU;EACxD,MAAM,YAAY;EAClB,MAAM,UACJ,UAAU,UAAU;EAEtB,IACE,UAAU,aAAa,UAAU,eACjC,UAAU,aAAa,UAAU,eACjC,UAAU,aAAa,UAAU,UACjC,UAAU,aAAa,UAAU,aACjC,UAAU,aAAa,UAAU,aACjC,UAAU,aAAa,UAAU,UACjC,UAAU,aAAa,UAAU,UACjC,UAAU,aAAa,UAAU,MAEjC,OAAO,aAAa,OAAsB;EAG5C,IAAI,UAAU,aAAa,UAAU,QACnC,OAAO;EAGT,IAAI,UAAU,aAAa,UAAU,MACnC,OAAO;EAGT,IAAI,UAAU,aAAa,UAAU,UACnC,OAAO,aAAa,OAAsB;EAG5C,OAAO;CACT;CAEA,IAAI,CAAC,WAAW,OAAO,YAAY,UACjC,OAAO;CAGT,IAAI,MAAM,QAAQ,OAAO,GACvB,OAAQ,QAA0B,IAChC,YACF;CAGF,MAAM,sBAAsB,OAAO,QAAQ,OAAO,CAAC,CAAC,KAAK,CAAC,KAAK,WAAW,CACxE,KACA,aAAa,KAAoB,CACnC,CAAC;CAID,OAF2B,OAAO,YAAY,mBAEtB;AAC1B"}

package/dist/esm/dictionaryManipulator/getNodeChildren.mjs

@@ -9,7 +9,7 @@ const getNodeChildren = (section) => {
 		const typedNode = section;
 		const content = typedNode[typedNode.nodeType];
 		if (typedNode.nodeType === NodeTypes.MARKDOWN || typedNode.nodeType === NodeTypes.HTML) return content;
-		if (typedNode.nodeType === NodeTypes.TRANSLATION || typedNode.nodeType === NodeTypes.ENUMERATION || typedNode.nodeType === NodeTypes.PLURAL || typedNode.nodeType === NodeTypes.CONDITION || typedNode.nodeType === NodeTypes.INSERTION || typedNode.nodeType === NodeTypes.GENDER || typedNode.nodeType === NodeTypes.FILE) return content[Object.keys(content)[0]];
+		if (typedNode.nodeType === NodeTypes.TRANSLATION || typedNode.nodeType === NodeTypes.ENUMERATION || typedNode.nodeType === NodeTypes.PLURAL || typedNode.nodeType === NodeTypes.CONDITION || typedNode.nodeType === NodeTypes.INSERTION || typedNode.nodeType === NodeTypes.GENDER || typedNode.nodeType === NodeTypes.SELECT || typedNode.nodeType === NodeTypes.FILE) return content[Object.keys(content)[0]];
 		if (typedNode.nodeType === NodeTypes.NESTED) return;
 		return content;
 	}

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

@@ -1 +1 @@
-{"version":3,"file":"getNodeChildren.mjs","names":[],"sources":["../../../src/dictionaryManipulator/getNodeChildren.ts"],"sourcesContent":["import type { ContentNode, TypedNode } from '@intlayer/types/dictionary';\n\nimport * as NodeTypes from '@intlayer/types/nodeType';\n\nexport const getNodeChildren = (section: ContentNode): ContentNode => {\n  if (typeof section === 'string') {\n    return section;\n  }\n  if (typeof section === 'number') {\n    return section;\n  }\n  if (typeof section === 'boolean') {\n    return section;\n  }\n  if (typeof (section as TypedNode)?.nodeType === 'string') {\n    const typedNode = section as TypedNode;\n    const content =\n      typedNode[typedNode.nodeType as unknown as keyof typeof typedNode];\n\n    if (\n      typedNode.nodeType === NodeTypes.MARKDOWN ||\n      typedNode.nodeType === NodeTypes.HTML\n    ) {\n      return content as ContentNode;\n    }\n\n    if (\n      typedNode.nodeType === NodeTypes.TRANSLATION ||\n      typedNode.nodeType === NodeTypes.ENUMERATION ||\n      typedNode.nodeType === NodeTypes.PLURAL ||\n      typedNode.nodeType === NodeTypes.CONDITION ||\n      typedNode.nodeType === NodeTypes.INSERTION ||\n      typedNode.nodeType === NodeTypes.GENDER ||\n      typedNode.nodeType === NodeTypes.FILE\n    ) {\n      const firstKey = Object.keys(content)[0] as keyof typeof content;\n      return content[firstKey] as ContentNode;\n    }\n\n    if (typedNode.nodeType === NodeTypes.NESTED) {\n      return undefined;\n    }\n\n    return content;\n  }\n\n  if (!section || typeof section !== 'object') {\n    return section;\n  }\n\n  if (Array.isArray(section)) {\n    return (section as ContentNode[])[0];\n  }\n\n  return section;\n};\n"],"mappings":";;;AAIA,MAAa,mBAAmB,YAAsC;CACpE,IAAI,OAAO,YAAY,UACrB,OAAO;CAET,IAAI,OAAO,YAAY,UACrB,OAAO;CAET,IAAI,OAAO,YAAY,WACrB,OAAO;CAET,IAAI,OAAQ,SAAuB,aAAa,UAAU;EACxD,MAAM,YAAY;EAClB,MAAM,UACJ,UAAU,UAAU;EAEtB,IACE,UAAU,aAAa,UAAU,YACjC,UAAU,aAAa,UAAU,MAEjC,OAAO;EAGT,IACE,UAAU,aAAa,UAAU,eACjC,UAAU,aAAa,UAAU,eACjC,UAAU,aAAa,UAAU,UACjC,UAAU,aAAa,UAAU,aACjC,UAAU,aAAa,UAAU,aACjC,UAAU,aAAa,UAAU,UACjC,UAAU,aAAa,UAAU,MAGjC,OAAO,QADU,OAAO,KAAK,OAAO,CAAC,CAAC;EAIxC,IAAI,UAAU,aAAa,UAAU,QACnC;EAGF,OAAO;CACT;CAEA,IAAI,CAAC,WAAW,OAAO,YAAY,UACjC,OAAO;CAGT,IAAI,MAAM,QAAQ,OAAO,GACvB,OAAQ,QAA0B;CAGpC,OAAO;AACT"}
+{"version":3,"file":"getNodeChildren.mjs","names":[],"sources":["../../../src/dictionaryManipulator/getNodeChildren.ts"],"sourcesContent":["import type { ContentNode, TypedNode } from '@intlayer/types/dictionary';\n\nimport * as NodeTypes from '@intlayer/types/nodeType';\n\nexport const getNodeChildren = (section: ContentNode): ContentNode => {\n  if (typeof section === 'string') {\n    return section;\n  }\n  if (typeof section === 'number') {\n    return section;\n  }\n  if (typeof section === 'boolean') {\n    return section;\n  }\n  if (typeof (section as TypedNode)?.nodeType === 'string') {\n    const typedNode = section as TypedNode;\n    const content =\n      typedNode[typedNode.nodeType as unknown as keyof typeof typedNode];\n\n    if (\n      typedNode.nodeType === NodeTypes.MARKDOWN ||\n      typedNode.nodeType === NodeTypes.HTML\n    ) {\n      return content as ContentNode;\n    }\n\n    if (\n      typedNode.nodeType === NodeTypes.TRANSLATION ||\n      typedNode.nodeType === NodeTypes.ENUMERATION ||\n      typedNode.nodeType === NodeTypes.PLURAL ||\n      typedNode.nodeType === NodeTypes.CONDITION ||\n      typedNode.nodeType === NodeTypes.INSERTION ||\n      typedNode.nodeType === NodeTypes.GENDER ||\n      typedNode.nodeType === NodeTypes.SELECT ||\n      typedNode.nodeType === NodeTypes.FILE\n    ) {\n      const firstKey = Object.keys(content)[0] as keyof typeof content;\n      return content[firstKey] as ContentNode;\n    }\n\n    if (typedNode.nodeType === NodeTypes.NESTED) {\n      return undefined;\n    }\n\n    return content;\n  }\n\n  if (!section || typeof section !== 'object') {\n    return section;\n  }\n\n  if (Array.isArray(section)) {\n    return (section as ContentNode[])[0];\n  }\n\n  return section;\n};\n"],"mappings":";;;AAIA,MAAa,mBAAmB,YAAsC;CACpE,IAAI,OAAO,YAAY,UACrB,OAAO;CAET,IAAI,OAAO,YAAY,UACrB,OAAO;CAET,IAAI,OAAO,YAAY,WACrB,OAAO;CAET,IAAI,OAAQ,SAAuB,aAAa,UAAU;EACxD,MAAM,YAAY;EAClB,MAAM,UACJ,UAAU,UAAU;EAEtB,IACE,UAAU,aAAa,UAAU,YACjC,UAAU,aAAa,UAAU,MAEjC,OAAO;EAGT,IACE,UAAU,aAAa,UAAU,eACjC,UAAU,aAAa,UAAU,eACjC,UAAU,aAAa,UAAU,UACjC,UAAU,aAAa,UAAU,aACjC,UAAU,aAAa,UAAU,aACjC,UAAU,aAAa,UAAU,UACjC,UAAU,aAAa,UAAU,UACjC,UAAU,aAAa,UAAU,MAGjC,OAAO,QADU,OAAO,KAAK,OAAO,CAAC,CAAC;EAIxC,IAAI,UAAU,aAAa,UAAU,QACnC;EAGF,OAAO;CACT;CAEA,IAAI,CAAC,WAAW,OAAO,YAAY,UACjC,OAAO;CAGT,IAAI,MAAM,QAAQ,OAAO,GACvB,OAAQ,QAA0B;CAGpC,OAAO;AACT"}

package/dist/esm/dictionaryManipulator/getNodeType.mjs

@@ -9,30 +9,38 @@ const isTypedNode = (content) => {
 	return typeof content === "object" && content !== null && "nodeType" in content && typeof content.nodeType === "string";
 };
 /**
-* Type guard to check if content is a valid NodeType
+* Every known {@link NodeType}, as a lookup record.
+*
+* Typed as `Record<NodeType, true>` so that adding a node type to
+* `@intlayer/types` without registering it here becomes a compile-time error.
 */
-const isValidNodeType = (nodeType) => {
-	return [
-		NodeTypes.TRANSLATION,
-		NodeTypes.ENUMERATION,
-		NodeTypes.PLURAL,
-		NodeTypes.CONDITION,
-		NodeTypes.INSERTION,
-		NodeTypes.FILE,
-		NodeTypes.OBJECT,
-		NodeTypes.ARRAY,
-		NodeTypes.NESTED,
-		NodeTypes.REACT_NODE,
-		NodeTypes.MARKDOWN,
-		NodeTypes.HTML,
-		NodeTypes.TEXT,
-		NodeTypes.NUMBER,
-		NodeTypes.BOOLEAN,
-		NodeTypes.GENDER,
-		NodeTypes.NULL,
-		NodeTypes.UNKNOWN
-	].includes(nodeType);
+const validNodeTypes = {
+	[NodeTypes.TRANSLATION]: true,
+	[NodeTypes.ENUMERATION]: true,
+	[NodeTypes.PLURAL]: true,
+	[NodeTypes.CONDITION]: true,
+	[NodeTypes.INSERTION]: true,
+	[NodeTypes.FILE]: true,
+	[NodeTypes.OBJECT]: true,
+	[NodeTypes.ARRAY]: true,
+	[NodeTypes.NESTED]: true,
+	[NodeTypes.REACT_NODE]: true,
+	[NodeTypes.PREACT_NODE]: true,
+	[NodeTypes.SOLID_NODE]: true,
+	[NodeTypes.MARKDOWN]: true,
+	[NodeTypes.HTML]: true,
+	[NodeTypes.TEXT]: true,
+	[NodeTypes.NUMBER]: true,
+	[NodeTypes.BOOLEAN]: true,
+	[NodeTypes.GENDER]: true,
+	[NodeTypes.SELECT]: true,
+	[NodeTypes.NULL]: true,
+	[NodeTypes.UNKNOWN]: true
 };
+/**
+* Type guard to check if a raw string is a valid {@link NodeType}
+*/
+const isValidNodeType = (nodeType) => Object.hasOwn(validNodeTypes, nodeType);
 const getNodeType = (content) => {
 	if (typeof content === "string") return NodeTypes.TEXT;
 	if (isTypedNode(content)) {

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

@@ -1 +1 @@
-{"version":3,"file":"getNodeType.mjs","names":[],"sources":["../../../src/dictionaryManipulator/getNodeType.ts"],"sourcesContent":["import type { ContentNode, TypedNode } from '@intlayer/types/dictionary';\n\nimport type { NodeType } from '@intlayer/types/nodeType';\nimport * as NodeTypes from '@intlayer/types/nodeType';\nimport { isValidElement } from '../utils/isValidReactElement';\n\n/**\n * Type guard to check if content is a TypedNode\n */\nconst isTypedNode = (content: unknown): content is TypedNode => {\n  return (\n    typeof content === 'object' &&\n    content !== null &&\n    'nodeType' in content &&\n    typeof (content as TypedNode).nodeType === 'string'\n  );\n};\n\n/**\n * Type guard to check if content is a valid NodeType\n */\nconst isValidNodeType = (nodeType: string): nodeType is NodeType => {\n  return [\n    NodeTypes.TRANSLATION,\n    NodeTypes.ENUMERATION,\n    NodeTypes.PLURAL,\n    NodeTypes.CONDITION,\n    NodeTypes.INSERTION,\n    NodeTypes.FILE,\n    NodeTypes.OBJECT,\n    NodeTypes.ARRAY,\n    NodeTypes.NESTED,\n    NodeTypes.REACT_NODE,\n    NodeTypes.MARKDOWN,\n    NodeTypes.HTML,\n    NodeTypes.TEXT,\n    NodeTypes.NUMBER,\n    NodeTypes.BOOLEAN,\n    NodeTypes.GENDER,\n    NodeTypes.NULL,\n    NodeTypes.UNKNOWN,\n  ].includes(nodeType as NodeType);\n};\n\nexport const getNodeType = (content: ContentNode): NodeType => {\n  if (typeof content === 'string') {\n    return NodeTypes.TEXT;\n  }\n\n  if (isTypedNode(content)) {\n    const nodeType = content.nodeType;\n    if (isValidNodeType(nodeType)) {\n      return nodeType;\n    }\n    // Fallback for unknown node types\n    return NodeTypes.UNKNOWN;\n  }\n\n  if (Array.isArray(content)) {\n    return NodeTypes.ARRAY;\n  }\n\n  if (isValidElement(content)) {\n    return NodeTypes.REACT_NODE;\n  }\n\n  if (typeof content === 'number') {\n    return NodeTypes.NUMBER;\n  }\n\n  if (typeof content === 'boolean') {\n    return NodeTypes.BOOLEAN;\n  }\n\n  if (content && typeof content === 'object') {\n    return NodeTypes.OBJECT;\n  }\n\n  if (content === null) {\n    return NodeTypes.NULL;\n  }\n\n  return NodeTypes.UNKNOWN;\n};\n"],"mappings":";;;;;;;AASA,MAAM,eAAe,YAA2C;CAC9D,OACE,OAAO,YAAY,YACnB,YAAY,QACZ,cAAc,WACd,OAAQ,QAAsB,aAAa;AAE/C;;;;AAKA,MAAM,mBAAmB,aAA2C;CAClE,OAAO;EACL,UAAU;EACV,UAAU;EACV,UAAU;EACV,UAAU;EACV,UAAU;EACV,UAAU;EACV,UAAU;EACV,UAAU;EACV,UAAU;EACV,UAAU;EACV,UAAU;EACV,UAAU;EACV,UAAU;EACV,UAAU;EACV,UAAU;EACV,UAAU;EACV,UAAU;EACV,UAAU;CACZ,CAAC,CAAC,SAAS,QAAoB;AACjC;AAEA,MAAa,eAAe,YAAmC;CAC7D,IAAI,OAAO,YAAY,UACrB,OAAO,UAAU;CAGnB,IAAI,YAAY,OAAO,GAAG;EACxB,MAAM,WAAW,QAAQ;EACzB,IAAI,gBAAgB,QAAQ,GAC1B,OAAO;EAGT,OAAO,UAAU;CACnB;CAEA,IAAI,MAAM,QAAQ,OAAO,GACvB,OAAO,UAAU;CAGnB,IAAI,eAAe,OAAO,GACxB,OAAO,UAAU;CAGnB,IAAI,OAAO,YAAY,UACrB,OAAO,UAAU;CAGnB,IAAI,OAAO,YAAY,WACrB,OAAO,UAAU;CAGnB,IAAI,WAAW,OAAO,YAAY,UAChC,OAAO,UAAU;CAGnB,IAAI,YAAY,MACd,OAAO,UAAU;CAGnB,OAAO,UAAU;AACnB"}
+{"version":3,"file":"getNodeType.mjs","names":[],"sources":["../../../src/dictionaryManipulator/getNodeType.ts"],"sourcesContent":["import type { ContentNode, TypedNode } from '@intlayer/types/dictionary';\n\nimport type { NodeType } from '@intlayer/types/nodeType';\nimport * as NodeTypes from '@intlayer/types/nodeType';\nimport { isValidElement } from '../utils/isValidReactElement';\n\n/**\n * Type guard to check if content is a TypedNode\n */\nconst isTypedNode = (content: unknown): content is TypedNode => {\n  return (\n    typeof content === 'object' &&\n    content !== null &&\n    'nodeType' in content &&\n    typeof (content as TypedNode).nodeType === 'string'\n  );\n};\n\n/**\n * Every known {@link NodeType}, as a lookup record.\n *\n * Typed as `Record<NodeType, true>` so that adding a node type to\n * `@intlayer/types` without registering it here becomes a compile-time error.\n */\nconst validNodeTypes: Record<NodeType, true> = {\n  [NodeTypes.TRANSLATION]: true,\n  [NodeTypes.ENUMERATION]: true,\n  [NodeTypes.PLURAL]: true,\n  [NodeTypes.CONDITION]: true,\n  [NodeTypes.INSERTION]: true,\n  [NodeTypes.FILE]: true,\n  [NodeTypes.OBJECT]: true,\n  [NodeTypes.ARRAY]: true,\n  [NodeTypes.NESTED]: true,\n  [NodeTypes.REACT_NODE]: true,\n  [NodeTypes.PREACT_NODE]: true,\n  [NodeTypes.SOLID_NODE]: true,\n  [NodeTypes.MARKDOWN]: true,\n  [NodeTypes.HTML]: true,\n  [NodeTypes.TEXT]: true,\n  [NodeTypes.NUMBER]: true,\n  [NodeTypes.BOOLEAN]: true,\n  [NodeTypes.GENDER]: true,\n  [NodeTypes.SELECT]: true,\n  [NodeTypes.NULL]: true,\n  [NodeTypes.UNKNOWN]: true,\n};\n\n/**\n * Type guard to check if a raw string is a valid {@link NodeType}\n */\nconst isValidNodeType = (nodeType: string): nodeType is NodeType =>\n  Object.hasOwn(validNodeTypes, nodeType);\n\nexport const getNodeType = (content: ContentNode): NodeType => {\n  if (typeof content === 'string') {\n    return NodeTypes.TEXT;\n  }\n\n  if (isTypedNode(content)) {\n    const nodeType = content.nodeType;\n    if (isValidNodeType(nodeType)) {\n      return nodeType;\n    }\n    // Fallback for unknown node types\n    return NodeTypes.UNKNOWN;\n  }\n\n  if (Array.isArray(content)) {\n    return NodeTypes.ARRAY;\n  }\n\n  if (isValidElement(content)) {\n    return NodeTypes.REACT_NODE;\n  }\n\n  if (typeof content === 'number') {\n    return NodeTypes.NUMBER;\n  }\n\n  if (typeof content === 'boolean') {\n    return NodeTypes.BOOLEAN;\n  }\n\n  if (content && typeof content === 'object') {\n    return NodeTypes.OBJECT;\n  }\n\n  if (content === null) {\n    return NodeTypes.NULL;\n  }\n\n  return NodeTypes.UNKNOWN;\n};\n"],"mappings":";;;;;;;AASA,MAAM,eAAe,YAA2C;CAC9D,OACE,OAAO,YAAY,YACnB,YAAY,QACZ,cAAc,WACd,OAAQ,QAAsB,aAAa;AAE/C;;;;;;;AAQA,MAAM,iBAAyC;EAC5C,UAAU,cAAc;EACxB,UAAU,cAAc;EACxB,UAAU,SAAS;EACnB,UAAU,YAAY;EACtB,UAAU,YAAY;EACtB,UAAU,OAAO;EACjB,UAAU,SAAS;EACnB,UAAU,QAAQ;EAClB,UAAU,SAAS;EACnB,UAAU,aAAa;EACvB,UAAU,cAAc;EACxB,UAAU,aAAa;EACvB,UAAU,WAAW;EACrB,UAAU,OAAO;EACjB,UAAU,OAAO;EACjB,UAAU,SAAS;EACnB,UAAU,UAAU;EACpB,UAAU,SAAS;EACnB,UAAU,SAAS;EACnB,UAAU,OAAO;EACjB,UAAU,UAAU;AACvB;;;;AAKA,MAAM,mBAAmB,aACvB,OAAO,OAAO,gBAAgB,QAAQ;AAExC,MAAa,eAAe,YAAmC;CAC7D,IAAI,OAAO,YAAY,UACrB,OAAO,UAAU;CAGnB,IAAI,YAAY,OAAO,GAAG;EACxB,MAAM,WAAW,QAAQ;EACzB,IAAI,gBAAgB,QAAQ,GAC1B,OAAO;EAGT,OAAO,UAAU;CACnB;CAEA,IAAI,MAAM,QAAQ,OAAO,GACvB,OAAO,UAAU;CAGnB,IAAI,eAAe,OAAO,GACxB,OAAO,UAAU;CAGnB,IAAI,OAAO,YAAY,UACrB,OAAO,UAAU;CAGnB,IAAI,OAAO,YAAY,WACrB,OAAO,UAAU;CAGnB,IAAI,WAAW,OAAO,YAAY,UAChC,OAAO,UAAU;CAGnB,IAAI,YAAY,MACd,OAAO,UAAU;CAGnB,OAAO,UAAU;AACnB"}

package/dist/esm/dictionaryManipulator/index.mjs

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

package/dist/esm/dictionaryManipulator/mergeQualifiedDictionaries.mjs

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

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

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

package/dist/esm/dictionaryManipulator/qualifiedDictionary.mjs

@@ -11,6 +11,12 @@ const QUALIFIER_ORDER = ["variant", "item"];
 */
 const COMPOSITE_ID_SEPARATOR = "/";
 /**
+* Identity of the implicit fallback variant. A selector that pins no variant
+* resolves to it, and a variant that declares no entry of its own falls back to
+* it — so a key only has to ship the entries that actually differ.
+*/
+const DEFAULT_VARIANT_ID = "default";
+/**
 * Characters kept verbatim in an encoded qualifier segment. Everything else is
 * percent-encoded so a segment can never contain the composite-id separator
 * (`/`), path-hostile characters (`\` `:` `*` `?` `"` `<` `>` `|`, control
@@ -49,7 +55,7 @@ const encodeSegmentText = (raw, unsafeChars) => {
 * an object variant in a selector must equal the one declared on the dictionary.
 */
 const serializeVariant = (variant) => {
-	if (variant === void 0) return "default";
+	if (variant === void 0) return DEFAULT_VARIANT_ID;
 	if (typeof variant === "string") return encodeSegmentText(variant, SEGMENT_UNSAFE_CHARS);
 	return Object.keys(variant).sort().map((field) => `${encodeSegmentText(field, COMPONENT_UNSAFE_CHARS)}=${encodeSegmentText(String(variant[field]), COMPONENT_UNSAFE_CHARS)}`).join("&");
 };
@@ -105,16 +111,33 @@ const getDictionaryCompositeIds = (dictionary, qualifierTypes) => {
 	return compositeIds;
 };
 /**
+* Resolves the variant id a selector actually targets among the ids a key
+* declares — the sparse-override fallback.
+*
+* The requested id wins when the key declares it. Otherwise the key falls back
+* to its `default` entry, so a variant only has to be declared where its
+* wording differs. When the key declares no `default` either, the requested id
+* is returned unchanged and the caller resolves to `null` / `[]`.
+*
+* @param requestedVariantId - The serialized variant id the selector asks for.
+* @param isVariantIdDeclared - Whether the key declares an entry for an id.
+*/
+const resolveEffectiveVariantId = (requestedVariantId, isVariantIdDeclared) => {
+	if (isVariantIdDeclared(requestedVariantId)) return requestedVariantId;
+	return isVariantIdDeclared("default") ? DEFAULT_VARIANT_ID : requestedVariantId;
+};
+/**
 * Tests whether a composite entry id matches a selector across every declared
 * dimension. Segments are compared in their encoded form (both the stored id
 * and the selector go through {@link serializeVariant}). The `item` dimension
 * matches any value when the selector does not provide one (open collection
-* axis).
+* axis); the `variant` dimension is compared against the already-resolved
+* effective id, so the fallback is applied consistently across dimensions.
 */
-const compositeIdMatchesSelector = (compositeId, qualifierTypes, selector) => {
+const compositeIdMatchesSelector = (compositeId, qualifierTypes, selector, effectiveVariantId) => {
 	const segments = compositeId.split("/");
 	return qualifierTypes.every((qualifierType, index) => {
-		if (qualifierType === "variant") return segments[index] === serializeVariant(selector?.variant);
+		if (qualifierType === "variant") return segments[index] === effectiveVariantId;
 		return selector?.item === void 0 || segments[index] === String(selector.item);
 	});
 };
@@ -154,8 +177,10 @@ const reconstructQualifiedEntry = (group, compositeId) => {
 * - Plain dictionary → returned as-is (selector ignored)
 * - `item` declared but not selected → every matching entry ordered by index
 * - `item` selected → the matching entry or null
-* - `variant` defaults to the `default` entry when not selected; an object
-*   variant resolves only when the selector provides an equal object
+* - `variant` defaults to the `default` entry when not selected, and falls back
+*   to it when the selected variant declares no entry of its own; an object
+*   variant resolves only when the selector provides an equal object (or, again,
+*   through the `default` fallback)
 *
 * Dimensions compose: e.g. a variant × item key with `{ variant: 'promo' }`
 * returns every promo item as an array; adding `{ item: 2 }` narrows to one.
@@ -164,7 +189,10 @@ const resolveQualifiedDictionary = (dictionaryOrGroup, selector) => {
 	if (!isQualifiedDictionaryGroup(dictionaryOrGroup)) return dictionaryOrGroup;
 	const { qualifierTypes, content } = dictionaryOrGroup;
 	const itemAxisOpen = qualifierTypes.includes("item") && selector?.item === void 0;
-	const matchedEntries = Object.keys(content).filter((compositeId) => compositeIdMatchesSelector(compositeId, qualifierTypes, selector)).map((compositeId) => reconstructQualifiedEntry(dictionaryOrGroup, compositeId));
+	const compositeIds = Object.keys(content);
+	const variantIndex = qualifierTypes.indexOf("variant");
+	const effectiveVariantId = variantIndex === -1 ? DEFAULT_VARIANT_ID : resolveEffectiveVariantId(serializeVariant(selector?.variant), (variantId) => compositeIds.some((compositeId) => compositeId.split("/")[variantIndex] === variantId));
+	const matchedEntries = compositeIds.filter((compositeId) => compositeIdMatchesSelector(compositeId, qualifierTypes, selector, effectiveVariantId)).map((compositeId) => reconstructQualifiedEntry(dictionaryOrGroup, compositeId));
 	if (itemAxisOpen) return matchedEntries.sort((left, right) => (left.item ?? 0) - (right.item ?? 0));
 	return matchedEntries[0] ?? null;
 };
@@ -231,7 +259,7 @@ const collectQualifiedChunks = (loaderMap, key, locale, selector) => {
 			for (const segment of Object.keys(tree).sort((left, right) => Number(left) - Number(right))) walk(tree[segment], rest, [...segments, segment]);
 			return true;
 		}
-		const segment = dimension === "variant" ? serializeVariant(selector?.variant) : String(selector?.item);
+		const segment = dimension === "variant" ? resolveEffectiveVariantId(serializeVariant(selector?.variant), (variantId) => tree[variantId] !== void 0) : String(selector?.item);
 		const child = tree[segment];
 		if (!child) return false;
 		return walk(child, rest, [...segments, segment]);
@@ -247,11 +275,11 @@ const collectQualifiedChunks = (loaderMap, key, locale, selector) => {
 * loading only the chunk(s) the selector actually targets.
 *
 * Walks the nested loader tree one dimension at a time (canonical order
-* `variant → item`): `variant` defaults to `default` (or descends by the
-* serialized object identity), and `item` either narrows to the selected index
-* or — when no item is given — expands into every sibling chunk (the collection
-* axis). Semantics mirror {@link resolveQualifiedDictionary} so dynamic and
-* static modes behave alike.
+* `variant → item`): `variant` descends by the serialized id, falling back to
+* `default` when the selected variant has no chunk of its own, and `item`
+* either narrows to the selected index or — when no item is given — expands
+* into every sibling chunk (the collection axis). Semantics mirror
+* {@link resolveQualifiedDictionary} so dynamic and static modes behave alike.
 *
 * The Suspense mechanism is injected through `loadChunk` so the same logic
 * serves both the client (suspender cache) and the server (`react.use`). Every
@@ -296,5 +324,5 @@ const resolveQualifiedDynamicContentAsync = async (params) => {
 };
 
 //#endregion
-export { COMPOSITE_ID_SEPARATOR, QUALIFIER_DYNAMIC_TYPES_KEY, QUALIFIER_ORDER, getDictionaryCompositeIds, getDictionaryQualifierIds, getDictionaryQualifierTypes, getDictionarySelectorCacheKey, getVariantIds, isQualifiedDictionaryGroup, isQualifiedDynamicLoaderMap, parseDictionarySelector, reconstructQualifiedEntry, resolveQualifiedDictionary, resolveQualifiedDynamicContent, resolveQualifiedDynamicContentAsync, serializeVariant };
+export { COMPOSITE_ID_SEPARATOR, DEFAULT_VARIANT_ID, QUALIFIER_DYNAMIC_TYPES_KEY, QUALIFIER_ORDER, getDictionaryCompositeIds, getDictionaryQualifierIds, getDictionaryQualifierTypes, getDictionarySelectorCacheKey, getVariantIds, isQualifiedDictionaryGroup, isQualifiedDynamicLoaderMap, parseDictionarySelector, reconstructQualifiedEntry, resolveQualifiedDictionary, resolveQualifiedDynamicContent, resolveQualifiedDynamicContentAsync, serializeVariant };
 //# sourceMappingURL=qualifiedDictionary.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"qualifiedDictionary.mjs","names":[],"sources":["../../../src/dictionaryManipulator/qualifiedDictionary.ts"],"sourcesContent":["import type {\n  Dictionary,\n  DictionaryQualifierType,\n  DictionarySelector,\n  DictionaryVariantValue,\n  QualifiedDictionaryGroup,\n} from '@intlayer/types/dictionary';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\n\n/**\n * Canonical order of qualifier dimensions. A key that declares both dimensions\n * always nests them in this order, with `item` innermost so it can act as the\n * collection (array) axis.\n */\nexport const QUALIFIER_ORDER = [\n  'variant',\n  'item',\n] as const satisfies readonly DictionaryQualifierType[];\n\n/**\n * Separator joining per-dimension ids into a composite entry id. Also used as\n * the chunk path separator in dynamic mode.\n */\nexport const COMPOSITE_ID_SEPARATOR = '/';\n\n/**\n * Characters kept verbatim in an encoded qualifier segment. Everything else is\n * percent-encoded so a segment can never contain the composite-id separator\n * (`/`), path-hostile characters (`\\` `:` `*` `?` `\"` `<` `>` `|`, control\n * chars), or characters that would break the generated loader modules (`'`).\n */\nconst SEGMENT_UNSAFE_CHARS = /[^A-Za-z0-9._&=-]/g;\n\n/**\n * Stricter set for the components of an object variant: also encodes `&` and\n * `=` so the `field=value&field=value` serialization stays unambiguous.\n */\nconst COMPONENT_UNSAFE_CHARS = /[^A-Za-z0-9._-]/g;\n\n/** Percent-encodes one UTF-16 code unit as a fixed-width `%XXXX` run. */\nconst percentEncodeChar = (char: string): string =>\n  `%${char.charCodeAt(0).toString(16).toUpperCase().padStart(4, '0')}`;\n\nconst encodeSegmentText = (raw: string, unsafeChars: RegExp): string => {\n  // Bare '%' cannot be produced by encoding (every encoded run is %XXXX),\n  // so it is a safe stand-in for the empty string.\n  if (raw === '') return '%';\n\n  const encoded = raw.replace(unsafeChars, percentEncodeChar);\n\n  // '.' and '..' are path navigation on every filesystem — encode the dots.\n  if (encoded === '.' || encoded === '..') {\n    return encoded.replace(/\\./g, '%002E');\n  }\n\n  return encoded;\n};\n\n/**\n * Canonical serialization of a single variant value into its identity string —\n * the variant segment of a composite id, the chunk directory name in dynamic\n * mode, and the runtime matching key.\n *\n * - `undefined` → `'default'` (the implicit fallback variant)\n * - a string → the string itself (a named variant)\n * - an object → its sorted `key=value` pairs joined by `&`\n *   (e.g. `{ userId: '123', id: 'abc' }` → `'id=abc&userId=123'`)\n *\n * Characters that are unsafe in file paths or generated code are\n * percent-encoded (fixed-width `%XXXX` runs, injective). Common names —\n * letters, digits, `-` `_` `.` — are left untouched. Both the declaration and\n * the selector go through this function, so encoding never affects matching.\n *\n * Two variants resolve to the same entry iff their serializations are equal, so\n * an object variant in a selector must equal the one declared on the dictionary.\n */\nexport const serializeVariant = (\n  variant: DictionaryVariantValue | undefined\n): string => {\n  if (variant === undefined) return 'default';\n  if (typeof variant === 'string') {\n    return encodeSegmentText(variant, SEGMENT_UNSAFE_CHARS);\n  }\n\n  return Object.keys(variant)\n    .sort()\n    .map(\n      (field) =>\n        `${encodeSegmentText(field, COMPONENT_UNSAFE_CHARS)}=${encodeSegmentText(String(variant[field]), COMPONENT_UNSAFE_CHARS)}`\n    )\n    .join('&');\n};\n\n/**\n * Normalizes the `variant` field of a dictionary into the list of variant ids\n * the declaration registers under. A single value yields one id; an **array**\n * fans out into one id per element (duplicates collapsed). Returns `undefined`\n * when the dictionary does not declare the variant dimension (no `variant`\n * field, or an empty array).\n */\nexport const getVariantIds = (\n  variant: Dictionary['variant']\n): string[] | undefined => {\n  if (variant === undefined) return undefined;\n\n  const values = Array.isArray(variant) ? variant : [variant];\n  if (values.length === 0) return undefined;\n\n  return [...new Set(values.map(serializeVariant))];\n};\n\n/**\n * Returns the qualifier dimensions declared on a dictionary, in canonical\n * order (`variant → item`). Empty when the dictionary is unqualified\n * (plain dictionary or shared base content of a qualified group).\n */\nexport const getDictionaryQualifierTypes = (\n  dictionary: Dictionary\n): DictionaryQualifierType[] => {\n  const declaredQualifiers: DictionaryQualifierType[] = [];\n\n  if (getVariantIds(dictionary.variant) !== undefined) {\n    declaredQualifiers.push('variant');\n  }\n  if (typeof dictionary.item === 'number') declaredQualifiers.push('item');\n\n  return declaredQualifiers;\n};\n\n/**\n * Returns the qualifier identifiers of a dictionary for the given qualifier\n * dimension — the candidate segments of the composite entry ids.\n *\n * - 'variant' → the serialized variant id(s); an array variant yields one id\n *   per element (declaration-side fan-out)\n * - 'item' → the item index as a single-element list\n */\nexport const getDictionaryQualifierIds = (\n  dictionary: Dictionary,\n  qualifierType: DictionaryQualifierType\n): string[] | undefined => {\n  if (qualifierType === 'variant') {\n    return getVariantIds(dictionary.variant);\n  }\n  return dictionary.item === undefined ? undefined : [String(dictionary.item)];\n};\n\n/**\n * Builds every composite entry id of a dictionary — the cartesian product of\n * its per-dimension id lists, joined in canonical order. A dictionary with a\n * plain (non-array) variant yields exactly one id; an array variant fans out\n * into one id per element. `undefined` when a dimension of the set is missing.\n */\nexport const getDictionaryCompositeIds = (\n  dictionary: Dictionary,\n  qualifierTypes: DictionaryQualifierType[]\n): string[] | undefined => {\n  let compositeIds: string[] = [''];\n\n  for (const qualifierType of qualifierTypes) {\n    const ids = getDictionaryQualifierIds(dictionary, qualifierType);\n    if (ids === undefined) return undefined;\n\n    compositeIds = compositeIds.flatMap((prefix) =>\n      ids.map((id) =>\n        prefix === '' ? id : `${prefix}${COMPOSITE_ID_SEPARATOR}${id}`\n      )\n    );\n  }\n\n  return compositeIds;\n};\n\n/**\n * Tests whether a composite entry id matches a selector across every declared\n * dimension. Segments are compared in their encoded form (both the stored id\n * and the selector go through {@link serializeVariant}). The `item` dimension\n * matches any value when the selector does not provide one (open collection\n * axis).\n */\nconst compositeIdMatchesSelector = (\n  compositeId: string,\n  qualifierTypes: DictionaryQualifierType[],\n  selector: DictionarySelector | undefined\n): boolean => {\n  const segments = compositeId.split(COMPOSITE_ID_SEPARATOR);\n\n  return qualifierTypes.every((qualifierType, index) => {\n    if (qualifierType === 'variant') {\n      return segments[index] === serializeVariant(selector?.variant);\n    }\n\n    // qualifierType === 'item'\n    return (\n      selector?.item === undefined || segments[index] === String(selector.item)\n    );\n  });\n};\n\n/**\n * Type guard discriminating a `QualifiedDictionaryGroup` (merge output of a\n * qualified key) from a plain `Dictionary`. Both carry a `content` field; only\n * the group declares `qualifierTypes`, which is therefore the discriminator.\n */\nexport const isQualifiedDictionaryGroup = (\n  value: unknown\n): value is QualifiedDictionaryGroup =>\n  typeof value === 'object' &&\n  value !== null &&\n  'qualifierTypes' in value &&\n  Array.isArray((value as { qualifierTypes: unknown }).qualifierTypes) &&\n  'content' in value;\n\n/**\n * Reconstructs a resolvable {@link Dictionary} from a single entry of a\n * qualified group: the content node stored under its composite id, plus the\n * qualifier coordinates decoded from that id (`variant`, `item`).\n *\n * This keeps the resolver's transform code unchanged: it still sees a\n * `{ key, content, variant?, item? }` shape, even though the stored format no\n * longer duplicates those fields per entry. The `variant` coordinate stays in\n * its serialized (encoded) form, e.g. `'id=abc&userId=123'` — matching happens\n * on the composite id segments, never on this reconstructed field.\n */\nexport const reconstructQualifiedEntry = (\n  group: QualifiedDictionaryGroup,\n  compositeId: string\n): Dictionary => {\n  const segments = compositeId.split(COMPOSITE_ID_SEPARATOR);\n\n  const entry = {\n    key: group.key,\n    content: group.content[compositeId],\n  } as Dictionary;\n\n  group.qualifierTypes.forEach((qualifierType, index) => {\n    if (qualifierType === 'variant') {\n      entry.variant = segments[index];\n    } else if (qualifierType === 'item') {\n      entry.item = Number(segments[index]);\n    }\n  });\n\n  return entry;\n};\n\n/**\n * Resolves a dictionary (or qualified dictionary group) against a selector,\n * across every declared dimension.\n *\n * - Plain dictionary → returned as-is (selector ignored)\n * - `item` declared but not selected → every matching entry ordered by index\n * - `item` selected → the matching entry or null\n * - `variant` defaults to the `default` entry when not selected; an object\n *   variant resolves only when the selector provides an equal object\n *\n * Dimensions compose: e.g. a variant × item key with `{ variant: 'promo' }`\n * returns every promo item as an array; adding `{ item: 2 }` narrows to one.\n */\nexport const resolveQualifiedDictionary = (\n  dictionaryOrGroup: Dictionary | QualifiedDictionaryGroup,\n  selector?: DictionarySelector\n): Dictionary | Dictionary[] | null => {\n  if (!isQualifiedDictionaryGroup(dictionaryOrGroup)) {\n    return dictionaryOrGroup;\n  }\n\n  const { qualifierTypes, content } = dictionaryOrGroup;\n\n  const itemAxisOpen =\n    qualifierTypes.includes('item') && selector?.item === undefined;\n\n  const matchedEntries = Object.keys(content)\n    .filter((compositeId) =>\n      compositeIdMatchesSelector(compositeId, qualifierTypes, selector)\n    )\n    .map((compositeId) =>\n      reconstructQualifiedEntry(dictionaryOrGroup, compositeId)\n    );\n\n  if (itemAxisOpen) {\n    return matchedEntries.sort(\n      (left, right) => (left.item ?? 0) - (right.item ?? 0)\n    );\n  }\n\n  return matchedEntries[0] ?? null;\n};\n\n/**\n * Splits the second argument of `getIntlayer` / `getDictionary` into the\n * effective locale and the selector object (if any).\n */\nexport const parseDictionarySelector = <L extends LocalesValues>(\n  localeOrSelector?: L | DictionarySelector\n): { locale?: L; selector?: DictionarySelector } => {\n  if (typeof localeOrSelector === 'object' && localeOrSelector !== null) {\n    return {\n      locale: localeOrSelector.locale as L | undefined,\n      selector: localeOrSelector,\n    };\n  }\n\n  return { locale: localeOrSelector };\n};\n\n/**\n * Builds a stable string identity of a selector (excluding `locale`), suitable\n * for cache keys and memoization dependencies.\n */\nexport const getDictionarySelectorCacheKey = (\n  selector?: DictionarySelector\n): string => {\n  if (!selector) return '';\n\n  return Object.keys(selector)\n    .filter((selectorKey) => selectorKey !== 'locale')\n    .sort()\n    .map((selectorKey) => {\n      const value = selector[selectorKey as keyof DictionarySelector];\n      const serialized =\n        selectorKey === 'variant'\n          ? serializeVariant(value as Parameters<typeof serializeVariant>[0])\n          : String(value);\n      return `${selectorKey}:${serialized}`;\n    })\n    .join('|');\n};\n\n/**\n * Marker property carrying the ordered qualifier dimensions on a dynamic loader\n * map. Its presence distinguishes a qualified group loader map (a nested tree\n * of chunks) from a plain dynamic loader map (one chunk per `locale`). Prefixed\n * and unlikely to collide with a real locale code.\n */\nexport const QUALIFIER_DYNAMIC_TYPES_KEY = '__intlayerQualifierTypes';\n\n/**\n * A lazily-imported per-locale dictionary chunk loader.\n */\nexport type DynamicDictionaryLoader = () => Promise<Dictionary>;\n\n/**\n * Nested tree of chunk loaders: one nesting level per declared dimension (in\n * canonical order), leaves are loaders.\n */\nexport type QualifiedDynamicLoaderTree = {\n  [segment: string]: QualifiedDynamicLoaderTree | DynamicDictionaryLoader;\n};\n\n/**\n * Default export shape of a generated dynamic entry point for a qualified key.\n * One nesting level per dimension under each locale, plus the dimension marker.\n *\n * ```ts\n * {\n *   __intlayerQualifierTypes: ['variant', 'item'],\n *   en: { promo: { '1': () => import('./json/x/promo/1/en.json'), … }, … },\n *   fr: { … },\n * }\n * ```\n */\nexport type QualifiedDynamicLoaderMap = {\n  [QUALIFIER_DYNAMIC_TYPES_KEY]: DictionaryQualifierType[];\n  [locale: string]: QualifiedDynamicLoaderTree | DictionaryQualifierType[];\n};\n\n/**\n * Type guard discriminating a qualified dynamic loader map (collections /\n * variants, possibly combined) from a plain dynamic loader map.\n */\nexport const isQualifiedDynamicLoaderMap = (\n  value: unknown\n): value is QualifiedDynamicLoaderMap =>\n  typeof value === 'object' &&\n  value !== null &&\n  QUALIFIER_DYNAMIC_TYPES_KEY in value;\n\n/**\n/** One targeted chunk: its stable cache key and lazy loader. */\ntype CollectedChunk = {\n  cacheKey: string;\n  loader: DynamicDictionaryLoader;\n};\n\ntype CollectedChunks = {\n  /** True when the `item` axis is open (collection result → array). */\n  itemAxisOpen: boolean;\n  /** True when a required coordinate is absent (result → [] or null). */\n  missed: boolean;\n  /** The chunks the selector targets (in collection order for the item axis). */\n  chunks: CollectedChunk[];\n};\n\n/**\n * Walks the loader tree following the selector and collects the chunk loaders\n * it targets — shared by the sync ({@link resolveQualifiedDynamicContent}) and\n * async ({@link resolveQualifiedDynamicContentAsync}) resolvers.\n */\nconst collectQualifiedChunks = (\n  loaderMap: QualifiedDynamicLoaderMap,\n  key: string,\n  locale: string,\n  selector: DictionarySelector | undefined\n): CollectedChunks => {\n  const qualifierTypes = loaderMap[QUALIFIER_DYNAMIC_TYPES_KEY];\n  const localeTree = loaderMap[locale] as\n    | QualifiedDynamicLoaderTree\n    | undefined;\n\n  const itemAxisOpen =\n    qualifierTypes.includes('item') && selector?.item === undefined;\n\n  if (!localeTree) return { itemAxisOpen, missed: true, chunks: [] };\n\n  const chunks: CollectedChunk[] = [];\n\n  const walk = (\n    node: QualifiedDynamicLoaderTree | DynamicDictionaryLoader,\n    dimensions: DictionaryQualifierType[],\n    segments: string[]\n  ): boolean => {\n    if (dimensions.length === 0) {\n      chunks.push({\n        cacheKey: `${key}.${locale}.${segments.join(COMPOSITE_ID_SEPARATOR)}`,\n        loader: node as DynamicDictionaryLoader,\n      });\n      return true;\n    }\n\n    const [dimension, ...rest] = dimensions;\n    const tree = node as QualifiedDynamicLoaderTree;\n\n    if (dimension === 'item' && selector?.item === undefined) {\n      // Open collection axis: fan out into every sibling chunk, ordered.\n      for (const segment of Object.keys(tree).sort(\n        (left, right) => Number(left) - Number(right)\n      )) {\n        walk(tree[segment]!, rest, [...segments, segment]);\n      }\n      return true;\n    }\n\n    const segment =\n      dimension === 'variant'\n        ? serializeVariant(selector?.variant)\n        : String(selector?.item);\n\n    const child = tree[segment];\n    if (!child) return false;\n\n    return walk(child, rest, [...segments, segment]);\n  };\n\n  const found = walk(localeTree, qualifierTypes, []);\n\n  return { itemAxisOpen, missed: !found, chunks };\n};\n\n/**\n * Resolves the content of a qualified dynamic loader map against a selector,\n * loading only the chunk(s) the selector actually targets.\n *\n * Walks the nested loader tree one dimension at a time (canonical order\n * `variant → item`): `variant` defaults to `default` (or descends by the\n * serialized object identity), and `item` either narrows to the selected index\n * or — when no item is given — expands into every sibling chunk (the collection\n * axis). Semantics mirror {@link resolveQualifiedDictionary} so dynamic and\n * static modes behave alike.\n *\n * The Suspense mechanism is injected through `loadChunk` so the same logic\n * serves both the client (suspender cache) and the server (`react.use`). Every\n * targeted loader is started before the first chunk is read, so sibling chunks\n * load in parallel rather than waterfalling.\n *\n * @param loaderMap - The qualified dynamic loader map (entry point default export).\n * @param key - The dictionary key (used to build stable chunk cache keys).\n * @param locale - The resolved locale to load chunks for.\n * @param selector - The selector splitting the qualifier dimensions.\n * @param loadChunk - Reads a started chunk promise, suspending until it resolves.\n * @param transform - Turns a resolved chunk dictionary into final content.\n */\nexport const resolveQualifiedDynamicContent = <Content>(params: {\n  loaderMap: QualifiedDynamicLoaderMap;\n  key: string;\n  locale: string;\n  selector: DictionarySelector | undefined;\n  loadChunk: (cacheKey: string, promise: Promise<Dictionary>) => Dictionary;\n  transform: (dictionary: Dictionary) => Content;\n}): Content | Content[] | null => {\n  const { loaderMap, key, locale, selector, loadChunk, transform } = params;\n\n  const { itemAxisOpen, missed, chunks } = collectQualifiedChunks(\n    loaderMap,\n    key,\n    locale,\n    selector\n  );\n\n  if (missed) return itemAxisOpen ? [] : null;\n\n  // Start every loader before reading, so siblings load in parallel.\n  const dictionaries = chunks.map(({ cacheKey, loader }) =>\n    loadChunk(cacheKey, loader())\n  );\n\n  if (itemAxisOpen) return dictionaries.map(transform);\n\n  const [dictionary] = dictionaries;\n  return dictionary ? transform(dictionary) : null;\n};\n\n/**\n * Async counterpart of {@link resolveQualifiedDynamicContent} for frameworks\n * that load dictionaries with `await` instead of Suspense (Vue, Svelte, Lit,\n * vanilla). Awaits every targeted chunk in parallel, then resolves identically.\n *\n * @param loaderMap - The qualified dynamic loader map.\n * @param key - The dictionary key (used to build stable chunk cache keys).\n * @param locale - The resolved locale to load chunks for.\n * @param selector - The selector splitting the qualifier dimensions.\n * @param transform - Turns a resolved chunk dictionary into final content.\n */\nexport const resolveQualifiedDynamicContentAsync = async <Content>(params: {\n  loaderMap: QualifiedDynamicLoaderMap;\n  key: string;\n  locale: string;\n  selector: DictionarySelector | undefined;\n  transform: (dictionary: Dictionary) => Content;\n}): Promise<Content | Content[] | null> => {\n  const { loaderMap, key, locale, selector, transform } = params;\n\n  const { itemAxisOpen, missed, chunks } = collectQualifiedChunks(\n    loaderMap,\n    key,\n    locale,\n    selector\n  );\n\n  if (missed) return itemAxisOpen ? [] : null;\n\n  const dictionaries = await Promise.all(chunks.map(({ loader }) => loader()));\n\n  if (itemAxisOpen) return dictionaries.map(transform);\n\n  const [dictionary] = dictionaries;\n  return dictionary ? transform(dictionary) : null;\n};\n"],"mappings":"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"}
+{"version":3,"file":"qualifiedDictionary.mjs","names":[],"sources":["../../../src/dictionaryManipulator/qualifiedDictionary.ts"],"sourcesContent":["import type {\n  Dictionary,\n  DictionaryQualifierType,\n  DictionarySelector,\n  DictionaryVariantValue,\n  QualifiedDictionaryGroup,\n} from '@intlayer/types/dictionary';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\n\n/**\n * Canonical order of qualifier dimensions. A key that declares both dimensions\n * always nests them in this order, with `item` innermost so it can act as the\n * collection (array) axis.\n */\nexport const QUALIFIER_ORDER = [\n  'variant',\n  'item',\n] as const satisfies readonly DictionaryQualifierType[];\n\n/**\n * Separator joining per-dimension ids into a composite entry id. Also used as\n * the chunk path separator in dynamic mode.\n */\nexport const COMPOSITE_ID_SEPARATOR = '/';\n\n/**\n * Identity of the implicit fallback variant. A selector that pins no variant\n * resolves to it, and a variant that declares no entry of its own falls back to\n * it — so a key only has to ship the entries that actually differ.\n */\nexport const DEFAULT_VARIANT_ID = 'default';\n\n/**\n * Characters kept verbatim in an encoded qualifier segment. Everything else is\n * percent-encoded so a segment can never contain the composite-id separator\n * (`/`), path-hostile characters (`\\` `:` `*` `?` `\"` `<` `>` `|`, control\n * chars), or characters that would break the generated loader modules (`'`).\n */\nconst SEGMENT_UNSAFE_CHARS = /[^A-Za-z0-9._&=-]/g;\n\n/**\n * Stricter set for the components of an object variant: also encodes `&` and\n * `=` so the `field=value&field=value` serialization stays unambiguous.\n */\nconst COMPONENT_UNSAFE_CHARS = /[^A-Za-z0-9._-]/g;\n\n/** Percent-encodes one UTF-16 code unit as a fixed-width `%XXXX` run. */\nconst percentEncodeChar = (char: string): string =>\n  `%${char.charCodeAt(0).toString(16).toUpperCase().padStart(4, '0')}`;\n\nconst encodeSegmentText = (raw: string, unsafeChars: RegExp): string => {\n  // Bare '%' cannot be produced by encoding (every encoded run is %XXXX),\n  // so it is a safe stand-in for the empty string.\n  if (raw === '') return '%';\n\n  const encoded = raw.replace(unsafeChars, percentEncodeChar);\n\n  // '.' and '..' are path navigation on every filesystem — encode the dots.\n  if (encoded === '.' || encoded === '..') {\n    return encoded.replace(/\\./g, '%002E');\n  }\n\n  return encoded;\n};\n\n/**\n * Canonical serialization of a single variant value into its identity string —\n * the variant segment of a composite id, the chunk directory name in dynamic\n * mode, and the runtime matching key.\n *\n * - `undefined` → `'default'` (the implicit fallback variant)\n * - a string → the string itself (a named variant)\n * - an object → its sorted `key=value` pairs joined by `&`\n *   (e.g. `{ userId: '123', id: 'abc' }` → `'id=abc&userId=123'`)\n *\n * Characters that are unsafe in file paths or generated code are\n * percent-encoded (fixed-width `%XXXX` runs, injective). Common names —\n * letters, digits, `-` `_` `.` — are left untouched. Both the declaration and\n * the selector go through this function, so encoding never affects matching.\n *\n * Two variants resolve to the same entry iff their serializations are equal, so\n * an object variant in a selector must equal the one declared on the dictionary.\n */\nexport const serializeVariant = (\n  variant: DictionaryVariantValue | undefined\n): string => {\n  if (variant === undefined) return DEFAULT_VARIANT_ID;\n  if (typeof variant === 'string') {\n    return encodeSegmentText(variant, SEGMENT_UNSAFE_CHARS);\n  }\n\n  return Object.keys(variant)\n    .sort()\n    .map(\n      (field) =>\n        `${encodeSegmentText(field, COMPONENT_UNSAFE_CHARS)}=${encodeSegmentText(String(variant[field]), COMPONENT_UNSAFE_CHARS)}`\n    )\n    .join('&');\n};\n\n/**\n * Normalizes the `variant` field of a dictionary into the list of variant ids\n * the declaration registers under. A single value yields one id; an **array**\n * fans out into one id per element (duplicates collapsed). Returns `undefined`\n * when the dictionary does not declare the variant dimension (no `variant`\n * field, or an empty array).\n */\nexport const getVariantIds = (\n  variant: Dictionary['variant']\n): string[] | undefined => {\n  if (variant === undefined) return undefined;\n\n  const values = Array.isArray(variant) ? variant : [variant];\n  if (values.length === 0) return undefined;\n\n  return [...new Set(values.map(serializeVariant))];\n};\n\n/**\n * Returns the qualifier dimensions declared on a dictionary, in canonical\n * order (`variant → item`). Empty when the dictionary is unqualified\n * (plain dictionary or shared base content of a qualified group).\n */\nexport const getDictionaryQualifierTypes = (\n  dictionary: Dictionary\n): DictionaryQualifierType[] => {\n  const declaredQualifiers: DictionaryQualifierType[] = [];\n\n  if (getVariantIds(dictionary.variant) !== undefined) {\n    declaredQualifiers.push('variant');\n  }\n  if (typeof dictionary.item === 'number') declaredQualifiers.push('item');\n\n  return declaredQualifiers;\n};\n\n/**\n * Returns the qualifier identifiers of a dictionary for the given qualifier\n * dimension — the candidate segments of the composite entry ids.\n *\n * - 'variant' → the serialized variant id(s); an array variant yields one id\n *   per element (declaration-side fan-out)\n * - 'item' → the item index as a single-element list\n */\nexport const getDictionaryQualifierIds = (\n  dictionary: Dictionary,\n  qualifierType: DictionaryQualifierType\n): string[] | undefined => {\n  if (qualifierType === 'variant') {\n    return getVariantIds(dictionary.variant);\n  }\n  return dictionary.item === undefined ? undefined : [String(dictionary.item)];\n};\n\n/**\n * Builds every composite entry id of a dictionary — the cartesian product of\n * its per-dimension id lists, joined in canonical order. A dictionary with a\n * plain (non-array) variant yields exactly one id; an array variant fans out\n * into one id per element. `undefined` when a dimension of the set is missing.\n */\nexport const getDictionaryCompositeIds = (\n  dictionary: Dictionary,\n  qualifierTypes: DictionaryQualifierType[]\n): string[] | undefined => {\n  let compositeIds: string[] = [''];\n\n  for (const qualifierType of qualifierTypes) {\n    const ids = getDictionaryQualifierIds(dictionary, qualifierType);\n    if (ids === undefined) return undefined;\n\n    compositeIds = compositeIds.flatMap((prefix) =>\n      ids.map((id) =>\n        prefix === '' ? id : `${prefix}${COMPOSITE_ID_SEPARATOR}${id}`\n      )\n    );\n  }\n\n  return compositeIds;\n};\n\n/**\n * Resolves the variant id a selector actually targets among the ids a key\n * declares — the sparse-override fallback.\n *\n * The requested id wins when the key declares it. Otherwise the key falls back\n * to its `default` entry, so a variant only has to be declared where its\n * wording differs. When the key declares no `default` either, the requested id\n * is returned unchanged and the caller resolves to `null` / `[]`.\n *\n * @param requestedVariantId - The serialized variant id the selector asks for.\n * @param isVariantIdDeclared - Whether the key declares an entry for an id.\n */\nconst resolveEffectiveVariantId = (\n  requestedVariantId: string,\n  isVariantIdDeclared: (variantId: string) => boolean\n): string => {\n  if (isVariantIdDeclared(requestedVariantId)) return requestedVariantId;\n\n  return isVariantIdDeclared(DEFAULT_VARIANT_ID)\n    ? DEFAULT_VARIANT_ID\n    : requestedVariantId;\n};\n\n/**\n * Tests whether a composite entry id matches a selector across every declared\n * dimension. Segments are compared in their encoded form (both the stored id\n * and the selector go through {@link serializeVariant}). The `item` dimension\n * matches any value when the selector does not provide one (open collection\n * axis); the `variant` dimension is compared against the already-resolved\n * effective id, so the fallback is applied consistently across dimensions.\n */\nconst compositeIdMatchesSelector = (\n  compositeId: string,\n  qualifierTypes: DictionaryQualifierType[],\n  selector: DictionarySelector | undefined,\n  effectiveVariantId: string\n): boolean => {\n  const segments = compositeId.split(COMPOSITE_ID_SEPARATOR);\n\n  return qualifierTypes.every((qualifierType, index) => {\n    if (qualifierType === 'variant') {\n      return segments[index] === effectiveVariantId;\n    }\n\n    // qualifierType === 'item'\n    return (\n      selector?.item === undefined || segments[index] === String(selector.item)\n    );\n  });\n};\n\n/**\n * Type guard discriminating a `QualifiedDictionaryGroup` (merge output of a\n * qualified key) from a plain `Dictionary`. Both carry a `content` field; only\n * the group declares `qualifierTypes`, which is therefore the discriminator.\n */\nexport const isQualifiedDictionaryGroup = (\n  value: unknown\n): value is QualifiedDictionaryGroup =>\n  typeof value === 'object' &&\n  value !== null &&\n  'qualifierTypes' in value &&\n  Array.isArray((value as { qualifierTypes: unknown }).qualifierTypes) &&\n  'content' in value;\n\n/**\n * Reconstructs a resolvable {@link Dictionary} from a single entry of a\n * qualified group: the content node stored under its composite id, plus the\n * qualifier coordinates decoded from that id (`variant`, `item`).\n *\n * This keeps the resolver's transform code unchanged: it still sees a\n * `{ key, content, variant?, item? }` shape, even though the stored format no\n * longer duplicates those fields per entry. The `variant` coordinate stays in\n * its serialized (encoded) form, e.g. `'id=abc&userId=123'` — matching happens\n * on the composite id segments, never on this reconstructed field.\n */\nexport const reconstructQualifiedEntry = (\n  group: QualifiedDictionaryGroup,\n  compositeId: string\n): Dictionary => {\n  const segments = compositeId.split(COMPOSITE_ID_SEPARATOR);\n\n  const entry = {\n    key: group.key,\n    content: group.content[compositeId],\n  } as Dictionary;\n\n  group.qualifierTypes.forEach((qualifierType, index) => {\n    if (qualifierType === 'variant') {\n      entry.variant = segments[index];\n    } else if (qualifierType === 'item') {\n      entry.item = Number(segments[index]);\n    }\n  });\n\n  return entry;\n};\n\n/**\n * Resolves a dictionary (or qualified dictionary group) against a selector,\n * across every declared dimension.\n *\n * - Plain dictionary → returned as-is (selector ignored)\n * - `item` declared but not selected → every matching entry ordered by index\n * - `item` selected → the matching entry or null\n * - `variant` defaults to the `default` entry when not selected, and falls back\n *   to it when the selected variant declares no entry of its own; an object\n *   variant resolves only when the selector provides an equal object (or, again,\n *   through the `default` fallback)\n *\n * Dimensions compose: e.g. a variant × item key with `{ variant: 'promo' }`\n * returns every promo item as an array; adding `{ item: 2 }` narrows to one.\n */\nexport const resolveQualifiedDictionary = (\n  dictionaryOrGroup: Dictionary | QualifiedDictionaryGroup,\n  selector?: DictionarySelector\n): Dictionary | Dictionary[] | null => {\n  if (!isQualifiedDictionaryGroup(dictionaryOrGroup)) {\n    return dictionaryOrGroup;\n  }\n\n  const { qualifierTypes, content } = dictionaryOrGroup;\n\n  const itemAxisOpen =\n    qualifierTypes.includes('item') && selector?.item === undefined;\n\n  const compositeIds = Object.keys(content);\n  const variantIndex = qualifierTypes.indexOf('variant');\n\n  const effectiveVariantId =\n    variantIndex === -1\n      ? DEFAULT_VARIANT_ID\n      : resolveEffectiveVariantId(\n          serializeVariant(selector?.variant),\n          (variantId) =>\n            compositeIds.some(\n              (compositeId) =>\n                compositeId.split(COMPOSITE_ID_SEPARATOR)[variantIndex] ===\n                variantId\n            )\n        );\n\n  const matchedEntries = compositeIds\n    .filter((compositeId) =>\n      compositeIdMatchesSelector(\n        compositeId,\n        qualifierTypes,\n        selector,\n        effectiveVariantId\n      )\n    )\n    .map((compositeId) =>\n      reconstructQualifiedEntry(dictionaryOrGroup, compositeId)\n    );\n\n  if (itemAxisOpen) {\n    return matchedEntries.sort(\n      (left, right) => (left.item ?? 0) - (right.item ?? 0)\n    );\n  }\n\n  return matchedEntries[0] ?? null;\n};\n\n/**\n * Splits the second argument of `getIntlayer` / `getDictionary` into the\n * effective locale and the selector object (if any).\n */\nexport const parseDictionarySelector = <L extends LocalesValues>(\n  localeOrSelector?: L | DictionarySelector\n): { locale?: L; selector?: DictionarySelector } => {\n  if (typeof localeOrSelector === 'object' && localeOrSelector !== null) {\n    return {\n      locale: localeOrSelector.locale as L | undefined,\n      selector: localeOrSelector,\n    };\n  }\n\n  return { locale: localeOrSelector };\n};\n\n/**\n * Builds a stable string identity of a selector (excluding `locale`), suitable\n * for cache keys and memoization dependencies.\n */\nexport const getDictionarySelectorCacheKey = (\n  selector?: DictionarySelector\n): string => {\n  if (!selector) return '';\n\n  return Object.keys(selector)\n    .filter((selectorKey) => selectorKey !== 'locale')\n    .sort()\n    .map((selectorKey) => {\n      const value = selector[selectorKey as keyof DictionarySelector];\n      const serialized =\n        selectorKey === 'variant'\n          ? serializeVariant(value as Parameters<typeof serializeVariant>[0])\n          : String(value);\n      return `${selectorKey}:${serialized}`;\n    })\n    .join('|');\n};\n\n/**\n * Marker property carrying the ordered qualifier dimensions on a dynamic loader\n * map. Its presence distinguishes a qualified group loader map (a nested tree\n * of chunks) from a plain dynamic loader map (one chunk per `locale`). Prefixed\n * and unlikely to collide with a real locale code.\n */\nexport const QUALIFIER_DYNAMIC_TYPES_KEY = '__intlayerQualifierTypes';\n\n/**\n * A lazily-imported per-locale dictionary chunk loader.\n */\nexport type DynamicDictionaryLoader = () => Promise<Dictionary>;\n\n/**\n * Nested tree of chunk loaders: one nesting level per declared dimension (in\n * canonical order), leaves are loaders.\n */\nexport type QualifiedDynamicLoaderTree = {\n  [segment: string]: QualifiedDynamicLoaderTree | DynamicDictionaryLoader;\n};\n\n/**\n * Default export shape of a generated dynamic entry point for a qualified key.\n * One nesting level per dimension under each locale, plus the dimension marker.\n *\n * ```ts\n * {\n *   __intlayerQualifierTypes: ['variant', 'item'],\n *   en: { promo: { '1': () => import('./json/x/promo/1/en.json'), … }, … },\n *   fr: { … },\n * }\n * ```\n */\nexport type QualifiedDynamicLoaderMap = {\n  [QUALIFIER_DYNAMIC_TYPES_KEY]: DictionaryQualifierType[];\n  [locale: string]: QualifiedDynamicLoaderTree | DictionaryQualifierType[];\n};\n\n/**\n * Type guard discriminating a qualified dynamic loader map (collections /\n * variants, possibly combined) from a plain dynamic loader map.\n */\nexport const isQualifiedDynamicLoaderMap = (\n  value: unknown\n): value is QualifiedDynamicLoaderMap =>\n  typeof value === 'object' &&\n  value !== null &&\n  QUALIFIER_DYNAMIC_TYPES_KEY in value;\n\n/**\n/** One targeted chunk: its stable cache key and lazy loader. */\ntype CollectedChunk = {\n  cacheKey: string;\n  loader: DynamicDictionaryLoader;\n};\n\ntype CollectedChunks = {\n  /** True when the `item` axis is open (collection result → array). */\n  itemAxisOpen: boolean;\n  /** True when a required coordinate is absent (result → [] or null). */\n  missed: boolean;\n  /** The chunks the selector targets (in collection order for the item axis). */\n  chunks: CollectedChunk[];\n};\n\n/**\n * Walks the loader tree following the selector and collects the chunk loaders\n * it targets — shared by the sync ({@link resolveQualifiedDynamicContent}) and\n * async ({@link resolveQualifiedDynamicContentAsync}) resolvers.\n */\nconst collectQualifiedChunks = (\n  loaderMap: QualifiedDynamicLoaderMap,\n  key: string,\n  locale: string,\n  selector: DictionarySelector | undefined\n): CollectedChunks => {\n  const qualifierTypes = loaderMap[QUALIFIER_DYNAMIC_TYPES_KEY];\n  const localeTree = loaderMap[locale] as\n    | QualifiedDynamicLoaderTree\n    | undefined;\n\n  const itemAxisOpen =\n    qualifierTypes.includes('item') && selector?.item === undefined;\n\n  if (!localeTree) return { itemAxisOpen, missed: true, chunks: [] };\n\n  const chunks: CollectedChunk[] = [];\n\n  const walk = (\n    node: QualifiedDynamicLoaderTree | DynamicDictionaryLoader,\n    dimensions: DictionaryQualifierType[],\n    segments: string[]\n  ): boolean => {\n    if (dimensions.length === 0) {\n      chunks.push({\n        cacheKey: `${key}.${locale}.${segments.join(COMPOSITE_ID_SEPARATOR)}`,\n        loader: node as DynamicDictionaryLoader,\n      });\n      return true;\n    }\n\n    const [dimension, ...rest] = dimensions;\n    const tree = node as QualifiedDynamicLoaderTree;\n\n    if (dimension === 'item' && selector?.item === undefined) {\n      // Open collection axis: fan out into every sibling chunk, ordered.\n      for (const segment of Object.keys(tree).sort(\n        (left, right) => Number(left) - Number(right)\n      )) {\n        walk(tree[segment]!, rest, [...segments, segment]);\n      }\n      return true;\n    }\n\n    // A variant with no chunk of its own falls back to the `default` chunk, so\n    // only the entries that actually differ need to be emitted.\n    const segment =\n      dimension === 'variant'\n        ? resolveEffectiveVariantId(\n            serializeVariant(selector?.variant),\n            (variantId) => tree[variantId] !== undefined\n          )\n        : String(selector?.item);\n\n    const child = tree[segment];\n    if (!child) return false;\n\n    return walk(child, rest, [...segments, segment]);\n  };\n\n  const found = walk(localeTree, qualifierTypes, []);\n\n  return { itemAxisOpen, missed: !found, chunks };\n};\n\n/**\n * Resolves the content of a qualified dynamic loader map against a selector,\n * loading only the chunk(s) the selector actually targets.\n *\n * Walks the nested loader tree one dimension at a time (canonical order\n * `variant → item`): `variant` descends by the serialized id, falling back to\n * `default` when the selected variant has no chunk of its own, and `item`\n * either narrows to the selected index or — when no item is given — expands\n * into every sibling chunk (the collection axis). Semantics mirror\n * {@link resolveQualifiedDictionary} so dynamic and static modes behave alike.\n *\n * The Suspense mechanism is injected through `loadChunk` so the same logic\n * serves both the client (suspender cache) and the server (`react.use`). Every\n * targeted loader is started before the first chunk is read, so sibling chunks\n * load in parallel rather than waterfalling.\n *\n * @param loaderMap - The qualified dynamic loader map (entry point default export).\n * @param key - The dictionary key (used to build stable chunk cache keys).\n * @param locale - The resolved locale to load chunks for.\n * @param selector - The selector splitting the qualifier dimensions.\n * @param loadChunk - Reads a started chunk promise, suspending until it resolves.\n * @param transform - Turns a resolved chunk dictionary into final content.\n */\nexport const resolveQualifiedDynamicContent = <Content>(params: {\n  loaderMap: QualifiedDynamicLoaderMap;\n  key: string;\n  locale: string;\n  selector: DictionarySelector | undefined;\n  loadChunk: (cacheKey: string, promise: Promise<Dictionary>) => Dictionary;\n  transform: (dictionary: Dictionary) => Content;\n}): Content | Content[] | null => {\n  const { loaderMap, key, locale, selector, loadChunk, transform } = params;\n\n  const { itemAxisOpen, missed, chunks } = collectQualifiedChunks(\n    loaderMap,\n    key,\n    locale,\n    selector\n  );\n\n  if (missed) return itemAxisOpen ? [] : null;\n\n  // Start every loader before reading, so siblings load in parallel.\n  const dictionaries = chunks.map(({ cacheKey, loader }) =>\n    loadChunk(cacheKey, loader())\n  );\n\n  if (itemAxisOpen) return dictionaries.map(transform);\n\n  const [dictionary] = dictionaries;\n  return dictionary ? transform(dictionary) : null;\n};\n\n/**\n * Async counterpart of {@link resolveQualifiedDynamicContent} for frameworks\n * that load dictionaries with `await` instead of Suspense (Vue, Svelte, Lit,\n * vanilla). Awaits every targeted chunk in parallel, then resolves identically.\n *\n * @param loaderMap - The qualified dynamic loader map.\n * @param key - The dictionary key (used to build stable chunk cache keys).\n * @param locale - The resolved locale to load chunks for.\n * @param selector - The selector splitting the qualifier dimensions.\n * @param transform - Turns a resolved chunk dictionary into final content.\n */\nexport const resolveQualifiedDynamicContentAsync = async <Content>(params: {\n  loaderMap: QualifiedDynamicLoaderMap;\n  key: string;\n  locale: string;\n  selector: DictionarySelector | undefined;\n  transform: (dictionary: Dictionary) => Content;\n}): Promise<Content | Content[] | null> => {\n  const { loaderMap, key, locale, selector, transform } = params;\n\n  const { itemAxisOpen, missed, chunks } = collectQualifiedChunks(\n    loaderMap,\n    key,\n    locale,\n    selector\n  );\n\n  if (missed) return itemAxisOpen ? [] : null;\n\n  const dictionaries = await Promise.all(chunks.map(({ loader }) => loader()));\n\n  if (itemAxisOpen) return dictionaries.map(transform);\n\n  const [dictionary] = dictionaries;\n  return dictionary ? transform(dictionary) : null;\n};\n"],"mappings":";;;;;;AAcA,MAAa,kBAAkB,CAC7B,WACA,MACF;;;;;AAMA,MAAa,yBAAyB;;;;;;AAOtC,MAAa,qBAAqB;;;;;;;AAQlC,MAAM,uBAAuB;;;;;AAM7B,MAAM,yBAAyB;;AAG/B,MAAM,qBAAqB,SACzB,IAAI,KAAK,WAAW,CAAC,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,YAAY,CAAC,CAAC,SAAS,GAAG,GAAG;AAEnE,MAAM,qBAAqB,KAAa,gBAAgC;CAGtE,IAAI,QAAQ,IAAI,OAAO;CAEvB,MAAM,UAAU,IAAI,QAAQ,aAAa,iBAAiB;CAG1D,IAAI,YAAY,OAAO,YAAY,MACjC,OAAO,QAAQ,QAAQ,OAAO,OAAO;CAGvC,OAAO;AACT;;;;;;;;;;;;;;;;;;;AAoBA,MAAa,oBACX,YACW;CACX,IAAI,YAAY,QAAW,OAAO;CAClC,IAAI,OAAO,YAAY,UACrB,OAAO,kBAAkB,SAAS,oBAAoB;CAGxD,OAAO,OAAO,KAAK,OAAO,CAAC,CACxB,KAAK,CAAC,CACN,KACE,UACC,GAAG,kBAAkB,OAAO,sBAAsB,EAAE,GAAG,kBAAkB,OAAO,QAAQ,MAAM,GAAG,sBAAsB,GAC3H,CAAC,CACA,KAAK,GAAG;AACb;;;;;;;;AASA,MAAa,iBACX,YACyB;CACzB,IAAI,YAAY,QAAW,OAAO;CAElC,MAAM,SAAS,MAAM,QAAQ,OAAO,IAAI,UAAU,CAAC,OAAO;CAC1D,IAAI,OAAO,WAAW,GAAG,OAAO;CAEhC,OAAO,CAAC,GAAG,IAAI,IAAI,OAAO,IAAI,gBAAgB,CAAC,CAAC;AAClD;;;;;;AAOA,MAAa,+BACX,eAC8B;CAC9B,MAAM,qBAAgD,CAAC;CAEvD,IAAI,cAAc,WAAW,OAAO,MAAM,QACxC,mBAAmB,KAAK,SAAS;CAEnC,IAAI,OAAO,WAAW,SAAS,UAAU,mBAAmB,KAAK,MAAM;CAEvE,OAAO;AACT;;;;;;;;;AAUA,MAAa,6BACX,YACA,kBACyB;CACzB,IAAI,kBAAkB,WACpB,OAAO,cAAc,WAAW,OAAO;CAEzC,OAAO,WAAW,SAAS,SAAY,SAAY,CAAC,OAAO,WAAW,IAAI,CAAC;AAC7E;;;;;;;AAQA,MAAa,6BACX,YACA,mBACyB;CACzB,IAAI,eAAyB,CAAC,EAAE;CAEhC,KAAK,MAAM,iBAAiB,gBAAgB;EAC1C,MAAM,MAAM,0BAA0B,YAAY,aAAa;EAC/D,IAAI,QAAQ,QAAW,OAAO;EAE9B,eAAe,aAAa,SAAS,WACnC,IAAI,KAAK,OACP,WAAW,KAAK,KAAK,GAAG,eAAkC,IAC5D,CACF;CACF;CAEA,OAAO;AACT;;;;;;;;;;;;;AAcA,MAAM,6BACJ,oBACA,wBACW;CACX,IAAI,oBAAoB,kBAAkB,GAAG,OAAO;CAEpD,OAAO,6BAAsC,IACzC,qBACA;AACN;;;;;;;;;AAUA,MAAM,8BACJ,aACA,gBACA,UACA,uBACY;CACZ,MAAM,WAAW,YAAY,SAA4B;CAEzD,OAAO,eAAe,OAAO,eAAe,UAAU;EACpD,IAAI,kBAAkB,WACpB,OAAO,SAAS,WAAW;EAI7B,OACE,UAAU,SAAS,UAAa,SAAS,WAAW,OAAO,SAAS,IAAI;CAE5E,CAAC;AACH;;;;;;AAOA,MAAa,8BACX,UAEA,OAAO,UAAU,YACjB,UAAU,QACV,oBAAoB,SACpB,MAAM,QAAS,MAAsC,cAAc,KACnE,aAAa;;;;;;;;;;;;AAaf,MAAa,6BACX,OACA,gBACe;CACf,MAAM,WAAW,YAAY,SAA4B;CAEzD,MAAM,QAAQ;EACZ,KAAK,MAAM;EACX,SAAS,MAAM,QAAQ;CACzB;CAEA,MAAM,eAAe,SAAS,eAAe,UAAU;EACrD,IAAI,kBAAkB,WACpB,MAAM,UAAU,SAAS;OACpB,IAAI,kBAAkB,QAC3B,MAAM,OAAO,OAAO,SAAS,MAAM;CAEvC,CAAC;CAED,OAAO;AACT;;;;;;;;;;;;;;;;AAiBA,MAAa,8BACX,mBACA,aACqC;CACrC,IAAI,CAAC,2BAA2B,iBAAiB,GAC/C,OAAO;CAGT,MAAM,EAAE,gBAAgB,YAAY;CAEpC,MAAM,eACJ,eAAe,SAAS,MAAM,KAAK,UAAU,SAAS;CAExD,MAAM,eAAe,OAAO,KAAK,OAAO;CACxC,MAAM,eAAe,eAAe,QAAQ,SAAS;CAErD,MAAM,qBACJ,iBAAiB,KACb,qBACA,0BACE,iBAAiB,UAAU,OAAO,IACjC,cACC,aAAa,MACV,gBACC,YAAY,SAA4B,CAAC,CAAC,kBAC1C,SACJ,CACJ;CAEN,MAAM,iBAAiB,aACpB,QAAQ,gBACP,2BACE,aACA,gBACA,UACA,kBACF,CACF,CAAC,CACA,KAAK,gBACJ,0BAA0B,mBAAmB,WAAW,CAC1D;CAEF,IAAI,cACF,OAAO,eAAe,MACnB,MAAM,WAAW,KAAK,QAAQ,MAAM,MAAM,QAAQ,EACrD;CAGF,OAAO,eAAe,MAAM;AAC9B;;;;;AAMA,MAAa,2BACX,qBACkD;CAClD,IAAI,OAAO,qBAAqB,YAAY,qBAAqB,MAC/D,OAAO;EACL,QAAQ,iBAAiB;EACzB,UAAU;CACZ;CAGF,OAAO,EAAE,QAAQ,iBAAiB;AACpC;;;;;AAMA,MAAa,iCACX,aACW;CACX,IAAI,CAAC,UAAU,OAAO;CAEtB,OAAO,OAAO,KAAK,QAAQ,CAAC,CACzB,QAAQ,gBAAgB,gBAAgB,QAAQ,CAAC,CACjD,KAAK,CAAC,CACN,KAAK,gBAAgB;EACpB,MAAM,QAAQ,SAAS;EAKvB,OAAO,GAAG,YAAY,GAHpB,gBAAgB,YACZ,iBAAiB,KAA+C,IAChE,OAAO,KAAK;CAEpB,CAAC,CAAC,CACD,KAAK,GAAG;AACb;;;;;;;AAQA,MAAa,8BAA8B;;;;;AAoC3C,MAAa,+BACX,UAEA,OAAO,UAAU,YACjB,UAAU,sCACqB;;;;;;AAuBjC,MAAM,0BACJ,WACA,KACA,QACA,aACoB;CACpB,MAAM,iBAAiB,UAAU;CACjC,MAAM,aAAa,UAAU;CAI7B,MAAM,eACJ,eAAe,SAAS,MAAM,KAAK,UAAU,SAAS;CAExD,IAAI,CAAC,YAAY,OAAO;EAAE;EAAc,QAAQ;EAAM,QAAQ,CAAC;CAAE;CAEjE,MAAM,SAA2B,CAAC;CAElC,MAAM,QACJ,MACA,YACA,aACY;EACZ,IAAI,WAAW,WAAW,GAAG;GAC3B,OAAO,KAAK;IACV,UAAU,GAAG,IAAI,GAAG,OAAO,GAAG,SAAS,QAA2B;IAClE,QAAQ;GACV,CAAC;GACD,OAAO;EACT;EAEA,MAAM,CAAC,WAAW,GAAG,QAAQ;EAC7B,MAAM,OAAO;EAEb,IAAI,cAAc,UAAU,UAAU,SAAS,QAAW;GAExD,KAAK,MAAM,WAAW,OAAO,KAAK,IAAI,CAAC,CAAC,MACrC,MAAM,UAAU,OAAO,IAAI,IAAI,OAAO,KAAK,CAC9C,GACE,KAAK,KAAK,UAAW,MAAM,CAAC,GAAG,UAAU,OAAO,CAAC;GAEnD,OAAO;EACT;EAIA,MAAM,UACJ,cAAc,YACV,0BACE,iBAAiB,UAAU,OAAO,IACjC,cAAc,KAAK,eAAe,MACrC,IACA,OAAO,UAAU,IAAI;EAE3B,MAAM,QAAQ,KAAK;EACnB,IAAI,CAAC,OAAO,OAAO;EAEnB,OAAO,KAAK,OAAO,MAAM,CAAC,GAAG,UAAU,OAAO,CAAC;CACjD;CAIA,OAAO;EAAE;EAAc,QAAQ,CAFjB,KAAK,YAAY,gBAAgB,CAAC,CAEZ;EAAG;CAAO;AAChD;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,MAAa,kCAA2C,WAOtB;CAChC,MAAM,EAAE,WAAW,KAAK,QAAQ,UAAU,WAAW,cAAc;CAEnE,MAAM,EAAE,cAAc,QAAQ,WAAW,uBACvC,WACA,KACA,QACA,QACF;CAEA,IAAI,QAAQ,OAAO,eAAe,CAAC,IAAI;CAGvC,MAAM,eAAe,OAAO,KAAK,EAAE,UAAU,aAC3C,UAAU,UAAU,OAAO,CAAC,CAC9B;CAEA,IAAI,cAAc,OAAO,aAAa,IAAI,SAAS;CAEnD,MAAM,CAAC,cAAc;CACrB,OAAO,aAAa,UAAU,UAAU,IAAI;AAC9C;;;;;;;;;;;;AAaA,MAAa,sCAAsC,OAAgB,WAMxB;CACzC,MAAM,EAAE,WAAW,KAAK,QAAQ,UAAU,cAAc;CAExD,MAAM,EAAE,cAAc,QAAQ,WAAW,uBACvC,WACA,KACA,QACA,QACF;CAEA,IAAI,QAAQ,OAAO,eAAe,CAAC,IAAI;CAEvC,MAAM,eAAe,MAAM,QAAQ,IAAI,OAAO,KAAK,EAAE,aAAa,OAAO,CAAC,CAAC;CAE3E,IAAI,cAAc,OAAO,aAAa,IAAI,SAAS;CAEnD,MAAM,CAAC,cAAc;CACrB,OAAO,aAAa,UAAU,UAAU,IAAI;AAC9C"}

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

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

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

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

package/dist/esm/dictionaryManipulator/removeContentNodeByKeyPath.mjs

@@ -11,7 +11,7 @@ const removeContentNodeByKeyPath = (dictionaryContent, keyPath) => {
 			lastKey = keyObj.key;
 			currentValue = currentValue[keyObj.key];
 		}
-		if (keyObj.type === NodeTypes.TRANSLATION || keyObj.type === NodeTypes.ENUMERATION || keyObj.type === NodeTypes.PLURAL || keyObj.type === NodeTypes.CONDITION) {
+		if (keyObj.type === NodeTypes.TRANSLATION || keyObj.type === NodeTypes.ENUMERATION || keyObj.type === NodeTypes.PLURAL || keyObj.type === NodeTypes.CONDITION || keyObj.type === NodeTypes.GENDER || keyObj.type === NodeTypes.SELECT) {
 			lastKey = keyObj.type;
 			currentValue = currentValue[keyObj.type][keyObj.key];
 		}