@intlayer/core 5.0.6 → 5.1.0

package/dist/cjs/dictionaryManipulator/editDictionaryByKeyPath.cjs

@@ -26,65 +26,70 @@ const editDictionaryByKeyPath = (dictionaryContent, keyPath, newValue) => {
   let currentValue = dictionaryContent;
   let parentValue = null;
   let lastKeys = [];
-  for (const keyObj of keyPath) {
+  for (let i = 0; i < keyPath.length; i++) {
+    const keyObj = keyPath[i];
     parentValue = currentValue;
     if (keyObj.type === import_types.NodeType.Object) {
       lastKeys = [keyObj.key];
-      if (!currentValue[keyObj.key]) {
-        currentValue = {
-          ...currentValue,
-          [keyObj.key]: {}
-        };
+      if (!currentValue[keyObj.key] || typeof currentValue[keyObj.key] !== "object") {
+        currentValue[keyObj.key] = {};
       }
       currentValue = currentValue[keyObj.key];
     } else if (keyObj.type === import_types.NodeType.Array) {
       lastKeys = [keyObj.key];
-      if (!currentValue[keyObj.key]) {
+      if (!currentValue[keyObj.key] || typeof currentValue[keyObj.key] !== "object") {
         currentValue[keyObj.key] = {};
       }
       currentValue = currentValue[keyObj.key];
     } else if (keyObj.type === import_types.NodeType.Translation) {
       lastKeys = [import_types.NodeType.Translation, keyObj.key];
-      if (!currentValue[import_types.NodeType.Translation]) {
-        currentValue[import_types.NodeType.Translation] = {
-          ...currentValue[import_types.NodeType.Translation],
-          [keyObj.key]: newValue
-        };
+      if (!currentValue[import_types.NodeType.Translation] || typeof currentValue[import_types.NodeType.Translation] !== "object") {
+        currentValue[import_types.NodeType.Translation] = {};
+      }
+      if (!currentValue[import_types.NodeType.Translation][keyObj.key] || typeof currentValue[import_types.NodeType.Translation][keyObj.key] !== "object") {
+        currentValue[import_types.NodeType.Translation][keyObj.key] = {};
       }
       currentValue = currentValue[import_types.NodeType.Translation][keyObj.key];
     } else if (keyObj.type === import_types.NodeType.Enumeration) {
       lastKeys = [import_types.NodeType.Enumeration, keyObj.key];
-      if (!currentValue[import_types.NodeType.Enumeration]) {
-        currentValue[import_types.NodeType.Enumeration] = {
-          ...currentValue[import_types.NodeType.Enumeration],
-          [keyObj.key]: newValue
-        };
+      if (!currentValue[import_types.NodeType.Enumeration] || typeof currentValue[import_types.NodeType.Enumeration] !== "object") {
+        currentValue[import_types.NodeType.Enumeration] = {};
+      }
+      if (!currentValue[import_types.NodeType.Enumeration][keyObj.key] || typeof currentValue[import_types.NodeType.Enumeration][keyObj.key] !== "object") {
+        currentValue[import_types.NodeType.Enumeration][keyObj.key] = {};
       }
       currentValue = currentValue[import_types.NodeType.Enumeration][keyObj.key];
+    } else if (keyObj.type === import_types.NodeType.Condition) {
+      lastKeys = [import_types.NodeType.Condition, keyObj.key];
+      if (!currentValue[import_types.NodeType.Condition] || typeof currentValue[import_types.NodeType.Condition] !== "object") {
+        currentValue[import_types.NodeType.Condition] = {};
+      }
+      if (!currentValue[import_types.NodeType.Condition][keyObj.key] || typeof currentValue[import_types.NodeType.Condition][keyObj.key] !== "object") {
+        currentValue[import_types.NodeType.Condition][keyObj.key] = {};
+      }
+      currentValue = currentValue[import_types.NodeType.Condition][keyObj.key];
     } else if (keyObj.type === import_types.NodeType.Markdown) {
       lastKeys = [import_types.NodeType.Markdown];
-      if (!currentValue[import_types.NodeType.Markdown]) {
-        currentValue[import_types.NodeType.Markdown] = newValue;
+      if (!currentValue[import_types.NodeType.Markdown] || typeof currentValue[import_types.NodeType.Markdown] !== "object") {
+        currentValue[import_types.NodeType.Markdown] = "";
       }
       currentValue = currentValue[import_types.NodeType.Markdown];
     } else if (keyObj.type === import_types.NodeType.Nested) {
       lastKeys = [import_types.NodeType.Nested];
-      if (!currentValue[import_types.NodeType.Nested]) {
-        currentValue[import_types.NodeType.Nested] = newValue;
+      if (!currentValue[import_types.NodeType.Nested] || typeof currentValue[import_types.NodeType.Nested] !== "object") {
+        currentValue[import_types.NodeType.Nested] = {};
       }
       currentValue = currentValue[import_types.NodeType.Nested];
     }
-    if (parentValue && lastKeys.length > 0) {
+    if (i === keyPath.length - 1 && parentValue && lastKeys.length > 0) {
+      let target = parentValue;
       for (const key of lastKeys.slice(0, -1)) {
-        parentValue = parentValue[key];
+        target = target[key];
       }
-      if (
-        // Remove the field if the new value is undefined
-        typeof newValue === "undefined"
-      ) {
-        delete parentValue[lastKeys[lastKeys.length - 1]];
+      if (typeof newValue === "undefined") {
+        delete target[lastKeys[lastKeys.length - 1]];
       } else {
-        parentValue[lastKeys[lastKeys.length - 1]] = newValue;
+        target[lastKeys[lastKeys.length - 1]] = newValue;
       }
     }
   }

package/dist/cjs/dictionaryManipulator/editDictionaryByKeyPath.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/dictionaryManipulator/editDictionaryByKeyPath.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { type KeyPath, NodeType } from '../types';\nimport type { ContentNode } from '../types/dictionary';\n\ntype LastKeyType = string | number;\n\nexport const editDictionaryByKeyPath = (\n  dictionaryContent: ContentNode,\n  keyPath: KeyPath[],\n  newValue: ContentNode\n): ContentNode => {\n  let currentValue: any = dictionaryContent;\n  let parentValue: any = null;\n  let lastKeys: LastKeyType[] = [];\n\n  for (const keyObj of keyPath) {\n    parentValue = currentValue;\n\n    if (keyObj.type === NodeType.Object) {\n      lastKeys = [keyObj.key];\n\n      if (!currentValue[keyObj.key]) {\n        currentValue = {\n          ...currentValue,\n          [keyObj.key]: {},\n        };\n      }\n      currentValue = currentValue[keyObj.key];\n    } else if (keyObj.type === NodeType.Array) {\n      lastKeys = [keyObj.key];\n\n      if (!currentValue[keyObj.key]) {\n        currentValue[keyObj.key] = {};\n      }\n      currentValue = currentValue[keyObj.key];\n    } else if (keyObj.type === NodeType.Translation) {\n      lastKeys = [NodeType.Translation, keyObj.key];\n\n      if (!currentValue[NodeType.Translation]) {\n        currentValue[NodeType.Translation] = {\n          ...currentValue[NodeType.Translation],\n          [keyObj.key]: newValue,\n        };\n      }\n      currentValue = currentValue[NodeType.Translation][keyObj.key];\n    } else if (keyObj.type === NodeType.Enumeration) {\n      lastKeys = [NodeType.Enumeration, keyObj.key];\n\n      if (!currentValue[NodeType.Enumeration]) {\n        currentValue[NodeType.Enumeration] = {\n          ...currentValue[NodeType.Enumeration],\n          [keyObj.key]: newValue,\n        };\n      }\n      currentValue = currentValue[NodeType.Enumeration][keyObj.key];\n    } else if (keyObj.type === NodeType.Markdown) {\n      lastKeys = [NodeType.Markdown];\n      if (!currentValue[NodeType.Markdown]) {\n        currentValue[NodeType.Markdown] = newValue;\n      }\n      currentValue = currentValue[NodeType.Markdown];\n    } else if (keyObj.type === NodeType.Nested) {\n      lastKeys = [NodeType.Nested];\n      if (!currentValue[NodeType.Nested]) {\n        currentValue[NodeType.Nested] = newValue;\n      }\n      currentValue = currentValue[NodeType.Nested];\n    }\n\n    // Assign the new value to the last key of the parent\n    if (parentValue && lastKeys.length > 0) {\n      for (const key of lastKeys.slice(0, -1)) {\n        parentValue = parentValue[key];\n      }\n      if (\n        // Remove the field if the new value is undefined\n        typeof newValue === 'undefined'\n      ) {\n        delete parentValue[lastKeys[lastKeys.length - 1]];\n      } else {\n        parentValue[lastKeys[lastKeys.length - 1]] = newValue;\n      }\n    }\n  }\n  return dictionaryContent;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,mBAAuC;AAKhC,MAAM,0BAA0B,CACrC,mBACA,SACA,aACgB;AAChB,MAAI,eAAoB;AACxB,MAAI,cAAmB;AACvB,MAAI,WAA0B,CAAC;AAE/B,aAAW,UAAU,SAAS;AAC5B,kBAAc;AAEd,QAAI,OAAO,SAAS,sBAAS,QAAQ;AACnC,iBAAW,CAAC,OAAO,GAAG;AAEtB,UAAI,CAAC,aAAa,OAAO,GAAG,GAAG;AAC7B,uBAAe;AAAA,UACb,GAAG;AAAA,UACH,CAAC,OAAO,GAAG,GAAG,CAAC;AAAA,QACjB;AAAA,MACF;AACA,qBAAe,aAAa,OAAO,GAAG;AAAA,IACxC,WAAW,OAAO,SAAS,sBAAS,OAAO;AACzC,iBAAW,CAAC,OAAO,GAAG;AAEtB,UAAI,CAAC,aAAa,OAAO,GAAG,GAAG;AAC7B,qBAAa,OAAO,GAAG,IAAI,CAAC;AAAA,MAC9B;AACA,qBAAe,aAAa,OAAO,GAAG;AAAA,IACxC,WAAW,OAAO,SAAS,sBAAS,aAAa;AAC/C,iBAAW,CAAC,sBAAS,aAAa,OAAO,GAAG;AAE5C,UAAI,CAAC,aAAa,sBAAS,WAAW,GAAG;AACvC,qBAAa,sBAAS,WAAW,IAAI;AAAA,UACnC,GAAG,aAAa,sBAAS,WAAW;AAAA,UACpC,CAAC,OAAO,GAAG,GAAG;AAAA,QAChB;AAAA,MACF;AACA,qBAAe,aAAa,sBAAS,WAAW,EAAE,OAAO,GAAG;AAAA,IAC9D,WAAW,OAAO,SAAS,sBAAS,aAAa;AAC/C,iBAAW,CAAC,sBAAS,aAAa,OAAO,GAAG;AAE5C,UAAI,CAAC,aAAa,sBAAS,WAAW,GAAG;AACvC,qBAAa,sBAAS,WAAW,IAAI;AAAA,UACnC,GAAG,aAAa,sBAAS,WAAW;AAAA,UACpC,CAAC,OAAO,GAAG,GAAG;AAAA,QAChB;AAAA,MACF;AACA,qBAAe,aAAa,sBAAS,WAAW,EAAE,OAAO,GAAG;AAAA,IAC9D,WAAW,OAAO,SAAS,sBAAS,UAAU;AAC5C,iBAAW,CAAC,sBAAS,QAAQ;AAC7B,UAAI,CAAC,aAAa,sBAAS,QAAQ,GAAG;AACpC,qBAAa,sBAAS,QAAQ,IAAI;AAAA,MACpC;AACA,qBAAe,aAAa,sBAAS,QAAQ;AAAA,IAC/C,WAAW,OAAO,SAAS,sBAAS,QAAQ;AAC1C,iBAAW,CAAC,sBAAS,MAAM;AAC3B,UAAI,CAAC,aAAa,sBAAS,MAAM,GAAG;AAClC,qBAAa,sBAAS,MAAM,IAAI;AAAA,MAClC;AACA,qBAAe,aAAa,sBAAS,MAAM;AAAA,IAC7C;AAGA,QAAI,eAAe,SAAS,SAAS,GAAG;AACtC,iBAAW,OAAO,SAAS,MAAM,GAAG,EAAE,GAAG;AACvC,sBAAc,YAAY,GAAG;AAAA,MAC/B;AACA;AAAA;AAAA,QAEE,OAAO,aAAa;AAAA,QACpB;AACA,eAAO,YAAY,SAAS,SAAS,SAAS,CAAC,CAAC;AAAA,MAClD,OAAO;AACL,oBAAY,SAAS,SAAS,SAAS,CAAC,CAAC,IAAI;AAAA,MAC/C;AAAA,IACF;AAAA,EACF;AACA,SAAO;AACT;","names":[]}
+{"version":3,"sources":["../../../src/dictionaryManipulator/editDictionaryByKeyPath.ts"],"sourcesContent":["import { type KeyPath, NodeType } from '../types';\nimport type { ContentNode } from '../types/dictionary';\n\ntype LastKeyType = string | number;\n\nexport const editDictionaryByKeyPath = (\n  dictionaryContent: ContentNode,\n  keyPath: KeyPath[],\n  newValue: ContentNode\n): ContentNode => {\n  let currentValue: any = dictionaryContent;\n  let parentValue: any = null;\n  let lastKeys: LastKeyType[] = [];\n\n  for (let i = 0; i < keyPath.length; i++) {\n    const keyObj = keyPath[i];\n    parentValue = currentValue;\n\n    if (keyObj.type === NodeType.Object) {\n      lastKeys = [keyObj.key];\n      if (\n        !currentValue[keyObj.key] ||\n        typeof currentValue[keyObj.key] !== 'object'\n      ) {\n        currentValue[keyObj.key] = {};\n      }\n      currentValue = currentValue[keyObj.key];\n    } else if (keyObj.type === NodeType.Array) {\n      lastKeys = [keyObj.key];\n      if (\n        !currentValue[keyObj.key] ||\n        typeof currentValue[keyObj.key] !== 'object'\n      ) {\n        currentValue[keyObj.key] = {};\n      }\n      currentValue = currentValue[keyObj.key];\n    } else if (keyObj.type === NodeType.Translation) {\n      lastKeys = [NodeType.Translation, keyObj.key];\n      if (\n        !currentValue[NodeType.Translation] ||\n        typeof currentValue[NodeType.Translation] !== 'object'\n      ) {\n        currentValue[NodeType.Translation] = {};\n      }\n      if (\n        !currentValue[NodeType.Translation][keyObj.key] ||\n        typeof currentValue[NodeType.Translation][keyObj.key] !== 'object'\n      ) {\n        currentValue[NodeType.Translation][keyObj.key] = {};\n      }\n      currentValue = currentValue[NodeType.Translation][keyObj.key];\n    } else if (keyObj.type === NodeType.Enumeration) {\n      lastKeys = [NodeType.Enumeration, keyObj.key];\n      if (\n        !currentValue[NodeType.Enumeration] ||\n        typeof currentValue[NodeType.Enumeration] !== 'object'\n      ) {\n        currentValue[NodeType.Enumeration] = {};\n      }\n      if (\n        !currentValue[NodeType.Enumeration][keyObj.key] ||\n        typeof currentValue[NodeType.Enumeration][keyObj.key] !== 'object'\n      ) {\n        currentValue[NodeType.Enumeration][keyObj.key] = {};\n      }\n      currentValue = currentValue[NodeType.Enumeration][keyObj.key];\n    } else if (keyObj.type === NodeType.Condition) {\n      lastKeys = [NodeType.Condition, keyObj.key];\n      if (\n        !currentValue[NodeType.Condition] ||\n        typeof currentValue[NodeType.Condition] !== 'object'\n      ) {\n        currentValue[NodeType.Condition] = {};\n      }\n      if (\n        !currentValue[NodeType.Condition][keyObj.key] ||\n        typeof currentValue[NodeType.Condition][keyObj.key] !== 'object'\n      ) {\n        currentValue[NodeType.Condition][keyObj.key] = {};\n      }\n      currentValue = currentValue[NodeType.Condition][keyObj.key];\n    } else if (keyObj.type === NodeType.Markdown) {\n      lastKeys = [NodeType.Markdown];\n      if (\n        !currentValue[NodeType.Markdown] ||\n        typeof currentValue[NodeType.Markdown] !== 'object'\n      ) {\n        currentValue[NodeType.Markdown] = '';\n      }\n      currentValue = currentValue[NodeType.Markdown];\n    } else if (keyObj.type === NodeType.Nested) {\n      lastKeys = [NodeType.Nested];\n      if (\n        !currentValue[NodeType.Nested] ||\n        typeof currentValue[NodeType.Nested] !== 'object'\n      ) {\n        currentValue[NodeType.Nested] = {};\n      }\n      currentValue = currentValue[NodeType.Nested];\n    }\n\n    // Only update the value when processing the last key in the keyPath.\n    if (i === keyPath.length - 1 && parentValue && lastKeys.length > 0) {\n      let target = parentValue;\n      // Drill down if lastKeys contains more than one key.\n      for (const key of lastKeys.slice(0, -1)) {\n        target = target[key];\n      }\n      if (typeof newValue === 'undefined') {\n        delete target[lastKeys[lastKeys.length - 1]];\n      } else {\n        target[lastKeys[lastKeys.length - 1]] = newValue;\n      }\n    }\n  }\n  return dictionaryContent;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAuC;AAKhC,MAAM,0BAA0B,CACrC,mBACA,SACA,aACgB;AAChB,MAAI,eAAoB;AACxB,MAAI,cAAmB;AACvB,MAAI,WAA0B,CAAC;AAE/B,WAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;AACvC,UAAM,SAAS,QAAQ,CAAC;AACxB,kBAAc;AAEd,QAAI,OAAO,SAAS,sBAAS,QAAQ;AACnC,iBAAW,CAAC,OAAO,GAAG;AACtB,UACE,CAAC,aAAa,OAAO,GAAG,KACxB,OAAO,aAAa,OAAO,GAAG,MAAM,UACpC;AACA,qBAAa,OAAO,GAAG,IAAI,CAAC;AAAA,MAC9B;AACA,qBAAe,aAAa,OAAO,GAAG;AAAA,IACxC,WAAW,OAAO,SAAS,sBAAS,OAAO;AACzC,iBAAW,CAAC,OAAO,GAAG;AACtB,UACE,CAAC,aAAa,OAAO,GAAG,KACxB,OAAO,aAAa,OAAO,GAAG,MAAM,UACpC;AACA,qBAAa,OAAO,GAAG,IAAI,CAAC;AAAA,MAC9B;AACA,qBAAe,aAAa,OAAO,GAAG;AAAA,IACxC,WAAW,OAAO,SAAS,sBAAS,aAAa;AAC/C,iBAAW,CAAC,sBAAS,aAAa,OAAO,GAAG;AAC5C,UACE,CAAC,aAAa,sBAAS,WAAW,KAClC,OAAO,aAAa,sBAAS,WAAW,MAAM,UAC9C;AACA,qBAAa,sBAAS,WAAW,IAAI,CAAC;AAAA,MACxC;AACA,UACE,CAAC,aAAa,sBAAS,WAAW,EAAE,OAAO,GAAG,KAC9C,OAAO,aAAa,sBAAS,WAAW,EAAE,OAAO,GAAG,MAAM,UAC1D;AACA,qBAAa,sBAAS,WAAW,EAAE,OAAO,GAAG,IAAI,CAAC;AAAA,MACpD;AACA,qBAAe,aAAa,sBAAS,WAAW,EAAE,OAAO,GAAG;AAAA,IAC9D,WAAW,OAAO,SAAS,sBAAS,aAAa;AAC/C,iBAAW,CAAC,sBAAS,aAAa,OAAO,GAAG;AAC5C,UACE,CAAC,aAAa,sBAAS,WAAW,KAClC,OAAO,aAAa,sBAAS,WAAW,MAAM,UAC9C;AACA,qBAAa,sBAAS,WAAW,IAAI,CAAC;AAAA,MACxC;AACA,UACE,CAAC,aAAa,sBAAS,WAAW,EAAE,OAAO,GAAG,KAC9C,OAAO,aAAa,sBAAS,WAAW,EAAE,OAAO,GAAG,MAAM,UAC1D;AACA,qBAAa,sBAAS,WAAW,EAAE,OAAO,GAAG,IAAI,CAAC;AAAA,MACpD;AACA,qBAAe,aAAa,sBAAS,WAAW,EAAE,OAAO,GAAG;AAAA,IAC9D,WAAW,OAAO,SAAS,sBAAS,WAAW;AAC7C,iBAAW,CAAC,sBAAS,WAAW,OAAO,GAAG;AAC1C,UACE,CAAC,aAAa,sBAAS,SAAS,KAChC,OAAO,aAAa,sBAAS,SAAS,MAAM,UAC5C;AACA,qBAAa,sBAAS,SAAS,IAAI,CAAC;AAAA,MACtC;AACA,UACE,CAAC,aAAa,sBAAS,SAAS,EAAE,OAAO,GAAG,KAC5C,OAAO,aAAa,sBAAS,SAAS,EAAE,OAAO,GAAG,MAAM,UACxD;AACA,qBAAa,sBAAS,SAAS,EAAE,OAAO,GAAG,IAAI,CAAC;AAAA,MAClD;AACA,qBAAe,aAAa,sBAAS,SAAS,EAAE,OAAO,GAAG;AAAA,IAC5D,WAAW,OAAO,SAAS,sBAAS,UAAU;AAC5C,iBAAW,CAAC,sBAAS,QAAQ;AAC7B,UACE,CAAC,aAAa,sBAAS,QAAQ,KAC/B,OAAO,aAAa,sBAAS,QAAQ,MAAM,UAC3C;AACA,qBAAa,sBAAS,QAAQ,IAAI;AAAA,MACpC;AACA,qBAAe,aAAa,sBAAS,QAAQ;AAAA,IAC/C,WAAW,OAAO,SAAS,sBAAS,QAAQ;AAC1C,iBAAW,CAAC,sBAAS,MAAM;AAC3B,UACE,CAAC,aAAa,sBAAS,MAAM,KAC7B,OAAO,aAAa,sBAAS,MAAM,MAAM,UACzC;AACA,qBAAa,sBAAS,MAAM,IAAI,CAAC;AAAA,MACnC;AACA,qBAAe,aAAa,sBAAS,MAAM;AAAA,IAC7C;AAGA,QAAI,MAAM,QAAQ,SAAS,KAAK,eAAe,SAAS,SAAS,GAAG;AAClE,UAAI,SAAS;AAEb,iBAAW,OAAO,SAAS,MAAM,GAAG,EAAE,GAAG;AACvC,iBAAS,OAAO,GAAG;AAAA,MACrB;AACA,UAAI,OAAO,aAAa,aAAa;AACnC,eAAO,OAAO,SAAS,SAAS,SAAS,CAAC,CAAC;AAAA,MAC7C,OAAO;AACL,eAAO,SAAS,SAAS,SAAS,CAAC,CAAC,IAAI;AAAA,MAC1C;AAAA,IACF;AAAA,EACF;AACA,SAAO;AACT;","names":[]}

package/dist/cjs/dictionaryManipulator/getContentNodeByKeyPath.cjs

@@ -23,7 +23,7 @@ __export(getContentNodeByKeyPath_exports, {
 module.exports = __toCommonJS(getContentNodeByKeyPath_exports);
 var import_types = require('../types/index.cjs');
 const getContentNodeByKeyPath = (dictionaryContent, keyPath) => {
-  let currentValue = JSON.parse(JSON.stringify(dictionaryContent ?? {}));
+  let currentValue = structuredClone(dictionaryContent ?? {});
   for (const keyObj of keyPath) {
     if (keyObj.type === import_types.NodeType.Object || keyObj.type === import_types.NodeType.Array) {
       currentValue = currentValue?.[keyObj.key];

package/dist/cjs/dictionaryManipulator/getContentNodeByKeyPath.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/dictionaryManipulator/getContentNodeByKeyPath.ts"],"sourcesContent":["import { type KeyPath, NodeType } from '../types';\nimport type { ContentNode } from '../types/dictionary';\n\nexport const getContentNodeByKeyPath = (\n  dictionaryContent: ContentNode,\n  keyPath: KeyPath[]\n): ContentNode => {\n  let currentValue: any = JSON.parse(JSON.stringify(dictionaryContent ?? {}));\n\n  for (const keyObj of keyPath) {\n    if (keyObj.type === NodeType.Object || keyObj.type === NodeType.Array) {\n      currentValue = currentValue?.[keyObj.key];\n    } else if (keyObj.type === NodeType.Translation) {\n      currentValue = currentValue?.[NodeType.Translation][keyObj.key];\n    } else if (keyObj.type === NodeType.Enumeration) {\n      currentValue = currentValue?.[NodeType.Enumeration][keyObj.key];\n    } else if (keyObj.type === NodeType.Condition) {\n      currentValue = currentValue[NodeType.Condition];\n    } else if (keyObj.type === NodeType.Markdown) {\n      currentValue = currentValue[NodeType.Markdown];\n    }\n  }\n\n  return currentValue as ContentNode;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAuC;AAGhC,MAAM,0BAA0B,CACrC,mBACA,YACgB;AAChB,MAAI,eAAoB,KAAK,MAAM,KAAK,UAAU,qBAAqB,CAAC,CAAC,CAAC;AAE1E,aAAW,UAAU,SAAS;AAC5B,QAAI,OAAO,SAAS,sBAAS,UAAU,OAAO,SAAS,sBAAS,OAAO;AACrE,qBAAe,eAAe,OAAO,GAAG;AAAA,IAC1C,WAAW,OAAO,SAAS,sBAAS,aAAa;AAC/C,qBAAe,eAAe,sBAAS,WAAW,EAAE,OAAO,GAAG;AAAA,IAChE,WAAW,OAAO,SAAS,sBAAS,aAAa;AAC/C,qBAAe,eAAe,sBAAS,WAAW,EAAE,OAAO,GAAG;AAAA,IAChE,WAAW,OAAO,SAAS,sBAAS,WAAW;AAC7C,qBAAe,aAAa,sBAAS,SAAS;AAAA,IAChD,WAAW,OAAO,SAAS,sBAAS,UAAU;AAC5C,qBAAe,aAAa,sBAAS,QAAQ;AAAA,IAC/C;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}
+{"version":3,"sources":["../../../src/dictionaryManipulator/getContentNodeByKeyPath.ts"],"sourcesContent":["import { type KeyPath, NodeType } from '../types';\nimport type { ContentNode } from '../types/dictionary';\n\nexport const getContentNodeByKeyPath = (\n  dictionaryContent: ContentNode,\n  keyPath: KeyPath[]\n): ContentNode => {\n  let currentValue: any = structuredClone(dictionaryContent ?? {});\n\n  for (const keyObj of keyPath) {\n    if (keyObj.type === NodeType.Object || keyObj.type === NodeType.Array) {\n      currentValue = currentValue?.[keyObj.key];\n    } else if (keyObj.type === NodeType.Translation) {\n      currentValue = currentValue?.[NodeType.Translation][keyObj.key];\n    } else if (keyObj.type === NodeType.Enumeration) {\n      currentValue = currentValue?.[NodeType.Enumeration][keyObj.key];\n    } else if (keyObj.type === NodeType.Condition) {\n      currentValue = currentValue[NodeType.Condition];\n    } else if (keyObj.type === NodeType.Markdown) {\n      currentValue = currentValue[NodeType.Markdown];\n    }\n  }\n\n  return currentValue as ContentNode;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAuC;AAGhC,MAAM,0BAA0B,CACrC,mBACA,YACgB;AAChB,MAAI,eAAoB,gBAAgB,qBAAqB,CAAC,CAAC;AAE/D,aAAW,UAAU,SAAS;AAC5B,QAAI,OAAO,SAAS,sBAAS,UAAU,OAAO,SAAS,sBAAS,OAAO;AACrE,qBAAe,eAAe,OAAO,GAAG;AAAA,IAC1C,WAAW,OAAO,SAAS,sBAAS,aAAa;AAC/C,qBAAe,eAAe,sBAAS,WAAW,EAAE,OAAO,GAAG;AAAA,IAChE,WAAW,OAAO,SAAS,sBAAS,aAAa;AAC/C,qBAAe,eAAe,sBAAS,WAAW,EAAE,OAAO,GAAG;AAAA,IAChE,WAAW,OAAO,SAAS,sBAAS,WAAW;AAC7C,qBAAe,aAAa,sBAAS,SAAS;AAAA,IAChD,WAAW,OAAO,SAAS,sBAAS,UAAU;AAC5C,qBAAe,aAAa,sBAAS,QAAQ;AAAA,IAC/C;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/cjs/dictionaryManipulator/getDefaultNode.cjs

@@ -0,0 +1,84 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getDefaultNode_exports = {};
+__export(getDefaultNode_exports, {
+  getDefaultNode: () => getDefaultNode
+});
+module.exports = __toCommonJS(getDefaultNode_exports);
+var import_types = require('../types/index.cjs');
+const getDefaultNode = (nodeType, locales, content) => {
+  switch (nodeType) {
+    case import_types.NodeType.Translation:
+      return {
+        nodeType: import_types.NodeType.Translation,
+        [import_types.NodeType.Translation]: Object.assign(
+          {},
+          ...locales.map((locale) => ({
+            [locale]: content ?? ""
+          }))
+        )
+      };
+    case import_types.NodeType.Enumeration:
+      return {
+        nodeType: import_types.NodeType.Enumeration,
+        [import_types.NodeType.Enumeration]: {
+          "1": content ?? ""
+        }
+      };
+    case import_types.NodeType.Condition:
+      return {
+        nodeType: import_types.NodeType.Condition,
+        [import_types.NodeType.Condition]: {
+          true: content ?? "",
+          false: content ?? ""
+        }
+      };
+    case import_types.NodeType.Nested:
+      return {
+        nodeType: import_types.NodeType.Nested,
+        [import_types.NodeType.Nested]: {
+          dictionaryKey: ""
+        }
+      };
+    case import_types.NodeType.Markdown:
+      return {
+        nodeType: import_types.NodeType.Markdown,
+        [import_types.NodeType.Markdown]: content ?? ""
+      };
+    case import_types.NodeType.Object:
+      return {
+        newKey: content ?? ""
+      };
+    case import_types.NodeType.Array:
+      return [content ?? ""];
+    case import_types.NodeType.Text:
+      return content ?? "";
+    case import_types.NodeType.Number:
+      return content ?? 0;
+    case import_types.NodeType.Boolean:
+      return content ?? true;
+    default:
+      return content ?? "";
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getDefaultNode
+});
+//# sourceMappingURL=getDefaultNode.cjs.map

package/dist/cjs/dictionaryManipulator/getDefaultNode.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/dictionaryManipulator/getDefaultNode.ts"],"sourcesContent":["import type { LocalesValues } from '@intlayer/config/client';\nimport type {\n  TranslationContent,\n  EnumerationContent,\n  ConditionContent,\n  NestedContent,\n  MarkdownContent,\n} from '../transpiler';\nimport { type ContentNode, NodeType } from '../types';\n\nexport const getDefaultNode = (\n  nodeType: NodeType,\n  locales: LocalesValues[],\n  content?: ContentNode\n) => {\n  switch (nodeType) {\n    case NodeType.Translation:\n      return {\n        nodeType: NodeType.Translation,\n        [NodeType.Translation]: Object.assign(\n          {},\n          ...locales.map((locale) => ({\n            [locale]: content ?? '',\n          }))\n        ),\n      } as TranslationContent<ContentNode>;\n\n    case NodeType.Enumeration:\n      return {\n        nodeType: NodeType.Enumeration,\n        [NodeType.Enumeration]: {\n          '1': content ?? '',\n        },\n      } as EnumerationContent<ContentNode>;\n\n    case NodeType.Condition:\n      return {\n        nodeType: NodeType.Condition,\n        [NodeType.Condition]: {\n          true: content ?? '',\n          false: content ?? '',\n        },\n      } as ConditionContent<ContentNode>;\n\n    case NodeType.Nested:\n      return {\n        nodeType: NodeType.Nested,\n        [NodeType.Nested]: {\n          dictionaryKey: '',\n        },\n      } as NestedContent;\n\n    case NodeType.Markdown:\n      return {\n        nodeType: NodeType.Markdown,\n        [NodeType.Markdown]: content ?? '',\n      } as MarkdownContent;\n\n    case NodeType.Object:\n      return {\n        newKey: content ?? '',\n      } as Record<string, ContentNode>;\n\n    case NodeType.Array:\n      return [content ?? ''] as Record<number, ContentNode>;\n\n    case NodeType.Text:\n      return content ?? '';\n\n    case NodeType.Number:\n      return content ?? 0;\n\n    case NodeType.Boolean:\n      return content ?? true;\n\n    default:\n      return content ?? '';\n  }\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,mBAA2C;AAEpC,MAAM,iBAAiB,CAC5B,UACA,SACA,YACG;AACH,UAAQ,UAAU;AAAA,IAChB,KAAK,sBAAS;AACZ,aAAO;AAAA,QACL,UAAU,sBAAS;AAAA,QACnB,CAAC,sBAAS,WAAW,GAAG,OAAO;AAAA,UAC7B,CAAC;AAAA,UACD,GAAG,QAAQ,IAAI,CAAC,YAAY;AAAA,YAC1B,CAAC,MAAM,GAAG,WAAW;AAAA,UACvB,EAAE;AAAA,QACJ;AAAA,MACF;AAAA,IAEF,KAAK,sBAAS;AACZ,aAAO;AAAA,QACL,UAAU,sBAAS;AAAA,QACnB,CAAC,sBAAS,WAAW,GAAG;AAAA,UACtB,KAAK,WAAW;AAAA,QAClB;AAAA,MACF;AAAA,IAEF,KAAK,sBAAS;AACZ,aAAO;AAAA,QACL,UAAU,sBAAS;AAAA,QACnB,CAAC,sBAAS,SAAS,GAAG;AAAA,UACpB,MAAM,WAAW;AAAA,UACjB,OAAO,WAAW;AAAA,QACpB;AAAA,MACF;AAAA,IAEF,KAAK,sBAAS;AACZ,aAAO;AAAA,QACL,UAAU,sBAAS;AAAA,QACnB,CAAC,sBAAS,MAAM,GAAG;AAAA,UACjB,eAAe;AAAA,QACjB;AAAA,MACF;AAAA,IAEF,KAAK,sBAAS;AACZ,aAAO;AAAA,QACL,UAAU,sBAAS;AAAA,QACnB,CAAC,sBAAS,QAAQ,GAAG,WAAW;AAAA,MAClC;AAAA,IAEF,KAAK,sBAAS;AACZ,aAAO;AAAA,QACL,QAAQ,WAAW;AAAA,MACrB;AAAA,IAEF,KAAK,sBAAS;AACZ,aAAO,CAAC,WAAW,EAAE;AAAA,IAEvB,KAAK,sBAAS;AACZ,aAAO,WAAW;AAAA,IAEpB,KAAK,sBAAS;AACZ,aAAO,WAAW;AAAA,IAEpB,KAAK,sBAAS;AACZ,aAAO,WAAW;AAAA,IAEpB;AACE,aAAO,WAAW;AAAA,EACtB;AACF;","names":[]}

package/dist/cjs/dictionaryManipulator/getNodeChildren.cjs

@@ -0,0 +1,59 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getNodeChildren_exports = {};
+__export(getNodeChildren_exports, {
+  getNodeChildren: () => getNodeChildren
+});
+module.exports = __toCommonJS(getNodeChildren_exports);
+var import_types = require('../types/index.cjs');
+const getNodeChildren = (section) => {
+  if (typeof section === "string") {
+    return section;
+  }
+  if (typeof section === "number") {
+    return section;
+  }
+  if (typeof section === "boolean") {
+    return section;
+  }
+  if (typeof section?.nodeType === "string") {
+    const typedNode = section;
+    const content = typedNode[typedNode.nodeType];
+    if (typedNode.nodeType === import_types.NodeType.Translation || typedNode.nodeType === import_types.NodeType.Enumeration || typedNode.nodeType === import_types.NodeType.Condition) {
+      const firstKey = Object.keys(content)[0];
+      return content[firstKey];
+    }
+    if (typedNode.nodeType === import_types.NodeType.Nested) {
+      return void 0;
+    }
+    return content;
+  }
+  if (!section || typeof section !== "object") {
+    return section;
+  }
+  if (Array.isArray(section)) {
+    return section[0];
+  }
+  return section;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getNodeChildren
+});
+//# sourceMappingURL=getNodeChildren.cjs.map

package/dist/cjs/dictionaryManipulator/getNodeChildren.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/dictionaryManipulator/getNodeChildren.ts"],"sourcesContent":["import { type ContentNode, type TypedNode, NodeType } from '../types';\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 = typedNode[typedNode.nodeType as keyof TypedNode];\n\n    if (\n      typedNode.nodeType === NodeType.Translation ||\n      typedNode.nodeType === NodeType.Enumeration ||\n      typedNode.nodeType === NodeType.Condition\n    ) {\n      const firstKey = Object.keys(content)[0] as keyof typeof content;\n      return content[firstKey] as ContentNode;\n    }\n\n    if (typedNode.nodeType === NodeType.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":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAA2D;AAEpD,MAAM,kBAAkB,CAAC,YAAsC;AACpE,MAAI,OAAO,YAAY,UAAU;AAC/B,WAAO;AAAA,EACT;AACA,MAAI,OAAO,YAAY,UAAU;AAC/B,WAAO;AAAA,EACT;AACA,MAAI,OAAO,YAAY,WAAW;AAChC,WAAO;AAAA,EACT;AACA,MAAI,OAAQ,SAAuB,aAAa,UAAU;AACxD,UAAM,YAAY;AAClB,UAAM,UAAU,UAAU,UAAU,QAA2B;AAE/D,QACE,UAAU,aAAa,sBAAS,eAChC,UAAU,aAAa,sBAAS,eAChC,UAAU,aAAa,sBAAS,WAChC;AACA,YAAM,WAAW,OAAO,KAAK,OAAO,EAAE,CAAC;AACvC,aAAO,QAAQ,QAAQ;AAAA,IACzB;AAEA,QAAI,UAAU,aAAa,sBAAS,QAAQ;AAC1C,aAAO;AAAA,IACT;AAEA,WAAO;AAAA,EACT;AAEA,MAAI,CAAC,WAAW,OAAO,YAAY,UAAU;AAC3C,WAAO;AAAA,EACT;AAEA,MAAI,MAAM,QAAQ,OAAO,GAAG;AAC1B,WAAQ,QAA0B,CAAC;AAAA,EACrC;AAEA,SAAO;AACT;","names":[]}

package/dist/cjs/dictionaryManipulator/{getSectionType.cjs → getNodeType.cjs}

@@ -16,42 +16,51 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var getSectionType_exports = {};
-__export(getSectionType_exports, {
-  getSectionType: () => getSectionType
+var getNodeType_exports = {};
+__export(getNodeType_exports, {
+  getNodeType: () => getNodeType
 });
-module.exports = __toCommonJS(getSectionType_exports);
+module.exports = __toCommonJS(getNodeType_exports);
 var import_types = require('../types/index.cjs');
 var import_isValidReactElement = require('../utils/isValidReactElement.cjs');
-const getSectionType = (section) => {
-  if (typeof section === "string") {
+const getNodeType = (content) => {
+  if (typeof content === "string") {
     return import_types.NodeType.Text;
   }
-  if (section?.nodeType === import_types.NodeType.Translation) {
+  if (content?.nodeType === import_types.NodeType.Translation) {
     return import_types.NodeType.Translation;
   }
-  if (section?.nodeType === import_types.NodeType.Enumeration) {
+  if (content?.nodeType === import_types.NodeType.Enumeration) {
     return import_types.NodeType.Enumeration;
   }
-  if (section?.nodeType === import_types.NodeType.Condition) {
+  if (content?.nodeType === import_types.NodeType.Condition) {
     return import_types.NodeType.Condition;
   }
-  if (section?.nodeType === import_types.NodeType.Markdown) {
+  if (content?.nodeType === import_types.NodeType.Markdown) {
     return import_types.NodeType.Markdown;
   }
-  if (section?.nodeType === import_types.NodeType.Nested) {
+  if (content?.nodeType === import_types.NodeType.Nested) {
     return import_types.NodeType.Nested;
   }
-  if (Array.isArray(section)) {
+  if (Array.isArray(content)) {
     return import_types.NodeType.Array;
   }
-  if ((0, import_isValidReactElement.isValidElement)(section)) {
+  if ((0, import_isValidReactElement.isValidElement)(content)) {
     return import_types.NodeType.ReactNode;
   }
-  return import_types.NodeType.Object;
+  if (typeof content === "number") {
+    return import_types.NodeType.Number;
+  }
+  if (typeof content === "boolean") {
+    return import_types.NodeType.Boolean;
+  }
+  if (content && typeof content === "object") {
+    return import_types.NodeType.Object;
+  }
+  return import_types.NodeType.Unknown;
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  getSectionType
+  getNodeType
 });
-//# sourceMappingURL=getSectionType.cjs.map
+//# sourceMappingURL=getNodeType.cjs.map

package/dist/cjs/dictionaryManipulator/getNodeType.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/dictionaryManipulator/getNodeType.ts"],"sourcesContent":["import type {\n  TranslationContent,\n  EnumerationContent,\n  ConditionContent,\n  MarkdownContent,\n  NestedContent,\n} from '../transpiler';\nimport { NodeType, type DictionaryKeys } from '../types';\nimport type { ContentNode } from '../types/dictionary';\nimport { isValidElement } from '../utils/isValidReactElement';\n\nexport const getNodeType = (content: ContentNode): NodeType => {\n  if (typeof content === 'string') {\n    return NodeType.Text;\n  }\n\n  if ((content as TranslationContent)?.nodeType === NodeType.Translation) {\n    return NodeType.Translation;\n  }\n\n  if ((content as EnumerationContent)?.nodeType === NodeType.Enumeration) {\n    return NodeType.Enumeration;\n  }\n\n  if ((content as ConditionContent)?.nodeType === NodeType.Condition) {\n    return NodeType.Condition;\n  }\n\n  if ((content as MarkdownContent)?.nodeType === NodeType.Markdown) {\n    return NodeType.Markdown;\n  }\n\n  if (\n    (content as NestedContent<DictionaryKeys>)?.nodeType === NodeType.Nested\n  ) {\n    return NodeType.Nested;\n  }\n\n  if (Array.isArray(content)) {\n    return NodeType.Array;\n  }\n\n  if (isValidElement(content)) {\n    return NodeType.ReactNode;\n  }\n\n  if (typeof content === 'number') {\n    return NodeType.Number;\n  }\n\n  if (typeof content === 'boolean') {\n    return NodeType.Boolean;\n  }\n\n  if (content && typeof content === 'object') {\n    return NodeType.Object;\n  }\n\n  return NodeType.Unknown;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,mBAA8C;AAE9C,iCAA+B;AAExB,MAAM,cAAc,CAAC,YAAmC;AAC7D,MAAI,OAAO,YAAY,UAAU;AAC/B,WAAO,sBAAS;AAAA,EAClB;AAEA,MAAK,SAAgC,aAAa,sBAAS,aAAa;AACtE,WAAO,sBAAS;AAAA,EAClB;AAEA,MAAK,SAAgC,aAAa,sBAAS,aAAa;AACtE,WAAO,sBAAS;AAAA,EAClB;AAEA,MAAK,SAA8B,aAAa,sBAAS,WAAW;AAClE,WAAO,sBAAS;AAAA,EAClB;AAEA,MAAK,SAA6B,aAAa,sBAAS,UAAU;AAChE,WAAO,sBAAS;AAAA,EAClB;AAEA,MACG,SAA2C,aAAa,sBAAS,QAClE;AACA,WAAO,sBAAS;AAAA,EAClB;AAEA,MAAI,MAAM,QAAQ,OAAO,GAAG;AAC1B,WAAO,sBAAS;AAAA,EAClB;AAEA,UAAI,2CAAe,OAAO,GAAG;AAC3B,WAAO,sBAAS;AAAA,EAClB;AAEA,MAAI,OAAO,YAAY,UAAU;AAC/B,WAAO,sBAAS;AAAA,EAClB;AAEA,MAAI,OAAO,YAAY,WAAW;AAChC,WAAO,sBAAS;AAAA,EAClB;AAEA,MAAI,WAAW,OAAO,YAAY,UAAU;AAC1C,WAAO,sBAAS;AAAA,EAClB;AAEA,SAAO,sBAAS;AAClB;","names":[]}

package/dist/cjs/dictionaryManipulator/index.cjs

@@ -17,15 +17,21 @@ var dictionaryManipulator_exports = {};
 module.exports = __toCommonJS(dictionaryManipulator_exports);
 __reExport(dictionaryManipulator_exports, require('./editDictionaryByKeyPath.cjs'), module.exports);
 __reExport(dictionaryManipulator_exports, require('./getContentNodeByKeyPath.cjs'), module.exports);
-__reExport(dictionaryManipulator_exports, require('./getSectionType.cjs'), module.exports);
+__reExport(dictionaryManipulator_exports, require('./getNodeChildren.cjs'), module.exports);
 __reExport(dictionaryManipulator_exports, require('./removeContentNodeByKeyPath.cjs'), module.exports);
 __reExport(dictionaryManipulator_exports, require('./renameContentNodeByKeyPath.cjs'), module.exports);
+__reExport(dictionaryManipulator_exports, require('./getNodeType.cjs'), module.exports);
+__reExport(dictionaryManipulator_exports, require('./updateNodeChildren.cjs'), module.exports);
+__reExport(dictionaryManipulator_exports, require('./getDefaultNode.cjs'), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ...require('./editDictionaryByKeyPath.cjs'),
   ...require('./getContentNodeByKeyPath.cjs'),
-  ...require('./getSectionType.cjs'),
+  ...require('./getNodeChildren.cjs'),
   ...require('./removeContentNodeByKeyPath.cjs'),
-  ...require('./renameContentNodeByKeyPath.cjs')
+  ...require('./renameContentNodeByKeyPath.cjs'),
+  ...require('./getNodeType.cjs'),
+  ...require('./updateNodeChildren.cjs'),
+  ...require('./getDefaultNode.cjs')
 });
 //# sourceMappingURL=index.cjs.map

package/dist/cjs/dictionaryManipulator/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/dictionaryManipulator/index.ts"],"sourcesContent":["export * from './editDictionaryByKeyPath';\nexport * from './getContentNodeByKeyPath';\nexport * from './getSectionType';\nexport * from './removeContentNodeByKeyPath';\nexport * from './renameContentNodeByKeyPath';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,0CAAc,sCAAd;AACA,0CAAc,sCADd;AAEA,0CAAc,6BAFd;AAGA,0CAAc,yCAHd;AAIA,0CAAc,yCAJd;","names":[]}
+{"version":3,"sources":["../../../src/dictionaryManipulator/index.ts"],"sourcesContent":["export * from './editDictionaryByKeyPath';\nexport * from './getContentNodeByKeyPath';\nexport * from './getNodeChildren';\nexport * from './removeContentNodeByKeyPath';\nexport * from './renameContentNodeByKeyPath';\nexport * from './getNodeType';\nexport * from './updateNodeChildren';\nexport * from './getDefaultNode';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,0CAAc,sCAAd;AACA,0CAAc,sCADd;AAEA,0CAAc,8BAFd;AAGA,0CAAc,yCAHd;AAIA,0CAAc,yCAJd;AAKA,0CAAc,0BALd;AAMA,0CAAc,iCANd;AAOA,0CAAc,6BAPd;","names":[]}

package/dist/cjs/dictionaryManipulator/updateNodeChildren.cjs

@@ -0,0 +1,79 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var updateNodeChildren_exports = {};
+__export(updateNodeChildren_exports, {
+  updateNodeChildren: () => updateNodeChildren
+});
+module.exports = __toCommonJS(updateNodeChildren_exports);
+var import_types = require('../types/index.cjs');
+const updateNodeChildren = (section, newChildren) => {
+  if (typeof section === "string") {
+    return newChildren;
+  }
+  if (typeof section === "number") {
+    return newChildren;
+  }
+  if (typeof section === "boolean") {
+    return newChildren;
+  }
+  if (typeof section?.nodeType === "string") {
+    const typedNode = section;
+    const content = typedNode[typedNode.nodeType];
+    if (typedNode.nodeType === import_types.NodeType.Translation || typedNode.nodeType === import_types.NodeType.Enumeration || typedNode.nodeType === import_types.NodeType.Condition) {
+      const newContent = Object.entries(content).reduce(
+        (acc, [key]) => ({
+          ...acc,
+          [key]: newChildren
+        }),
+        {}
+      );
+      return {
+        ...typedNode,
+        [typedNode.nodeType]: newContent
+      };
+    }
+    if (typedNode.nodeType === import_types.NodeType.Nested) {
+      return typedNode;
+    }
+    return {
+      ...typedNode,
+      [typedNode.nodeType]: newChildren
+    };
+  }
+  if (!section || typeof section !== "object") {
+    return newChildren;
+  }
+  if (Array.isArray(section)) {
+    return section.map(() => newChildren);
+  }
+  return Object.entries(
+    section
+  ).reduce(
+    (acc, [key]) => ({
+      ...acc,
+      [key]: newChildren
+    }),
+    {}
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  updateNodeChildren
+});
+//# sourceMappingURL=updateNodeChildren.cjs.map

package/dist/cjs/dictionaryManipulator/updateNodeChildren.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/dictionaryManipulator/updateNodeChildren.ts"],"sourcesContent":["import { type ContentNode, type TypedNode, NodeType } from '../types';\n\nexport const updateNodeChildren = <\n  T extends ContentNode,\n  U extends ContentNode,\n>(\n  section: T,\n  newChildren: U\n): ContentNode => {\n  if (typeof section === 'string') {\n    return newChildren;\n  }\n  if (typeof section === 'number') {\n    return newChildren;\n  }\n  if (typeof section === 'boolean') {\n    return newChildren;\n  }\n  if (typeof (section as TypedNode)?.nodeType === 'string') {\n    const typedNode = section as TypedNode;\n    const content = typedNode[typedNode.nodeType as keyof TypedNode];\n\n    if (\n      typedNode.nodeType === NodeType.Translation ||\n      typedNode.nodeType === NodeType.Enumeration ||\n      typedNode.nodeType === NodeType.Condition\n    ) {\n      const newContent = Object.entries(content).reduce(\n        (acc, [key]) => ({\n          ...acc,\n          [key]: newChildren,\n        }),\n        {} as Record<string, ContentNode>\n      );\n\n      return {\n        ...typedNode,\n        [typedNode.nodeType]: newContent,\n      };\n    }\n\n    if (typedNode.nodeType === NodeType.Nested) {\n      return typedNode;\n    }\n\n    return {\n      ...typedNode,\n      [typedNode.nodeType]: newChildren,\n    };\n  }\n\n  if (!section || typeof section !== 'object') {\n    return newChildren;\n  }\n\n  if (Array.isArray(section)) {\n    return section.map(() => newChildren) as unknown as ContentNode;\n  }\n\n  return Object.entries(\n    section as unknown as Record<string, ContentNode>\n  ).reduce(\n    (acc, [key]) => ({\n      ...acc,\n      [key]: newChildren,\n    }),\n    {} as Record<string, ContentNode>\n  ) as ContentNode;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAA2D;AAEpD,MAAM,qBAAqB,CAIhC,SACA,gBACgB;AAChB,MAAI,OAAO,YAAY,UAAU;AAC/B,WAAO;AAAA,EACT;AACA,MAAI,OAAO,YAAY,UAAU;AAC/B,WAAO;AAAA,EACT;AACA,MAAI,OAAO,YAAY,WAAW;AAChC,WAAO;AAAA,EACT;AACA,MAAI,OAAQ,SAAuB,aAAa,UAAU;AACxD,UAAM,YAAY;AAClB,UAAM,UAAU,UAAU,UAAU,QAA2B;AAE/D,QACE,UAAU,aAAa,sBAAS,eAChC,UAAU,aAAa,sBAAS,eAChC,UAAU,aAAa,sBAAS,WAChC;AACA,YAAM,aAAa,OAAO,QAAQ,OAAO,EAAE;AAAA,QACzC,CAAC,KAAK,CAAC,GAAG,OAAO;AAAA,UACf,GAAG;AAAA,UACH,CAAC,GAAG,GAAG;AAAA,QACT;AAAA,QACA,CAAC;AAAA,MACH;AAEA,aAAO;AAAA,QACL,GAAG;AAAA,QACH,CAAC,UAAU,QAAQ,GAAG;AAAA,MACxB;AAAA,IACF;AAEA,QAAI,UAAU,aAAa,sBAAS,QAAQ;AAC1C,aAAO;AAAA,IACT;AAEA,WAAO;AAAA,MACL,GAAG;AAAA,MACH,CAAC,UAAU,QAAQ,GAAG;AAAA,IACxB;AAAA,EACF;AAEA,MAAI,CAAC,WAAW,OAAO,YAAY,UAAU;AAC3C,WAAO;AAAA,EACT;AAEA,MAAI,MAAM,QAAQ,OAAO,GAAG;AAC1B,WAAO,QAAQ,IAAI,MAAM,WAAW;AAAA,EACtC;AAEA,SAAO,OAAO;AAAA,IACZ;AAAA,EACF,EAAE;AAAA,IACA,CAAC,KAAK,CAAC,GAAG,OAAO;AAAA,MACf,GAAG;AAAA,MACH,CAAC,GAAG,GAAG;AAAA,IACT;AAAA,IACA,CAAC;AAAA,EACH;AACF;","names":[]}

package/dist/cjs/interpreter/getContent/deepTransform.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/interpreter/getContent/deepTransform.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { type KeyPath, NodeType } from '../../types/index';\nimport { NodeProps } from './plugins';\n\n/**\n * Recursively traverses a node (object/array/primitive).\n * Applies the *first* plugin that can transform a node, then stops descending further.\n * If no plugin transforms it, it recurses into its children.\n */\nexport const deepTransformNode = (node: any, props: NodeProps): any => {\n  // Otherwise, if it's an object, check if any plugin can handle it:\n  for (const plugin of props.plugins ?? []) {\n    if (plugin.canHandle(node)) {\n      // Return the transformed node => do NOT recurse further\n      return plugin.transform(node, props, (node: any, props: any) =>\n        deepTransformNode(node, props)\n      );\n    }\n  }\n\n  // If it's null/undefined or not an object, just return it directly:\n  if (node === null || typeof node !== 'object') {\n    return node;\n  }\n\n  // If it's an array, transform each element:\n  if (Array.isArray(node)) {\n    return node.map((child, index) => {\n      const childProps = {\n        ...props,\n        content: child,\n        keyPath: [\n          ...props.keyPath,\n          { type: NodeType.Array, key: index } as KeyPath,\n        ],\n      };\n      return deepTransformNode(child, childProps);\n    });\n  }\n\n  // If no plugin transforms it, we keep traversing its properties.\n  const result: Record<string, any> = {};\n  for (const key in node) {\n    const childProps = {\n      ...props,\n      content: node[key],\n      keyPath: [...props.keyPath, { type: NodeType.Object, key } as KeyPath],\n    };\n    result[key] = deepTransformNode(node[key], childProps);\n  }\n\n  return result;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,mBAAuC;AAQhC,MAAM,oBAAoB,CAAC,MAAW,UAA0B;AAErE,aAAW,UAAU,MAAM,WAAW,CAAC,GAAG;AACxC,QAAI,OAAO,UAAU,IAAI,GAAG;AAE1B,aAAO,OAAO;AAAA,QAAU;AAAA,QAAM;AAAA,QAAO,CAACA,OAAWC,WAC/C,kBAAkBD,OAAMC,MAAK;AAAA,MAC/B;AAAA,IACF;AAAA,EACF;AAGA,MAAI,SAAS,QAAQ,OAAO,SAAS,UAAU;AAC7C,WAAO;AAAA,EACT;AAGA,MAAI,MAAM,QAAQ,IAAI,GAAG;AACvB,WAAO,KAAK,IAAI,CAAC,OAAO,UAAU;AAChC,YAAM,aAAa;AAAA,QACjB,GAAG;AAAA,QACH,SAAS;AAAA,QACT,SAAS;AAAA,UACP,GAAG,MAAM;AAAA,UACT,EAAE,MAAM,sBAAS,OAAO,KAAK,MAAM;AAAA,QACrC;AAAA,MACF;AACA,aAAO,kBAAkB,OAAO,UAAU;AAAA,IAC5C,CAAC;AAAA,EACH;AAGA,QAAM,SAA8B,CAAC;AACrC,aAAW,OAAO,MAAM;AACtB,UAAM,aAAa;AAAA,MACjB,GAAG;AAAA,MACH,SAAS,KAAK,GAAG;AAAA,MACjB,SAAS,CAAC,GAAG,MAAM,SAAS,EAAE,MAAM,sBAAS,QAAQ,IAAI,CAAY;AAAA,IACvE;AACA,WAAO,GAAG,IAAI,kBAAkB,KAAK,GAAG,GAAG,UAAU;AAAA,EACvD;AAEA,SAAO;AACT;","names":["node","props"]}
+{"version":3,"sources":["../../../../src/interpreter/getContent/deepTransform.ts"],"sourcesContent":["import { type KeyPath, NodeType } from '../../types/index';\nimport type { NodeProps } from './plugins';\n\n/**\n * Recursively traverses a node (object/array/primitive).\n * Applies the *first* plugin that can transform a node, then stops descending further.\n * If no plugin transforms it, it recurses into its children.\n */\nexport const deepTransformNode = (node: any, props: NodeProps): any => {\n  // Otherwise, if it's an object, check if any plugin can handle it:\n  for (const plugin of props.plugins ?? []) {\n    if (plugin.canHandle(node)) {\n      // Return the transformed node => do NOT recurse further\n      return plugin.transform(node, props, (node: any, props: any) =>\n        deepTransformNode(node, props)\n      );\n    }\n  }\n\n  // If it's null/undefined or not an object, just return it directly:\n  if (node === null || typeof node !== 'object') {\n    return node;\n  }\n\n  // If it's an array, transform each element:\n  if (Array.isArray(node)) {\n    return node.map((child, index) => {\n      const childProps = {\n        ...props,\n        content: child,\n        keyPath: [\n          ...props.keyPath,\n          { type: NodeType.Array, key: index } as KeyPath,\n        ],\n      };\n      return deepTransformNode(child, childProps);\n    });\n  }\n\n  // If no plugin transforms it, we keep traversing its properties.\n  const result: Record<string, any> = {};\n  for (const key in node) {\n    const childProps = {\n      ...props,\n      content: node[key],\n      keyPath: [...props.keyPath, { type: NodeType.Object, key } as KeyPath],\n    };\n    result[key] = deepTransformNode(node[key], childProps);\n  }\n\n  return result;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAuC;AAQhC,MAAM,oBAAoB,CAAC,MAAW,UAA0B;AAErE,aAAW,UAAU,MAAM,WAAW,CAAC,GAAG;AACxC,QAAI,OAAO,UAAU,IAAI,GAAG;AAE1B,aAAO,OAAO;AAAA,QAAU;AAAA,QAAM;AAAA,QAAO,CAACA,OAAWC,WAC/C,kBAAkBD,OAAMC,MAAK;AAAA,MAC/B;AAAA,IACF;AAAA,EACF;AAGA,MAAI,SAAS,QAAQ,OAAO,SAAS,UAAU;AAC7C,WAAO;AAAA,EACT;AAGA,MAAI,MAAM,QAAQ,IAAI,GAAG;AACvB,WAAO,KAAK,IAAI,CAAC,OAAO,UAAU;AAChC,YAAM,aAAa;AAAA,QACjB,GAAG;AAAA,QACH,SAAS;AAAA,QACT,SAAS;AAAA,UACP,GAAG,MAAM;AAAA,UACT,EAAE,MAAM,sBAAS,OAAO,KAAK,MAAM;AAAA,QACrC;AAAA,MACF;AACA,aAAO,kBAAkB,OAAO,UAAU;AAAA,IAC5C,CAAC;AAAA,EACH;AAGA,QAAM,SAA8B,CAAC;AACrC,aAAW,OAAO,MAAM;AACtB,UAAM,aAAa;AAAA,MACjB,GAAG;AAAA,MACH,SAAS,KAAK,GAAG;AAAA,MACjB,SAAS,CAAC,GAAG,MAAM,SAAS,EAAE,MAAM,sBAAS,QAAQ,IAAI,CAAY;AAAA,IACvE;AACA,WAAO,GAAG,IAAI,kBAAkB,KAAK,GAAG,GAAG,UAAU;AAAA,EACvD;AAEA,SAAO;AACT;","names":["node","props"]}

package/dist/cjs/interpreter/getContent/index.cjs

@@ -15,12 +15,10 @@ var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "defau
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var getContent_exports = {};
 module.exports = __toCommonJS(getContent_exports);
-__reExport(getContent_exports, require('../getDictionary.cjs'), module.exports);
 __reExport(getContent_exports, require('./deepTransform.cjs'), module.exports);
 __reExport(getContent_exports, require('./plugins.cjs'), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ...require('../getDictionary.cjs'),
   ...require('./deepTransform.cjs'),
   ...require('./plugins.cjs')
 });

package/dist/cjs/interpreter/getContent/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/interpreter/getContent/index.ts"],"sourcesContent":["export * from '../getDictionary';\nexport * from './deepTransform';\nexport * from './plugins';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,+BAAc,6BAAd;AACA,+BAAc,4BADd;AAEA,+BAAc,sBAFd;","names":[]}
+{"version":3,"sources":["../../../../src/interpreter/getContent/index.ts"],"sourcesContent":["export * from './deepTransform';\nexport * from './plugins';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,+BAAc,4BAAd;AACA,+BAAc,sBADd;","names":[]}

package/dist/cjs/interpreter/getContent/plugins.cjs

@@ -25,10 +25,10 @@ __export(plugins_exports, {
 });
 module.exports = __toCommonJS(plugins_exports);
 var import_types = require('../../types/index.cjs');
-var import_getTranslation = require('../getTranslation.cjs');
-var import_getEnumeration = require('../getEnumeration.cjs');
 var import_getCondition = require('../getCondition.cjs');
+var import_getEnumeration = require('../getEnumeration.cjs');
 var import_getNesting = require('../getNesting.cjs');
+var import_getTranslation = require('../getTranslation.cjs');
 const translationPlugin = (locale) => ({
   canHandle: (node) => typeof node === "object" && node?.nodeType === import_types.NodeType.Translation,
   transform: (node, props, deepTransformNode) => {
@@ -96,10 +96,7 @@ const conditionPlugin = {
 };
 const nestedPlugin = {
   canHandle: (node) => typeof node === "object" && node?.nodeType === import_types.NodeType.Nested,
-  transform: (node, props) => (
-    // @ts-ignore
-    (0, import_getNesting.getNesting)(node.nested.dictionaryKey, node.nested.path, props)
-  )
+  transform: (node, props) => (0, import_getNesting.getNesting)(node.nested.dictionaryKey, node.nested.path, props)
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/interpreter/getContent/plugins.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/interpreter/getContent/plugins.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport type { Locales, LocalesValues } from '@intlayer/config/client';\n\nimport { type DictionaryKeys, type KeyPath, NodeType } from '../../types/index';\nimport type {\n  ConditionContent,\n  EnumerationContent,\n  NestedContent,\n  TranslationContent,\n} from '../../transpiler';\nimport { getTranslation } from '../getTranslation';\nimport { getEnumeration } from '../getEnumeration';\nimport { getCondition } from '../getCondition';\nimport { type GetNestingResult, getNesting } from '../getNesting';\n\n/** ---------------------------------------------\n *  PLUGIN DEFINITION\n *  --------------------------------------------- */\n\n/**\n * A plugin/transformer that can optionally transform a node during a single DFS pass.\n * - `canHandle` decides if the node is transformable by this plugin.\n * - `transform` returns the transformed node (and does not recurse further).\n *\n * > `transformFn` is a function that can be used to deeply transform inside the plugin.\n */\nexport type Plugins = {\n  canHandle: (node: any) => boolean;\n  transform: (\n    node: any,\n    props: NodeProps,\n    transformFn: (node: any, props: NodeProps) => any\n  ) => any;\n};\n\n/** ---------------------------------------------\n *  TRANSLATION PLUGIN\n *  --------------------------------------------- */\n\nexport type TranslationCond<T, S> = T extends {\n  nodeType: NodeType | string;\n  [NodeType.Translation]: object;\n}\n  ? DeepTransformContent<\n      T[NodeType.Translation][keyof T[NodeType.Translation]],\n      S\n    >\n  : never;\n\n/** Translation plugin. Replaces node with a locale string if nodeType = Translation. */\nexport const translationPlugin = (locale: LocalesValues): Plugins => ({\n  canHandle: (node) =>\n    typeof node === 'object' && node?.nodeType === NodeType.Translation,\n  transform: (node: TranslationContent, props, deepTransformNode) => {\n    const result = structuredClone(node.translation);\n\n    for (const key in result) {\n      const childProps = {\n        ...props,\n        content: result[key as unknown as keyof typeof result],\n        keyPath: [\n          ...props.keyPath,\n          { type: NodeType.Translation, key } as KeyPath,\n        ],\n      };\n      result[key as unknown as keyof typeof result] = deepTransformNode(\n        result[key as unknown as keyof typeof result],\n        childProps\n      );\n    }\n    return getTranslation(result, locale);\n  },\n});\n\n/** ---------------------------------------------\n *  ENUMERATION PLUGIN\n *  --------------------------------------------- */\n\nexport type EnumerationCond<T, S> = T extends {\n  nodeType: NodeType | string;\n  [NodeType.Enumeration]: object;\n}\n  ? (\n      quantity: number\n    ) => DeepTransformContent<\n      T[NodeType.Enumeration][keyof T[NodeType.Enumeration]],\n      S\n    >\n  : never;\n\n/** Enumeration plugin. Replaces node with a function that takes quantity => string. */\nexport const enumerationPlugin: Plugins = {\n  canHandle: (node) =>\n    typeof node === 'object' && node?.nodeType === NodeType.Enumeration,\n  transform: (node: EnumerationContent, props, deepTransformNode) => {\n    const result = structuredClone(node.enumeration);\n\n    for (const key in result) {\n      const child = result[key as unknown as keyof typeof result];\n      const childProps = {\n        ...props,\n        content: child,\n        keyPath: [\n          ...props.keyPath,\n          { type: NodeType.Enumeration, key } as KeyPath,\n        ],\n      };\n      result[key as unknown as keyof typeof result] = deepTransformNode(\n        child,\n        childProps\n      );\n    }\n\n    return (quantity: number) => getEnumeration(result, quantity);\n  },\n};\n\n/** ---------------------------------------------\n *  CONDITION PLUGIN\n *  --------------------------------------------- */\n\nexport type ConditionCond<T, S> = T extends {\n  nodeType: NodeType | string;\n  [NodeType.Condition]: object;\n}\n  ? (\n      value: boolean\n    ) => DeepTransformContent<\n      T[NodeType.Condition][keyof T[NodeType.Condition]],\n      S\n    >\n  : never;\n\n/** Condition plugin. Replaces node with a function that takes boolean => string. */\nexport const conditionPlugin: Plugins = {\n  canHandle: (node) =>\n    typeof node === 'object' && node?.nodeType === NodeType.Condition,\n  transform: (node: ConditionContent, props, deepTransformNode) => {\n    const result = structuredClone(node.condition);\n\n    for (const key in result) {\n      const child = result[key as keyof typeof result];\n      const childProps = {\n        ...props,\n        content: child,\n        keyPath: [\n          ...props.keyPath,\n          { type: NodeType.Condition, key } as KeyPath,\n        ],\n      };\n      result[key as unknown as keyof typeof result] = deepTransformNode(\n        child,\n        childProps\n      );\n    }\n\n    return (value: boolean) => getCondition(result, value);\n  },\n};\n\n/** ---------------------------------------------\n *  NESTED PLUGIN\n *  --------------------------------------------- */\n\nexport type NestedCond<T, S> = T extends {\n  nodeType: NodeType | string;\n  [NodeType.Nested]: infer U;\n}\n  ? U extends {\n      dictionaryKey: infer K extends DictionaryKeys;\n      path?: infer P;\n    }\n    ? GetNestingResult<K, P, S>\n    : never\n  : never;\n\n/** Nested plugin. Replaces node with the result of `getNesting`. */\nexport const nestedPlugin: Plugins = {\n  canHandle: (node) =>\n    typeof node === 'object' && node?.nodeType === NodeType.Nested,\n  transform: (node: NestedContent, props) =>\n    // @ts-ignore\n    getNesting(node.nested.dictionaryKey, node.nested.path, props),\n};\n\n/**\n * PLUGIN RESULT\n */\n\n/**\n * Interface that defines the properties of a node.\n * This interface can be augmented in other packages, such as `react-intlayer`.\n */\nexport interface NodeProps {\n  dictionaryKey: string;\n  keyPath: KeyPath[];\n  plugins?: Plugins[];\n  locale?: Locales;\n  dictionaryPath?: string;\n  content?: any;\n}\n\n/**\n * Interface that defines the plugins that can be used to transform a node.\n * This interface can be augmented in other packages, such as `react-intlayer`.\n */\nexport interface IInterpreterPlugin<T, S> {\n  translation: TranslationCond<T, S>;\n  enumeration: EnumerationCond<T, S>;\n  condition: ConditionCond<T, S>;\n  nested: NestedCond<T, S>;\n}\n\n/**\n * Allow to avoid overwriting import from `intlayer` package when `IInterpreterPlugin<T>` interface is augmented in another package, such as `react-intlayer`.\n */\nexport type IInterpreterPluginState = {\n  translation: true;\n  enumeration: true;\n  condition: true;\n  nested: true;\n};\n\n/**\n * Utility type to check if a plugin can be applied to a node.\n */\ntype CheckApplyPlugin<T, K extends keyof IInterpreterPlugin<T, S>, S> =\n  // Test if the key is a key of S.\n  K extends keyof S\n    ? // Test if the key of S is true. Then the plugin can be applied.\n      S[K] extends true\n      ? // Test if the key of S exist\n        IInterpreterPlugin<T, S>[K] extends never\n        ? never\n        : // Test if the plugin condition is true (if it's not, the plugin is skipped for this node)\n          IInterpreterPlugin<T, S>[K]\n      : never\n    : never;\n\n/**\n * Traverse recursively through an object or array, applying each plugin as needed.\n */\ntype Traverse<T, S> =\n  // Turn any read-only array into a plain mutable array\n  T extends ReadonlyArray<infer U>\n    ? Array<DeepTransformContent<U, S>>\n    : T extends object\n      ? { [K in keyof T]: DeepTransformContent<T[K], S> }\n      : T;\n\n/**\n * Traverse recursively through an object or array, applying each plugin as needed.\n */\nexport type DeepTransformContent<T, S = IInterpreterPluginState> =\n  // Check if there is a plugin for T:\n  CheckApplyPlugin<T, keyof IInterpreterPlugin<T, S>, S> extends never\n    ? // No plugin was found, so try to transform T recursively:\n      Traverse<T, S>\n    : // A plugin was found – use the plugin’s transformation.\n      IInterpreterPlugin<T, S>[keyof IInterpreterPlugin<T, S>];\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAIA,mBAA4D;AAO5D,4BAA+B;AAC/B,4BAA+B;AAC/B,0BAA6B;AAC7B,wBAAkD;AAqC3C,MAAM,oBAAoB,CAAC,YAAoC;AAAA,EACpE,WAAW,CAAC,SACV,OAAO,SAAS,YAAY,MAAM,aAAa,sBAAS;AAAA,EAC1D,WAAW,CAAC,MAA0B,OAAO,sBAAsB;AACjE,UAAM,SAAS,gBAAgB,KAAK,WAAW;AAE/C,eAAW,OAAO,QAAQ;AACxB,YAAM,aAAa;AAAA,QACjB,GAAG;AAAA,QACH,SAAS,OAAO,GAAqC;AAAA,QACrD,SAAS;AAAA,UACP,GAAG,MAAM;AAAA,UACT,EAAE,MAAM,sBAAS,aAAa,IAAI;AAAA,QACpC;AAAA,MACF;AACA,aAAO,GAAqC,IAAI;AAAA,QAC9C,OAAO,GAAqC;AAAA,QAC5C;AAAA,MACF;AAAA,IACF;AACA,eAAO,sCAAe,QAAQ,MAAM;AAAA,EACtC;AACF;AAmBO,MAAM,oBAA6B;AAAA,EACxC,WAAW,CAAC,SACV,OAAO,SAAS,YAAY,MAAM,aAAa,sBAAS;AAAA,EAC1D,WAAW,CAAC,MAA0B,OAAO,sBAAsB;AACjE,UAAM,SAAS,gBAAgB,KAAK,WAAW;AAE/C,eAAW,OAAO,QAAQ;AACxB,YAAM,QAAQ,OAAO,GAAqC;AAC1D,YAAM,aAAa;AAAA,QACjB,GAAG;AAAA,QACH,SAAS;AAAA,QACT,SAAS;AAAA,UACP,GAAG,MAAM;AAAA,UACT,EAAE,MAAM,sBAAS,aAAa,IAAI;AAAA,QACpC;AAAA,MACF;AACA,aAAO,GAAqC,IAAI;AAAA,QAC9C;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAEA,WAAO,CAAC,iBAAqB,sCAAe,QAAQ,QAAQ;AAAA,EAC9D;AACF;AAmBO,MAAM,kBAA2B;AAAA,EACtC,WAAW,CAAC,SACV,OAAO,SAAS,YAAY,MAAM,aAAa,sBAAS;AAAA,EAC1D,WAAW,CAAC,MAAwB,OAAO,sBAAsB;AAC/D,UAAM,SAAS,gBAAgB,KAAK,SAAS;AAE7C,eAAW,OAAO,QAAQ;AACxB,YAAM,QAAQ,OAAO,GAA0B;AAC/C,YAAM,aAAa;AAAA,QACjB,GAAG;AAAA,QACH,SAAS;AAAA,QACT,SAAS;AAAA,UACP,GAAG,MAAM;AAAA,UACT,EAAE,MAAM,sBAAS,WAAW,IAAI;AAAA,QAClC;AAAA,MACF;AACA,aAAO,GAAqC,IAAI;AAAA,QAC9C;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAEA,WAAO,CAAC,cAAmB,kCAAa,QAAQ,KAAK;AAAA,EACvD;AACF;AAmBO,MAAM,eAAwB;AAAA,EACnC,WAAW,CAAC,SACV,OAAO,SAAS,YAAY,MAAM,aAAa,sBAAS;AAAA,EAC1D,WAAW,CAAC,MAAqB;AAAA;AAAA,QAE/B,8BAAW,KAAK,OAAO,eAAe,KAAK,OAAO,MAAM,KAAK;AAAA;AACjE;","names":[]}
+{"version":3,"sources":["../../../../src/interpreter/getContent/plugins.ts"],"sourcesContent":["import type { Locales, LocalesValues } from '@intlayer/config/client';\n\nimport type {\n  ConditionContent,\n  EnumerationContent,\n  NestedContent,\n  TranslationContent,\n} from '../../transpiler';\nimport { type DictionaryKeys, type KeyPath, NodeType } from '../../types/index';\nimport { getCondition } from '../getCondition';\nimport { getEnumeration } from '../getEnumeration';\nimport { type GetNestingResult, getNesting } from '../getNesting';\nimport { getTranslation } from '../getTranslation';\n\n/** ---------------------------------------------\n *  PLUGIN DEFINITION\n *  --------------------------------------------- */\n\n/**\n * A plugin/transformer that can optionally transform a node during a single DFS pass.\n * - `canHandle` decides if the node is transformable by this plugin.\n * - `transform` returns the transformed node (and does not recurse further).\n *\n * > `transformFn` is a function that can be used to deeply transform inside the plugin.\n */\nexport type Plugins = {\n  canHandle: (node: any) => boolean;\n  transform: (\n    node: any,\n    props: NodeProps,\n    transformFn: (node: any, props: NodeProps) => any\n  ) => any;\n};\n\n/** ---------------------------------------------\n *  TRANSLATION PLUGIN\n *  --------------------------------------------- */\n\nexport type TranslationCond<T, S> = T extends {\n  nodeType: NodeType | string;\n  [NodeType.Translation]: object;\n}\n  ? DeepTransformContent<\n      T[NodeType.Translation][keyof T[NodeType.Translation]],\n      S\n    >\n  : never;\n\n/** Translation plugin. Replaces node with a locale string if nodeType = Translation. */\nexport const translationPlugin = (locale: LocalesValues): Plugins => ({\n  canHandle: (node) =>\n    typeof node === 'object' && node?.nodeType === NodeType.Translation,\n  transform: (node: TranslationContent, props, deepTransformNode) => {\n    const result = structuredClone(node.translation);\n\n    for (const key in result) {\n      const childProps = {\n        ...props,\n        content: result[key as unknown as keyof typeof result],\n        keyPath: [\n          ...props.keyPath,\n          { type: NodeType.Translation, key } as KeyPath,\n        ],\n      };\n      result[key as unknown as keyof typeof result] = deepTransformNode(\n        result[key as unknown as keyof typeof result],\n        childProps\n      );\n    }\n    return getTranslation(result, locale);\n  },\n});\n\n/** ---------------------------------------------\n *  ENUMERATION PLUGIN\n *  --------------------------------------------- */\n\nexport type EnumerationCond<T, S> = T extends {\n  nodeType: NodeType | string;\n  [NodeType.Enumeration]: object;\n}\n  ? (\n      quantity: number\n    ) => DeepTransformContent<\n      T[NodeType.Enumeration][keyof T[NodeType.Enumeration]],\n      S\n    >\n  : never;\n\n/** Enumeration plugin. Replaces node with a function that takes quantity => string. */\nexport const enumerationPlugin: Plugins = {\n  canHandle: (node) =>\n    typeof node === 'object' && node?.nodeType === NodeType.Enumeration,\n  transform: (node: EnumerationContent, props, deepTransformNode) => {\n    const result = structuredClone(node.enumeration);\n\n    for (const key in result) {\n      const child = result[key as unknown as keyof typeof result];\n      const childProps = {\n        ...props,\n        content: child,\n        keyPath: [\n          ...props.keyPath,\n          { type: NodeType.Enumeration, key } as KeyPath,\n        ],\n      };\n      result[key as unknown as keyof typeof result] = deepTransformNode(\n        child,\n        childProps\n      );\n    }\n\n    return (quantity: number) => getEnumeration(result, quantity);\n  },\n};\n\n/** ---------------------------------------------\n *  CONDITION PLUGIN\n *  --------------------------------------------- */\n\nexport type ConditionCond<T, S> = T extends {\n  nodeType: NodeType | string;\n  [NodeType.Condition]: object;\n}\n  ? (\n      value: boolean\n    ) => DeepTransformContent<\n      T[NodeType.Condition][keyof T[NodeType.Condition]],\n      S\n    >\n  : never;\n\n/** Condition plugin. Replaces node with a function that takes boolean => string. */\nexport const conditionPlugin: Plugins = {\n  canHandle: (node) =>\n    typeof node === 'object' && node?.nodeType === NodeType.Condition,\n  transform: (node: ConditionContent, props, deepTransformNode) => {\n    const result = structuredClone(node.condition);\n\n    for (const key in result) {\n      const child = result[key as keyof typeof result];\n      const childProps = {\n        ...props,\n        content: child,\n        keyPath: [\n          ...props.keyPath,\n          { type: NodeType.Condition, key } as KeyPath,\n        ],\n      };\n      result[key as unknown as keyof typeof result] = deepTransformNode(\n        child,\n        childProps\n      );\n    }\n\n    return (value: boolean) => getCondition(result, value);\n  },\n};\n\n/** ---------------------------------------------\n *  NESTED PLUGIN\n *  --------------------------------------------- */\n\nexport type NestedCond<T, S> = T extends {\n  nodeType: NodeType | string;\n  [NodeType.Nested]: infer U;\n}\n  ? U extends {\n      dictionaryKey: infer K extends DictionaryKeys;\n      path?: infer P;\n    }\n    ? GetNestingResult<K, P, S>\n    : never\n  : never;\n\n/** Nested plugin. Replaces node with the result of `getNesting`. */\nexport const nestedPlugin: Plugins = {\n  canHandle: (node) =>\n    typeof node === 'object' && node?.nodeType === NodeType.Nested,\n  transform: (node: NestedContent, props) =>\n    getNesting(node.nested.dictionaryKey, node.nested.path, props),\n};\n\n/**\n * PLUGIN RESULT\n */\n\n/**\n * Interface that defines the properties of a node.\n * This interface can be augmented in other packages, such as `react-intlayer`.\n */\nexport interface NodeProps {\n  dictionaryKey: string;\n  keyPath: KeyPath[];\n  plugins?: Plugins[];\n  locale?: Locales;\n  dictionaryPath?: string;\n  content?: any;\n}\n\n/**\n * Interface that defines the plugins that can be used to transform a node.\n * This interface can be augmented in other packages, such as `react-intlayer`.\n */\nexport interface IInterpreterPlugin<T, S> {\n  translation: TranslationCond<T, S>;\n  enumeration: EnumerationCond<T, S>;\n  condition: ConditionCond<T, S>;\n  nested: NestedCond<T, S>;\n}\n\n/**\n * Allow to avoid overwriting import from `intlayer` package when `IInterpreterPlugin<T>` interface is augmented in another package, such as `react-intlayer`.\n */\nexport type IInterpreterPluginState = {\n  translation: true;\n  enumeration: true;\n  condition: true;\n  nested: true;\n};\n\n/**\n * Utility type to check if a plugin can be applied to a node.\n */\ntype CheckApplyPlugin<T, K extends keyof IInterpreterPlugin<T, S>, S> =\n  // Test if the key is a key of S.\n  K extends keyof S\n    ? // Test if the key of S is true. Then the plugin can be applied.\n      S[K] extends true\n      ? // Test if the key of S exist\n        IInterpreterPlugin<T, S>[K] extends never\n        ? never\n        : // Test if the plugin condition is true (if it's not, the plugin is skipped for this node)\n          IInterpreterPlugin<T, S>[K]\n      : never\n    : never;\n\n/**\n * Traverse recursively through an object or array, applying each plugin as needed.\n */\ntype Traverse<T, S> =\n  // Turn any read-only array into a plain mutable array\n  T extends ReadonlyArray<infer U>\n    ? Array<DeepTransformContent<U, S>>\n    : T extends object\n      ? { [K in keyof T]: DeepTransformContent<T[K], S> }\n      : T;\n\n/**\n * Traverse recursively through an object or array, applying each plugin as needed.\n */\nexport type DeepTransformContent<T, S = IInterpreterPluginState> =\n  // Check if there is a plugin for T:\n  CheckApplyPlugin<T, keyof IInterpreterPlugin<T, S>, S> extends never\n    ? // No plugin was found, so try to transform T recursively:\n      Traverse<T, S>\n    : // A plugin was found – use the plugin’s transformation.\n      IInterpreterPlugin<T, S>[keyof IInterpreterPlugin<T, S>];\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,mBAA4D;AAC5D,0BAA6B;AAC7B,4BAA+B;AAC/B,wBAAkD;AAClD,4BAA+B;AAqCxB,MAAM,oBAAoB,CAAC,YAAoC;AAAA,EACpE,WAAW,CAAC,SACV,OAAO,SAAS,YAAY,MAAM,aAAa,sBAAS;AAAA,EAC1D,WAAW,CAAC,MAA0B,OAAO,sBAAsB;AACjE,UAAM,SAAS,gBAAgB,KAAK,WAAW;AAE/C,eAAW,OAAO,QAAQ;AACxB,YAAM,aAAa;AAAA,QACjB,GAAG;AAAA,QACH,SAAS,OAAO,GAAqC;AAAA,QACrD,SAAS;AAAA,UACP,GAAG,MAAM;AAAA,UACT,EAAE,MAAM,sBAAS,aAAa,IAAI;AAAA,QACpC;AAAA,MACF;AACA,aAAO,GAAqC,IAAI;AAAA,QAC9C,OAAO,GAAqC;AAAA,QAC5C;AAAA,MACF;AAAA,IACF;AACA,eAAO,sCAAe,QAAQ,MAAM;AAAA,EACtC;AACF;AAmBO,MAAM,oBAA6B;AAAA,EACxC,WAAW,CAAC,SACV,OAAO,SAAS,YAAY,MAAM,aAAa,sBAAS;AAAA,EAC1D,WAAW,CAAC,MAA0B,OAAO,sBAAsB;AACjE,UAAM,SAAS,gBAAgB,KAAK,WAAW;AAE/C,eAAW,OAAO,QAAQ;AACxB,YAAM,QAAQ,OAAO,GAAqC;AAC1D,YAAM,aAAa;AAAA,QACjB,GAAG;AAAA,QACH,SAAS;AAAA,QACT,SAAS;AAAA,UACP,GAAG,MAAM;AAAA,UACT,EAAE,MAAM,sBAAS,aAAa,IAAI;AAAA,QACpC;AAAA,MACF;AACA,aAAO,GAAqC,IAAI;AAAA,QAC9C;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAEA,WAAO,CAAC,iBAAqB,sCAAe,QAAQ,QAAQ;AAAA,EAC9D;AACF;AAmBO,MAAM,kBAA2B;AAAA,EACtC,WAAW,CAAC,SACV,OAAO,SAAS,YAAY,MAAM,aAAa,sBAAS;AAAA,EAC1D,WAAW,CAAC,MAAwB,OAAO,sBAAsB;AAC/D,UAAM,SAAS,gBAAgB,KAAK,SAAS;AAE7C,eAAW,OAAO,QAAQ;AACxB,YAAM,QAAQ,OAAO,GAA0B;AAC/C,YAAM,aAAa;AAAA,QACjB,GAAG;AAAA,QACH,SAAS;AAAA,QACT,SAAS;AAAA,UACP,GAAG,MAAM;AAAA,UACT,EAAE,MAAM,sBAAS,WAAW,IAAI;AAAA,QAClC;AAAA,MACF;AACA,aAAO,GAAqC,IAAI;AAAA,QAC9C;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAEA,WAAO,CAAC,cAAmB,kCAAa,QAAQ,KAAK;AAAA,EACvD;AACF;AAmBO,MAAM,eAAwB;AAAA,EACnC,WAAW,CAAC,SACV,OAAO,SAAS,YAAY,MAAM,aAAa,sBAAS;AAAA,EAC1D,WAAW,CAAC,MAAqB,cAC/B,8BAAW,KAAK,OAAO,eAAe,KAAK,OAAO,MAAM,KAAK;AACjE;","names":[]}