@intlayer/core 9.1.3 → 9.3.0

package/dist/cjs/deepTransformPlugins/getEditedContent.cjs

@@ -4,8 +4,12 @@ let _intlayer_types_nodeType = require("@intlayer/types/nodeType");
 _intlayer_types_nodeType = require_runtime.__toESM(_intlayer_types_nodeType);
 
 //#region src/deepTransformPlugins/getEditedContent.ts
-const isTranslationNode = (node) => typeof node === "object" && node !== null && node.nodeType === _intlayer_types_nodeType.TRANSLATION;
-const isTypedNode = (node) => typeof node === "object" && node !== null && !Array.isArray(node) && typeof node.nodeType === "string";
+/** Whether `node` is a plain (non-array) object, i.e. a content branch. */
+const isRecordNode = (node) => typeof node === "object" && node !== null && !Array.isArray(node);
+/** Whether `node` is a typed node, whatever its `nodeType`. */
+const isTypedNode = (node) => isRecordNode(node) && typeof node.nodeType === "string";
+/** Whether `node` is a `translation` node holding a locale map. */
+const isTranslationNode = (node) => isTypedNode(node) && node.nodeType === _intlayer_types_nodeType.TRANSLATION && isRecordNode(node[_intlayer_types_nodeType.TRANSLATION]);
 /** Structural equality for leaf source values (string / number / nested objects). */
 const isSameValue = (a, b) => JSON.stringify(a) === JSON.stringify(b);
 /**
@@ -15,8 +19,8 @@ const isSameValue = (a, b) => JSON.stringify(a) === JSON.stringify(b);
 */
 const getEditedNode = (previous, next, defaultLocale) => {
 	if (isTranslationNode(next)) {
-		const nextValue = next[_intlayer_types_nodeType.TRANSLATION]?.[defaultLocale];
-		const previousValue = isTranslationNode(previous) ? previous[_intlayer_types_nodeType.TRANSLATION]?.[defaultLocale] : void 0;
+		const nextValue = next[_intlayer_types_nodeType.TRANSLATION][defaultLocale];
+		const previousValue = isTranslationNode(previous) ? previous[_intlayer_types_nodeType.TRANSLATION][defaultLocale] : void 0;
 		if (typeof nextValue === "undefined") return;
 		if (isSameValue(previousValue, nextValue)) return;
 		return {
@@ -47,8 +51,8 @@ const getEditedNode = (previous, next, defaultLocale) => {
 		});
 		return hasChange ? result : void 0;
 	}
-	if (typeof next === "object" && next !== null) {
-		const previousObject = typeof previous === "object" && previous !== null && !Array.isArray(previous) ? previous : void 0;
+	if (isRecordNode(next)) {
+		const previousObject = isRecordNode(previous) ? previous : void 0;
 		const result = {};
 		let hasChange = false;
 		for (const key of Object.keys(next)) {

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

@@ -1 +1 @@
-{"version":3,"file":"getEditedContent.cjs","names":["NodeTypes"],"sources":["../../../src/deepTransformPlugins/getEditedContent.ts"],"sourcesContent":["import type { ContentNode, Dictionary } from '@intlayer/types/dictionary';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport * as NodeTypes from '@intlayer/types/nodeType';\n\n/** A `translation` node, e.g. `{ nodeType: 'translation', translation: { en, fr } }`. */\ntype TranslationNode = {\n  nodeType: typeof NodeTypes.TRANSLATION;\n  [NodeTypes.TRANSLATION]: Record<string, unknown>;\n};\n\nconst isTranslationNode = (node: unknown): node is TranslationNode =>\n  typeof node === 'object' &&\n  node !== null &&\n  (node as { nodeType?: unknown }).nodeType === NodeTypes.TRANSLATION;\n\nconst isTypedNode = (\n  node: unknown\n): node is { nodeType: string; [key: string]: unknown } =>\n  typeof node === 'object' &&\n  node !== null &&\n  !Array.isArray(node) &&\n  typeof (node as { nodeType?: unknown }).nodeType === 'string';\n\n/** Structural equality for leaf source values (string / number / nested objects). */\nconst isSameValue = (a: unknown, b: unknown): boolean =>\n  JSON.stringify(a) === JSON.stringify(b);\n\n/**\n * Recursively compares `next` against `previous` and returns the sub-tree of\n * `next` that holds only the nodes whose source-locale value was added or\n * changed. Returns `undefined` when nothing changed at this node.\n */\nconst getEditedNode = (\n  previous: ContentNode | undefined,\n  next: ContentNode,\n  defaultLocale: LocalesValues\n): ContentNode | undefined => {\n  // Translation node: compare the default-locale leaf only.\n  if (isTranslationNode(next)) {\n    const nextValue = next[NodeTypes.TRANSLATION]?.[defaultLocale as string];\n    const previousValue = isTranslationNode(previous)\n      ? previous[NodeTypes.TRANSLATION]?.[defaultLocale as string]\n      : undefined;\n\n    // Nothing to (re)translate if the source locale is absent.\n    if (typeof nextValue === 'undefined') {\n      return undefined;\n    }\n\n    // Include only when the source value was added or changed.\n    if (isSameValue(previousValue, nextValue)) {\n      return undefined;\n    }\n\n    // Reduce to the source locale only, so every target locale is regenerated.\n    return {\n      nodeType: NodeTypes.TRANSLATION,\n      [NodeTypes.TRANSLATION]: { [defaultLocale as string]: nextValue },\n    } as ContentNode;\n  }\n\n  // Other typed nodes (enumeration, condition, nested, …): recurse into the\n  // wrapped value while preserving the wrapper so the partial stays valid.\n  if (isTypedNode(next)) {\n    const { nodeType } = next;\n    const previousInner = isTypedNode(previous)\n      ? (previous[nodeType] as ContentNode | undefined)\n      : undefined;\n    const editedInner = getEditedNode(\n      previousInner,\n      next[nodeType] as ContentNode,\n      defaultLocale\n    );\n\n    if (typeof editedInner === 'undefined') {\n      return undefined;\n    }\n\n    return {\n      nodeType,\n      [nodeType]: editedInner,\n    } as ContentNode;\n  }\n\n  // Arrays: keep changed items reduced to source-only, unchanged items as-is to\n  // preserve index alignment for `mergeDictionaries` (which merges by index).\n  if (Array.isArray(next)) {\n    const previousArray = Array.isArray(previous) ? previous : [];\n    let hasChange = false;\n\n    const result = next.map((child, index) => {\n      const editedChild = getEditedNode(\n        previousArray[index] as ContentNode | undefined,\n        child as ContentNode,\n        defaultLocale\n      );\n      if (typeof editedChild !== 'undefined') {\n        hasChange = true;\n        return editedChild;\n      }\n      // Unchanged item: keep the full node. It already has every locale, so the\n      // complete-mode translation pass skips it and the merge leaves it intact.\n      return child;\n    });\n\n    return hasChange ? (result as ContentNode) : undefined;\n  }\n\n  // Plain objects: recurse into each key, keeping only changed branches.\n  if (typeof next === 'object' && next !== null) {\n    const previousObject =\n      typeof previous === 'object' &&\n      previous !== null &&\n      !Array.isArray(previous)\n        ? (previous as Record<string, ContentNode>)\n        : undefined;\n\n    const result: Record<string, ContentNode> = {};\n    let hasChange = false;\n\n    for (const key of Object.keys(next as Record<string, ContentNode>)) {\n      const editedChild = getEditedNode(\n        previousObject?.[key],\n        (next as Record<string, ContentNode>)[key],\n        defaultLocale\n      );\n      if (typeof editedChild !== 'undefined') {\n        result[key] = editedChild;\n        hasChange = true;\n      }\n    }\n\n    return hasChange ? (result as ContentNode) : undefined;\n  }\n\n  // Primitive leaves are not locale-aware on their own — nothing to translate.\n  return undefined;\n};\n\n/**\n * Returns the partial content holding only the `translation` nodes whose\n * source (`defaultLocale`) value was added or changed between `previousContent`\n * and `newContent`. Each changed node is reduced to its source locale so that\n * every target locale is regenerated when the partial is translated.\n *\n * Returns `{}` (empty content) when no source value changed.\n *\n * @example\n * // default value of `title` changed → only `title` is returned, source-only\n * getEditedContent(\n *   { title: t({ en: 'Old', fr: 'Vieux' }), body: t({ en: 'B', fr: 'B' }) },\n *   { title: t({ en: 'New', fr: 'Vieux' }), body: t({ en: 'B', fr: 'B' }) },\n *   'en'\n * ); // → { title: { nodeType: 'translation', translation: { en: 'New' } } }\n */\nexport const getEditedContent = (\n  previousContent: ContentNode | undefined,\n  newContent: ContentNode,\n  defaultLocale: LocalesValues\n): ContentNode =>\n  getEditedNode(previousContent, newContent, defaultLocale) ??\n  ({} as ContentNode);\n\n/**\n * Dictionary-level wrapper around {@link getEditedContent}. Returns a partial\n * dictionary (same `key`) whose `content` holds only the changed source nodes.\n *\n * @param previousDictionary - Dictionary state before the edit.\n * @param newDictionary - Dictionary state after the edit.\n * @param defaultLocale - The source locale to diff against.\n */\nexport const getEditedDictionary = (\n  previousDictionary: Dictionary | undefined,\n  newDictionary: Dictionary,\n  defaultLocale: LocalesValues\n): Dictionary => ({\n  ...newDictionary,\n  content: getEditedContent(\n    previousDictionary?.content,\n    newDictionary.content,\n    defaultLocale\n  ),\n});\n"],"mappings":";;;;;;AAUA,MAAM,qBAAqB,SACzB,OAAO,SAAS,YAChB,SAAS,QACR,KAAgC,aAAaA,yBAAU;AAE1D,MAAM,eACJ,SAEA,OAAO,SAAS,YAChB,SAAS,QACT,CAAC,MAAM,QAAQ,IAAI,KACnB,OAAQ,KAAgC,aAAa;;AAGvD,MAAM,eAAe,GAAY,MAC/B,KAAK,UAAU,CAAC,MAAM,KAAK,UAAU,CAAC;;;;;;AAOxC,MAAM,iBACJ,UACA,MACA,kBAC4B;CAE5B,IAAI,kBAAkB,IAAI,GAAG;EAC3B,MAAM,YAAY,KAAKA,yBAAU,YAAY,GAAG;EAChD,MAAM,gBAAgB,kBAAkB,QAAQ,IAC5C,SAASA,yBAAU,YAAY,GAAG,iBAClC;EAGJ,IAAI,OAAO,cAAc,aACvB;EAIF,IAAI,YAAY,eAAe,SAAS,GACtC;EAIF,OAAO;GACL,UAAUA,yBAAU;IACnBA,yBAAU,cAAc,GAAG,gBAA0B,UAAU;EAClE;CACF;CAIA,IAAI,YAAY,IAAI,GAAG;EACrB,MAAM,EAAE,aAAa;EACrB,MAAM,gBAAgB,YAAY,QAAQ,IACrC,SAAS,YACV;EACJ,MAAM,cAAc,cAClB,eACA,KAAK,WACL,aACF;EAEA,IAAI,OAAO,gBAAgB,aACzB;EAGF,OAAO;GACL;IACC,WAAW;EACd;CACF;CAIA,IAAI,MAAM,QAAQ,IAAI,GAAG;EACvB,MAAM,gBAAgB,MAAM,QAAQ,QAAQ,IAAI,WAAW,CAAC;EAC5D,IAAI,YAAY;EAEhB,MAAM,SAAS,KAAK,KAAK,OAAO,UAAU;GACxC,MAAM,cAAc,cAClB,cAAc,QACd,OACA,aACF;GACA,IAAI,OAAO,gBAAgB,aAAa;IACtC,YAAY;IACZ,OAAO;GACT;GAGA,OAAO;EACT,CAAC;EAED,OAAO,YAAa,SAAyB;CAC/C;CAGA,IAAI,OAAO,SAAS,YAAY,SAAS,MAAM;EAC7C,MAAM,iBACJ,OAAO,aAAa,YACpB,aAAa,QACb,CAAC,MAAM,QAAQ,QAAQ,IAClB,WACD;EAEN,MAAM,SAAsC,CAAC;EAC7C,IAAI,YAAY;EAEhB,KAAK,MAAM,OAAO,OAAO,KAAK,IAAmC,GAAG;GAClE,MAAM,cAAc,cAClB,iBAAiB,MAChB,KAAqC,MACtC,aACF;GACA,IAAI,OAAO,gBAAgB,aAAa;IACtC,OAAO,OAAO;IACd,YAAY;GACd;EACF;EAEA,OAAO,YAAa,SAAyB;CAC/C;AAIF;;;;;;;;;;;;;;;;;AAkBA,MAAa,oBACX,iBACA,YACA,kBAEA,cAAc,iBAAiB,YAAY,aAAa,KACvD,CAAC;;;;;;;;;AAUJ,MAAa,uBACX,oBACA,eACA,mBACgB;CAChB,GAAG;CACH,SAAS,iBACP,oBAAoB,SACpB,cAAc,SACd,aACF;AACF"}
+{"version":3,"file":"getEditedContent.cjs","names":["NodeTypes"],"sources":["../../../src/deepTransformPlugins/getEditedContent.ts"],"sourcesContent":["import type { ContentNode, Dictionary } from '@intlayer/types/dictionary';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport type { TypedNodeModel } from '@intlayer/types/nodeType';\nimport * as NodeTypes from '@intlayer/types/nodeType';\n\n/**\n * Structural view of a dictionary content tree.\n *\n * `ContentNode` describes leaves and typed nodes only — the plain objects and\n * arrays that hold them are typed as `any` by the public `Dictionary['content']`.\n * Declaring those containers explicitly lets the diff walk a whole content tree\n * without casting at every step.\n */\ntype ContentTree = ContentNode | ContentTree[] | { [key: string]: ContentTree };\n\n/** A `translation` node, e.g. `{ nodeType: 'translation', translation: { en, fr } }`. */\ntype TranslationNode = TypedNodeModel<\n  typeof NodeTypes.TRANSLATION,\n  Record<string, ContentTree>\n>;\n\n/**\n * Any typed node — a wrapper holding its value under the key named by its own\n * `nodeType` (e.g. `{ nodeType: 'plural', plural: … }`).\n */\ntype TypedContentNode = {\n  nodeType: string;\n  [wrappedValueKey: string]: ContentTree;\n};\n\n/** Whether `node` is a plain (non-array) object, i.e. a content branch. */\nconst isRecordNode = (node: ContentTree): node is Record<string, ContentTree> =>\n  typeof node === 'object' && node !== null && !Array.isArray(node);\n\n/** Whether `node` is a typed node, whatever its `nodeType`. */\nconst isTypedNode = (node: ContentTree): node is TypedContentNode =>\n  isRecordNode(node) && typeof node.nodeType === 'string';\n\n/** Whether `node` is a `translation` node holding a locale map. */\nconst isTranslationNode = (node: ContentTree): node is TranslationNode =>\n  isTypedNode(node) &&\n  node.nodeType === NodeTypes.TRANSLATION &&\n  isRecordNode(node[NodeTypes.TRANSLATION]);\n\n/** Structural equality for leaf source values (string / number / nested objects). */\nconst isSameValue = (a: ContentTree, b: ContentTree): boolean =>\n  JSON.stringify(a) === JSON.stringify(b);\n\n/**\n * Recursively compares `next` against `previous` and returns the sub-tree of\n * `next` that holds only the nodes whose source-locale value was added or\n * changed. Returns `undefined` when nothing changed at this node.\n */\nconst getEditedNode = (\n  previous: ContentTree,\n  next: ContentTree,\n  defaultLocale: LocalesValues\n): ContentTree | undefined => {\n  // Translation node: compare the default-locale leaf only.\n  if (isTranslationNode(next)) {\n    const nextValue = next[NodeTypes.TRANSLATION][defaultLocale];\n    const previousValue = isTranslationNode(previous)\n      ? previous[NodeTypes.TRANSLATION][defaultLocale]\n      : undefined;\n\n    // Nothing to (re)translate if the source locale is absent.\n    if (typeof nextValue === 'undefined') {\n      return undefined;\n    }\n\n    // Include only when the source value was added or changed.\n    if (isSameValue(previousValue, nextValue)) {\n      return undefined;\n    }\n\n    // Reduce to the source locale only, so every target locale is regenerated.\n    return {\n      nodeType: NodeTypes.TRANSLATION,\n      [NodeTypes.TRANSLATION]: { [defaultLocale]: nextValue },\n    } satisfies TranslationNode;\n  }\n\n  // Other typed nodes (enumeration, condition, nested, …): recurse into the\n  // wrapped value while preserving the wrapper so the partial stays valid.\n  if (isTypedNode(next)) {\n    const { nodeType } = next;\n    const previousInner = isTypedNode(previous)\n      ? previous[nodeType]\n      : undefined;\n    const editedInner = getEditedNode(\n      previousInner,\n      next[nodeType],\n      defaultLocale\n    );\n\n    if (typeof editedInner === 'undefined') {\n      return undefined;\n    }\n\n    return {\n      nodeType,\n      [nodeType]: editedInner,\n    } satisfies TypedContentNode;\n  }\n\n  // Arrays: keep changed items reduced to source-only, unchanged items as-is to\n  // preserve index alignment for `mergeDictionaries` (which merges by index).\n  if (Array.isArray(next)) {\n    const previousArray = Array.isArray(previous) ? previous : [];\n    let hasChange = false;\n\n    const result = next.map((child, index) => {\n      const editedChild = getEditedNode(\n        previousArray[index],\n        child,\n        defaultLocale\n      );\n      if (typeof editedChild !== 'undefined') {\n        hasChange = true;\n        return editedChild;\n      }\n      // Unchanged item: keep the full node. It already has every locale, so the\n      // complete-mode translation pass skips it and the merge leaves it intact.\n      return child;\n    });\n\n    return hasChange ? result : undefined;\n  }\n\n  // Plain objects: recurse into each key, keeping only changed branches.\n  if (isRecordNode(next)) {\n    const previousObject = isRecordNode(previous) ? previous : undefined;\n\n    const result: Record<string, ContentTree> = {};\n    let hasChange = false;\n\n    for (const key of Object.keys(next)) {\n      const editedChild = getEditedNode(\n        previousObject?.[key],\n        next[key],\n        defaultLocale\n      );\n      if (typeof editedChild !== 'undefined') {\n        result[key] = editedChild;\n        hasChange = true;\n      }\n    }\n\n    return hasChange ? result : undefined;\n  }\n\n  // Primitive leaves are not locale-aware on their own — nothing to translate.\n  return undefined;\n};\n\n/**\n * Returns the partial content holding only the `translation` nodes whose\n * source (`defaultLocale`) value was added or changed between `previousContent`\n * and `newContent`. Each changed node is reduced to its source locale so that\n * every target locale is regenerated when the partial is translated.\n *\n * Returns `{}` (empty content) when no source value changed.\n *\n * @example\n * // default value of `title` changed → only `title` is returned, source-only\n * getEditedContent(\n *   { title: t({ en: 'Old', fr: 'Vieux' }), body: t({ en: 'B', fr: 'B' }) },\n *   { title: t({ en: 'New', fr: 'Vieux' }), body: t({ en: 'B', fr: 'B' }) },\n *   'en'\n * ); // → { title: { nodeType: 'translation', translation: { en: 'New' } } }\n */\nexport const getEditedContent = (\n  previousContent: ContentNode | undefined,\n  newContent: ContentNode,\n  defaultLocale: LocalesValues\n): ContentNode =>\n  // The result is a sub-tree of `newContent`, so narrowing the structural\n  // `ContentTree` back to the public `ContentNode` is sound: only the plain\n  // containers `ContentNode` leaves untyped are dropped from the type.\n  (getEditedNode(previousContent, newContent, defaultLocale) ??\n    {}) as ContentNode;\n\n/**\n * Dictionary-level wrapper around {@link getEditedContent}. Returns a partial\n * dictionary (same `key`) whose `content` holds only the changed source nodes.\n *\n * @param previousDictionary - Dictionary state before the edit.\n * @param newDictionary - Dictionary state after the edit.\n * @param defaultLocale - The source locale to diff against.\n */\nexport const getEditedDictionary = (\n  previousDictionary: Dictionary | undefined,\n  newDictionary: Dictionary,\n  defaultLocale: LocalesValues\n): Dictionary => ({\n  ...newDictionary,\n  content: getEditedContent(\n    previousDictionary?.content,\n    newDictionary.content,\n    defaultLocale\n  ),\n});\n"],"mappings":";;;;;;;AA+BA,MAAM,gBAAgB,SACpB,OAAO,SAAS,YAAY,SAAS,QAAQ,CAAC,MAAM,QAAQ,IAAI;;AAGlE,MAAM,eAAe,SACnB,aAAa,IAAI,KAAK,OAAO,KAAK,aAAa;;AAGjD,MAAM,qBAAqB,SACzB,YAAY,IAAI,KAChB,KAAK,aAAaA,yBAAU,eAC5B,aAAa,KAAKA,yBAAU,YAAY;;AAG1C,MAAM,eAAe,GAAgB,MACnC,KAAK,UAAU,CAAC,MAAM,KAAK,UAAU,CAAC;;;;;;AAOxC,MAAM,iBACJ,UACA,MACA,kBAC4B;CAE5B,IAAI,kBAAkB,IAAI,GAAG;EAC3B,MAAM,YAAY,KAAKA,yBAAU,YAAY,CAAC;EAC9C,MAAM,gBAAgB,kBAAkB,QAAQ,IAC5C,SAASA,yBAAU,YAAY,CAAC,iBAChC;EAGJ,IAAI,OAAO,cAAc,aACvB;EAIF,IAAI,YAAY,eAAe,SAAS,GACtC;EAIF,OAAO;GACL,UAAUA,yBAAU;IACnBA,yBAAU,cAAc,GAAG,gBAAgB,UAAU;EACxD;CACF;CAIA,IAAI,YAAY,IAAI,GAAG;EACrB,MAAM,EAAE,aAAa;EACrB,MAAM,gBAAgB,YAAY,QAAQ,IACtC,SAAS,YACT;EACJ,MAAM,cAAc,cAClB,eACA,KAAK,WACL,aACF;EAEA,IAAI,OAAO,gBAAgB,aACzB;EAGF,OAAO;GACL;IACC,WAAW;EACd;CACF;CAIA,IAAI,MAAM,QAAQ,IAAI,GAAG;EACvB,MAAM,gBAAgB,MAAM,QAAQ,QAAQ,IAAI,WAAW,CAAC;EAC5D,IAAI,YAAY;EAEhB,MAAM,SAAS,KAAK,KAAK,OAAO,UAAU;GACxC,MAAM,cAAc,cAClB,cAAc,QACd,OACA,aACF;GACA,IAAI,OAAO,gBAAgB,aAAa;IACtC,YAAY;IACZ,OAAO;GACT;GAGA,OAAO;EACT,CAAC;EAED,OAAO,YAAY,SAAS;CAC9B;CAGA,IAAI,aAAa,IAAI,GAAG;EACtB,MAAM,iBAAiB,aAAa,QAAQ,IAAI,WAAW;EAE3D,MAAM,SAAsC,CAAC;EAC7C,IAAI,YAAY;EAEhB,KAAK,MAAM,OAAO,OAAO,KAAK,IAAI,GAAG;GACnC,MAAM,cAAc,cAClB,iBAAiB,MACjB,KAAK,MACL,aACF;GACA,IAAI,OAAO,gBAAgB,aAAa;IACtC,OAAO,OAAO;IACd,YAAY;GACd;EACF;EAEA,OAAO,YAAY,SAAS;CAC9B;AAIF;;;;;;;;;;;;;;;;;AAkBA,MAAa,oBACX,iBACA,YACA,kBAKC,cAAc,iBAAiB,YAAY,aAAa,KACvD,CAAC;;;;;;;;;AAUL,MAAa,uBACX,oBACA,eACA,mBACgB;CAChB,GAAG;CACH,SAAS,iBACP,oBAAoB,SACpB,cAAc,SACd,aACF;AACF"}

package/dist/cjs/dictionaryManipulator/getNestedDictionaryReferences.cjs

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

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

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

package/dist/cjs/dictionaryManipulator/index.cjs

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

package/dist/cjs/dictionaryManipulator/mergeQualifiedDictionaries.cjs

@@ -1,6 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_dictionaryManipulator_qualifiedDictionary = require('./qualifiedDictionary.cjs');
 const require_dictionaryManipulator_mergeDictionaries = require('./mergeDictionaries.cjs');
+const require_dictionaryManipulator_qualifiedDictionaryDeclaration = require('./qualifiedDictionaryDeclaration.cjs');
 let _intlayer_config_built = require("@intlayer/config/built");
 let _intlayer_config_logger = require("@intlayer/config/logger");
 
@@ -24,10 +25,10 @@ let _intlayer_config_logger = require("@intlayer/config/logger");
 * declares only a subset is ambiguous and is rejected with an error log.
 */
 const mergeQualifiedDictionaries = (dictionaries) => {
-	const perDictionaryTypes = dictionaries.map(require_dictionaryManipulator_qualifiedDictionary.getDictionaryQualifierTypes);
+	const perDictionaryTypes = dictionaries.map(require_dictionaryManipulator_qualifiedDictionaryDeclaration.getDictionaryQualifierTypes);
 	const declaredDimensions = /* @__PURE__ */ new Set();
 	for (const types of perDictionaryTypes) for (const type of types) declaredDimensions.add(type);
-	const groupQualifierTypes = require_dictionaryManipulator_qualifiedDictionary.QUALIFIER_ORDER.filter((qualifierType) => declaredDimensions.has(qualifierType));
+	const groupQualifierTypes = require_dictionaryManipulator_qualifiedDictionaryDeclaration.QUALIFIER_ORDER.filter((qualifierType) => declaredDimensions.has(qualifierType));
 	if (groupQualifierTypes.length === 0) return require_dictionaryManipulator_mergeDictionaries.mergeDictionaries(dictionaries);
 	const appLogger = (0, _intlayer_config_logger.getAppLogger)({ log: _intlayer_config_built.log });
 	const baseDictionaries = [];
@@ -37,7 +38,7 @@ const mergeQualifiedDictionaries = (dictionaries) => {
 			baseDictionaries.push(dictionary);
 			return;
 		}
-		const compositeIds = require_dictionaryManipulator_qualifiedDictionary.getDictionaryCompositeIds(dictionary, groupQualifierTypes);
+		const compositeIds = require_dictionaryManipulator_qualifiedDictionaryDeclaration.getDictionaryCompositeIds(dictionary, groupQualifierTypes);
 		if (compositeIds === void 0) {
 			appLogger(`Dictionary ${(0, _intlayer_config_logger.colorizeKey)(dictionary.key)} declares (${perDictionaryTypes[index].join(", ")}) but the key's dimensions are (${groupQualifierTypes.join(", ")}); every entry must declare all of them. Entry ignored${dictionary.filePath ? ` - ${dictionary.filePath}` : ""}.`, { level: "error" });
 			return;

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

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

package/dist/cjs/dictionaryManipulator/qualifiedDictionary.cjs

@@ -2,12 +2,6 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 //#region src/dictionaryManipulator/qualifiedDictionary.ts
 /**
-* Canonical order of qualifier dimensions. A key that declares both dimensions
-* always nests them in this order, with `item` innermost so it can act as the
-* collection (array) axis.
-*/
-const QUALIFIER_ORDER = ["variant", "item"];
-/**
 * Separator joining per-dimension ids into a composite entry id. Also used as
 * the chunk path separator in dynamic mode.
 */
@@ -62,57 +56,6 @@ const serializeVariant = (variant) => {
 	return Object.keys(variant).sort().map((field) => `${encodeSegmentText(field, COMPONENT_UNSAFE_CHARS)}=${encodeSegmentText(String(variant[field]), COMPONENT_UNSAFE_CHARS)}`).join("&");
 };
 /**
-* Normalizes the `variant` field of a dictionary into the list of variant ids
-* the declaration registers under. A single value yields one id; an **array**
-* fans out into one id per element (duplicates collapsed). Returns `undefined`
-* when the dictionary does not declare the variant dimension (no `variant`
-* field, or an empty array).
-*/
-const getVariantIds = (variant) => {
-	if (variant === void 0) return void 0;
-	const values = Array.isArray(variant) ? variant : [variant];
-	if (values.length === 0) return void 0;
-	return [...new Set(values.map(serializeVariant))];
-};
-/**
-* Returns the qualifier dimensions declared on a dictionary, in canonical
-* order (`variant → item`). Empty when the dictionary is unqualified
-* (plain dictionary or shared base content of a qualified group).
-*/
-const getDictionaryQualifierTypes = (dictionary) => {
-	const declaredQualifiers = [];
-	if (getVariantIds(dictionary.variant) !== void 0) declaredQualifiers.push("variant");
-	if (typeof dictionary.item === "number") declaredQualifiers.push("item");
-	return declaredQualifiers;
-};
-/**
-* Returns the qualifier identifiers of a dictionary for the given qualifier
-* dimension — the candidate segments of the composite entry ids.
-*
-* - 'variant' → the serialized variant id(s); an array variant yields one id
-*   per element (declaration-side fan-out)
-* - 'item' → the item index as a single-element list
-*/
-const getDictionaryQualifierIds = (dictionary, qualifierType) => {
-	if (qualifierType === "variant") return getVariantIds(dictionary.variant);
-	return dictionary.item === void 0 ? void 0 : [String(dictionary.item)];
-};
-/**
-* Builds every composite entry id of a dictionary — the cartesian product of
-* its per-dimension id lists, joined in canonical order. A dictionary with a
-* plain (non-array) variant yields exactly one id; an array variant fans out
-* into one id per element. `undefined` when a dimension of the set is missing.
-*/
-const getDictionaryCompositeIds = (dictionary, qualifierTypes) => {
-	let compositeIds = [""];
-	for (const qualifierType of qualifierTypes) {
-		const ids = getDictionaryQualifierIds(dictionary, qualifierType);
-		if (ids === void 0) return void 0;
-		compositeIds = compositeIds.flatMap((prefix) => ids.map((id) => prefix === "" ? id : `${prefix}${"/"}${id}`));
-	}
-	return compositeIds;
-};
-/**
 * Serializes the variant coordinate of a selector into the ordered list of
 * candidate ids to try, so a single value and a preference chain share one code
 * path downstream.
@@ -290,130 +233,18 @@ const getDictionarySelectorCacheKey = (selector) => {
 		return `${selectorKey}:${selectorKey === "variant" ? serializeVariantChain(value).join(",") : String(value)}`;
 	}).join("|");
 };
-/**
-* Marker property carrying the ordered qualifier dimensions on a dynamic loader
-* map. Its presence distinguishes a qualified group loader map (a nested tree
-* of chunks) from a plain dynamic loader map (one chunk per `locale`). Prefixed
-* and unlikely to collide with a real locale code.
-*/
-const QUALIFIER_DYNAMIC_TYPES_KEY = "__intlayerQualifierTypes";
-/**
-* Type guard discriminating a qualified dynamic loader map (collections /
-* variants, possibly combined) from a plain dynamic loader map.
-*/
-const isQualifiedDynamicLoaderMap = (value) => typeof value === "object" && value !== null && "__intlayerQualifierTypes" in value;
-/**
-* Walks the loader tree following the selector and collects the chunk loaders
-* it targets — shared by the sync ({@link resolveQualifiedDynamicContent}) and
-* async ({@link resolveQualifiedDynamicContentAsync}) resolvers.
-*/
-const collectQualifiedChunks = (loaderMap, key, locale, selector) => {
-	const qualifierTypes = loaderMap[QUALIFIER_DYNAMIC_TYPES_KEY];
-	const localeTree = loaderMap[locale];
-	const itemAxisOpen = qualifierTypes.includes("item") && selector?.item === void 0;
-	if (!localeTree) return {
-		itemAxisOpen,
-		missed: true,
-		chunks: []
-	};
-	const chunks = [];
-	const walk = (node, dimensions, segments) => {
-		if (dimensions.length === 0) {
-			chunks.push({
-				cacheKey: `${key}.${locale}.${segments.join("/")}`,
-				loader: node
-			});
-			return true;
-		}
-		const [dimension, ...rest] = dimensions;
-		const tree = node;
-		if (dimension === "item" && selector?.item === void 0) {
-			for (const segment of Object.keys(tree).sort((left, right) => Number(left) - Number(right))) walk(tree[segment], rest, [...segments, segment]);
-			return true;
-		}
-		const segment = dimension === "variant" ? resolveEffectiveVariantId(serializeVariantChain(selector?.variant), (variantId) => tree[variantId] !== void 0) : String(selector?.item);
-		const child = tree[segment];
-		if (!child) return false;
-		return walk(child, rest, [...segments, segment]);
-	};
-	return {
-		itemAxisOpen,
-		missed: !walk(localeTree, qualifierTypes, []),
-		chunks
-	};
-};
-/**
-* Resolves the content of a qualified dynamic loader map against a selector,
-* loading only the chunk(s) the selector actually targets.
-*
-* Walks the nested loader tree one dimension at a time (canonical order
-* `variant → item`): `variant` descends by the serialized id, falling back to
-* `default` when the selected variant has no chunk of its own, and `item`
-* either narrows to the selected index or — when no item is given — expands
-* into every sibling chunk (the collection axis). Semantics mirror
-* {@link resolveQualifiedDictionary} so dynamic and static modes behave alike.
-*
-* The Suspense mechanism is injected through `loadChunk` so the same logic
-* serves both the client (suspender cache) and the server (`react.use`). Every
-* targeted loader is started before the first chunk is read, so sibling chunks
-* load in parallel rather than waterfalling.
-*
-* @param loaderMap - The qualified dynamic loader map (entry point default export).
-* @param key - The dictionary key (used to build stable chunk cache keys).
-* @param locale - The resolved locale to load chunks for.
-* @param selector - The selector splitting the qualifier dimensions.
-* @param loadChunk - Reads a started chunk promise, suspending until it resolves.
-* @param transform - Turns a resolved chunk dictionary into final content.
-*/
-const resolveQualifiedDynamicContent = (params) => {
-	const { loaderMap, key, locale, selector, loadChunk, transform } = params;
-	const { itemAxisOpen, missed, chunks } = collectQualifiedChunks(loaderMap, key, locale, selector);
-	if (missed) return itemAxisOpen ? [] : null;
-	const dictionaries = chunks.map(({ cacheKey, loader }) => loadChunk(cacheKey, loader()));
-	if (itemAxisOpen) return dictionaries.map(transform);
-	const [dictionary] = dictionaries;
-	return dictionary ? transform(dictionary) : null;
-};
-/**
-* Async counterpart of {@link resolveQualifiedDynamicContent} for frameworks
-* that load dictionaries with `await` instead of Suspense (Vue, Svelte, Lit,
-* vanilla). Awaits every targeted chunk in parallel, then resolves identically.
-*
-* @param loaderMap - The qualified dynamic loader map.
-* @param key - The dictionary key (used to build stable chunk cache keys).
-* @param locale - The resolved locale to load chunks for.
-* @param selector - The selector splitting the qualifier dimensions.
-* @param transform - Turns a resolved chunk dictionary into final content.
-*/
-const resolveQualifiedDynamicContentAsync = async (params) => {
-	const { loaderMap, key, locale, selector, transform } = params;
-	const { itemAxisOpen, missed, chunks } = collectQualifiedChunks(loaderMap, key, locale, selector);
-	if (missed) return itemAxisOpen ? [] : null;
-	const dictionaries = await Promise.all(chunks.map(({ loader }) => loader()));
-	if (itemAxisOpen) return dictionaries.map(transform);
-	const [dictionary] = dictionaries;
-	return dictionary ? transform(dictionary) : null;
-};
 
 //#endregion
 exports.COMPOSITE_ID_SEPARATOR = COMPOSITE_ID_SEPARATOR;
 exports.DEFAULT_VARIANT_ID = DEFAULT_VARIANT_ID;
-exports.QUALIFIER_DYNAMIC_TYPES_KEY = QUALIFIER_DYNAMIC_TYPES_KEY;
-exports.QUALIFIER_ORDER = QUALIFIER_ORDER;
-exports.getDictionaryCompositeIds = getDictionaryCompositeIds;
-exports.getDictionaryQualifierIds = getDictionaryQualifierIds;
-exports.getDictionaryQualifierTypes = getDictionaryQualifierTypes;
 exports.getDictionarySelectorCacheKey = getDictionarySelectorCacheKey;
-exports.getVariantIds = getVariantIds;
 exports.isQualifiedDictionaryGroup = isQualifiedDictionaryGroup;
-exports.isQualifiedDynamicLoaderMap = isQualifiedDynamicLoaderMap;
 exports.parseDictionarySelector = parseDictionarySelector;
 exports.reconstructQualifiedEntry = reconstructQualifiedEntry;
 exports.resolveDictionaryArgument = resolveDictionaryArgument;
+exports.resolveEffectiveVariantId = resolveEffectiveVariantId;
 exports.resolveProviderVariant = resolveProviderVariant;
 exports.resolveQualifiedDictionary = resolveQualifiedDictionary;
-exports.resolveQualifiedDynamicContent = resolveQualifiedDynamicContent;
-exports.resolveQualifiedDynamicContentAsync = resolveQualifiedDynamicContentAsync;
 exports.serializeVariant = serializeVariant;
 exports.serializeVariantChain = serializeVariantChain;
 //# sourceMappingURL=qualifiedDictionary.cjs.map