@intlayer/core 4.1.11 → 5.0.0

package/dist/cjs/dictionaryManipulator/editDictionaryByKeyPath.cjs

@@ -0,0 +1,97 @@
+"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 editDictionaryByKeyPath_exports = {};
+__export(editDictionaryByKeyPath_exports, {
+  editDictionaryByKeyPath: () => editDictionaryByKeyPath
+});
+module.exports = __toCommonJS(editDictionaryByKeyPath_exports);
+var import_types = require('../types/index.cjs');
+const editDictionaryByKeyPath = (dictionaryContent, keyPath, newValue) => {
+  let currentValue = dictionaryContent;
+  let parentValue = null;
+  let lastKeys = [];
+  for (const keyObj of keyPath) {
+    parentValue = currentValue;
+    if (keyObj.type === import_types.NodeType.Object) {
+      lastKeys = [keyObj.key];
+      if (!currentValue[keyObj.key]) {
+        currentValue = {
+          ...currentValue,
+          [keyObj.key]: {}
+        };
+      }
+      currentValue = currentValue[keyObj.key];
+    } else if (keyObj.type === import_types.NodeType.Array) {
+      lastKeys = [keyObj.key];
+      if (!currentValue[keyObj.key]) {
+        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
+        };
+      }
+      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
+        };
+      }
+      currentValue = currentValue[import_types.NodeType.Enumeration][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;
+      }
+      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;
+      }
+      currentValue = currentValue[import_types.NodeType.Nested];
+    }
+    if (parentValue && lastKeys.length > 0) {
+      for (const key of lastKeys.slice(0, -1)) {
+        parentValue = parentValue[key];
+      }
+      if (
+        // Remove the field if the new value is undefined
+        typeof newValue === "undefined"
+      ) {
+        delete parentValue[lastKeys[lastKeys.length - 1]];
+      } else {
+        parentValue[lastKeys[lastKeys.length - 1]] = newValue;
+      }
+    }
+  }
+  return dictionaryContent;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  editDictionaryByKeyPath
+});
+//# sourceMappingURL=editDictionaryByKeyPath.cjs.map

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

@@ -0,0 +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":[]}

package/dist/cjs/dictionaryManipulator/getContentNodeByKeyPath.cjs

@@ -0,0 +1,46 @@
+"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 getContentNodeByKeyPath_exports = {};
+__export(getContentNodeByKeyPath_exports, {
+  getContentNodeByKeyPath: () => getContentNodeByKeyPath
+});
+module.exports = __toCommonJS(getContentNodeByKeyPath_exports);
+var import_types = require('../types/index.cjs');
+const getContentNodeByKeyPath = (dictionaryContent, keyPath) => {
+  let currentValue = JSON.parse(JSON.stringify(dictionaryContent ?? {}));
+  for (const keyObj of keyPath) {
+    if (keyObj.type === import_types.NodeType.Object || keyObj.type === import_types.NodeType.Array) {
+      currentValue = currentValue?.[keyObj.key];
+    } else if (keyObj.type === import_types.NodeType.Translation) {
+      currentValue = currentValue?.[import_types.NodeType.Translation][keyObj.key];
+    } else if (keyObj.type === import_types.NodeType.Enumeration) {
+      currentValue = currentValue?.[import_types.NodeType.Enumeration][keyObj.key];
+    } else if (keyObj.type === import_types.NodeType.Condition) {
+      currentValue = currentValue[import_types.NodeType.Condition];
+    } else if (keyObj.type === import_types.NodeType.Markdown) {
+      currentValue = currentValue[import_types.NodeType.Markdown];
+    }
+  }
+  return currentValue;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getContentNodeByKeyPath
+});
+//# sourceMappingURL=getContentNodeByKeyPath.cjs.map

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

@@ -0,0 +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":[]}

package/dist/cjs/dictionaryManipulator/getSectionType.cjs

@@ -0,0 +1,57 @@
+"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 getSectionType_exports = {};
+__export(getSectionType_exports, {
+  getSectionType: () => getSectionType
+});
+module.exports = __toCommonJS(getSectionType_exports);
+var import_types = require('../types/index.cjs');
+var import_isValidReactElement = require('../utils/isValidReactElement.cjs');
+const getSectionType = (section) => {
+  if (typeof section === "string") {
+    return import_types.NodeType.Text;
+  }
+  if (section?.nodeType === import_types.NodeType.Translation) {
+    return import_types.NodeType.Translation;
+  }
+  if (section?.nodeType === import_types.NodeType.Enumeration) {
+    return import_types.NodeType.Enumeration;
+  }
+  if (section?.nodeType === import_types.NodeType.Condition) {
+    return import_types.NodeType.Condition;
+  }
+  if (section?.nodeType === import_types.NodeType.Markdown) {
+    return import_types.NodeType.Markdown;
+  }
+  if (section?.nodeType === import_types.NodeType.Nested) {
+    return import_types.NodeType.Nested;
+  }
+  if (Array.isArray(section)) {
+    return import_types.NodeType.Array;
+  }
+  if ((0, import_isValidReactElement.isValidElement)(section)) {
+    return import_types.NodeType.ReactNode;
+  }
+  return import_types.NodeType.Object;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getSectionType
+});
+//# sourceMappingURL=getSectionType.cjs.map

package/dist/cjs/dictionaryManipulator/getSectionType.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/dictionaryManipulator/getSectionType.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 getSectionType = (section: ContentNode): NodeType => {\n  if (typeof section === 'string') {\n    return NodeType.Text;\n  }\n\n  if (\n    (section as TranslationContent<unknown>)?.nodeType === NodeType.Translation\n  ) {\n    return NodeType.Translation;\n  }\n\n  if (\n    (section as EnumerationContent<unknown>)?.nodeType === NodeType.Enumeration\n  ) {\n    return NodeType.Enumeration;\n  }\n\n  if ((section as ConditionContent<unknown>)?.nodeType === NodeType.Condition) {\n    return NodeType.Condition;\n  }\n\n  if ((section as MarkdownContent)?.nodeType === NodeType.Markdown) {\n    return NodeType.Markdown;\n  }\n\n  if (\n    (section as NestedContent<DictionaryKeys>)?.nodeType === NodeType.Nested\n  ) {\n    return NodeType.Nested;\n  }\n\n  if (Array.isArray(section)) {\n    return NodeType.Array;\n  }\n\n  if (isValidElement(section)) {\n    return NodeType.ReactNode;\n  }\n\n  return NodeType.Object;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,mBAA8C;AAE9C,iCAA+B;AAExB,MAAM,iBAAiB,CAAC,YAAmC;AAChE,MAAI,OAAO,YAAY,UAAU;AAC/B,WAAO,sBAAS;AAAA,EAClB;AAEA,MACG,SAAyC,aAAa,sBAAS,aAChE;AACA,WAAO,sBAAS;AAAA,EAClB;AAEA,MACG,SAAyC,aAAa,sBAAS,aAChE;AACA,WAAO,sBAAS;AAAA,EAClB;AAEA,MAAK,SAAuC,aAAa,sBAAS,WAAW;AAC3E,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,SAAO,sBAAS;AAClB;","names":[]}

package/dist/cjs/dictionaryManipulator/index.cjs

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+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('./removeContentNodeByKeyPath.cjs'), module.exports);
+__reExport(dictionaryManipulator_exports, require('./renameContentNodeByKeyPath.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('./removeContentNodeByKeyPath.cjs'),
+  ...require('./renameContentNodeByKeyPath.cjs')
+});
+//# sourceMappingURL=index.cjs.map

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

@@ -0,0 +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":[]}

package/dist/cjs/dictionaryManipulator/removeContentNodeByKeyPath.cjs

@@ -0,0 +1,64 @@
+"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 removeContentNodeByKeyPath_exports = {};
+__export(removeContentNodeByKeyPath_exports, {
+  removeContentNodeByKeyPath: () => removeContentNodeByKeyPath
+});
+module.exports = __toCommonJS(removeContentNodeByKeyPath_exports);
+var import_types = require('../types/index.cjs');
+const removeContentNodeByKeyPath = (dictionaryContent, keyPath) => {
+  let currentValue = dictionaryContent;
+  let parentValue = null;
+  let lastKey = null;
+  for (const keyObj of keyPath) {
+    parentValue = currentValue;
+    if (keyObj.type === import_types.NodeType.Object || keyObj.type === import_types.NodeType.Array) {
+      lastKey = keyObj.key;
+      currentValue = currentValue[keyObj.key];
+    } else if (keyObj.type === import_types.NodeType.Translation) {
+      lastKey = import_types.NodeType.Translation;
+      currentValue = currentValue[import_types.NodeType.Translation][keyObj.key];
+    } else if (keyObj.type === import_types.NodeType.Enumeration) {
+      lastKey = import_types.NodeType.Enumeration;
+      currentValue = currentValue[import_types.NodeType.Enumeration][keyObj.key];
+    } else if (keyObj.type === import_types.NodeType.Condition) {
+      lastKey = import_types.NodeType.Condition;
+      currentValue = currentValue[import_types.NodeType.Condition];
+    } else if (keyObj.type === import_types.NodeType.Markdown) {
+      lastKey = import_types.NodeType.Markdown;
+      currentValue = currentValue[import_types.NodeType.Markdown];
+    } else if (keyObj.type === import_types.NodeType.ReactNode) {
+      lastKey = import_types.NodeType.ReactNode;
+      currentValue = currentValue[import_types.NodeType.ReactNode];
+    }
+  }
+  if (parentValue && lastKey !== null) {
+    if (Array.isArray(parentValue)) {
+      parentValue.splice(lastKey, 1);
+    } else {
+      delete parentValue[lastKey];
+    }
+  }
+  return dictionaryContent;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  removeContentNodeByKeyPath
+});
+//# sourceMappingURL=removeContentNodeByKeyPath.cjs.map

package/dist/cjs/dictionaryManipulator/removeContentNodeByKeyPath.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/dictionaryManipulator/removeContentNodeByKeyPath.ts"],"sourcesContent":["import { type KeyPath, NodeType } from '../types';\nimport type { ContentNode } from '../types/dictionary';\n\nexport const removeContentNodeByKeyPath = (\n  dictionaryContent: ContentNode,\n  keyPath: KeyPath[]\n): ContentNode => {\n  let currentValue: any = dictionaryContent;\n  let parentValue: any = null;\n  let lastKey: string | number | null = null;\n\n  for (const keyObj of keyPath) {\n    parentValue = currentValue;\n\n    if (keyObj.type === NodeType.Object || keyObj.type === NodeType.Array) {\n      lastKey = keyObj.key;\n      currentValue = currentValue[keyObj.key];\n    } else if (keyObj.type === NodeType.Translation) {\n      lastKey = NodeType.Translation;\n      currentValue = currentValue[NodeType.Translation][keyObj.key];\n    } else if (keyObj.type === NodeType.Enumeration) {\n      lastKey = NodeType.Enumeration;\n      currentValue = currentValue[NodeType.Enumeration][keyObj.key];\n    } else if (keyObj.type === NodeType.Condition) {\n      lastKey = NodeType.Condition;\n      currentValue = currentValue[NodeType.Condition];\n    } else if (keyObj.type === NodeType.Markdown) {\n      lastKey = NodeType.Markdown;\n      currentValue = currentValue[NodeType.Markdown];\n    } else if (keyObj.type === NodeType.ReactNode) {\n      lastKey = NodeType.ReactNode;\n      currentValue = currentValue[NodeType.ReactNode];\n    }\n  }\n\n  if (parentValue && lastKey !== null) {\n    if (Array.isArray(parentValue)) {\n      parentValue.splice(lastKey as unknown as number, 1);\n    } else {\n      delete parentValue[lastKey];\n    }\n  }\n\n  return dictionaryContent;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAuC;AAGhC,MAAM,6BAA6B,CACxC,mBACA,YACgB;AAChB,MAAI,eAAoB;AACxB,MAAI,cAAmB;AACvB,MAAI,UAAkC;AAEtC,aAAW,UAAU,SAAS;AAC5B,kBAAc;AAEd,QAAI,OAAO,SAAS,sBAAS,UAAU,OAAO,SAAS,sBAAS,OAAO;AACrE,gBAAU,OAAO;AACjB,qBAAe,aAAa,OAAO,GAAG;AAAA,IACxC,WAAW,OAAO,SAAS,sBAAS,aAAa;AAC/C,gBAAU,sBAAS;AACnB,qBAAe,aAAa,sBAAS,WAAW,EAAE,OAAO,GAAG;AAAA,IAC9D,WAAW,OAAO,SAAS,sBAAS,aAAa;AAC/C,gBAAU,sBAAS;AACnB,qBAAe,aAAa,sBAAS,WAAW,EAAE,OAAO,GAAG;AAAA,IAC9D,WAAW,OAAO,SAAS,sBAAS,WAAW;AAC7C,gBAAU,sBAAS;AACnB,qBAAe,aAAa,sBAAS,SAAS;AAAA,IAChD,WAAW,OAAO,SAAS,sBAAS,UAAU;AAC5C,gBAAU,sBAAS;AACnB,qBAAe,aAAa,sBAAS,QAAQ;AAAA,IAC/C,WAAW,OAAO,SAAS,sBAAS,WAAW;AAC7C,gBAAU,sBAAS;AACnB,qBAAe,aAAa,sBAAS,SAAS;AAAA,IAChD;AAAA,EACF;AAEA,MAAI,eAAe,YAAY,MAAM;AACnC,QAAI,MAAM,QAAQ,WAAW,GAAG;AAC9B,kBAAY,OAAO,SAA8B,CAAC;AAAA,IACpD,OAAO;AACL,aAAO,YAAY,OAAO;AAAA,IAC5B;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/cjs/dictionaryManipulator/renameContentNodeByKeyPath.cjs

@@ -0,0 +1,73 @@
+"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 renameContentNodeByKeyPath_exports = {};
+__export(renameContentNodeByKeyPath_exports, {
+  renameContentNodeByKeyPath: () => renameContentNodeByKeyPath
+});
+module.exports = __toCommonJS(renameContentNodeByKeyPath_exports);
+var import_types = require('../types/index.cjs');
+const renameContentNodeByKeyPath = (dictionaryContent, newKey, keyPath) => {
+  let currentValue = dictionaryContent;
+  let parentValue = null;
+  let lastKey = null;
+  for (const keyObj of keyPath) {
+    parentValue = currentValue;
+    if (keyObj.type === import_types.NodeType.Object || keyObj.type === import_types.NodeType.Array) {
+      lastKey = keyObj.key;
+      currentValue = currentValue[keyObj.key];
+    } else if (keyObj.type === import_types.NodeType.Translation) {
+      lastKey = import_types.NodeType.Translation;
+      currentValue = currentValue[import_types.NodeType.Translation][keyObj.key];
+    } else if (keyObj.type === import_types.NodeType.Enumeration) {
+      lastKey = import_types.NodeType.Enumeration;
+      currentValue = currentValue[import_types.NodeType.Enumeration][keyObj.key];
+    } else if (keyObj.type === import_types.NodeType.Condition) {
+      lastKey = import_types.NodeType.Condition;
+      currentValue = currentValue[import_types.NodeType.Condition];
+    } else if (keyObj.type === import_types.NodeType.Markdown) {
+      lastKey = import_types.NodeType.Markdown;
+      currentValue = currentValue[import_types.NodeType.Markdown];
+    } else if (keyObj.type === import_types.NodeType.ReactNode) {
+      lastKey = import_types.NodeType.ReactNode;
+      currentValue = currentValue[import_types.NodeType.ReactNode];
+    }
+  }
+  if (parentValue && lastKey !== null) {
+    if (Array.isArray(parentValue)) {
+      parentValue[lastKey] = currentValue;
+    } else {
+      const newParentValue = {};
+      for (const key of Object.keys(parentValue)) {
+        if (key === lastKey && typeof newKey !== "undefined") {
+          newParentValue[newKey] = currentValue;
+        } else {
+          newParentValue[key] = parentValue[key];
+        }
+      }
+      Object.keys(parentValue).forEach((key) => delete parentValue[key]);
+      Object.assign(parentValue, newParentValue);
+    }
+  }
+  return dictionaryContent;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  renameContentNodeByKeyPath
+});
+//# sourceMappingURL=renameContentNodeByKeyPath.cjs.map

package/dist/cjs/dictionaryManipulator/renameContentNodeByKeyPath.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/dictionaryManipulator/renameContentNodeByKeyPath.ts"],"sourcesContent":["import { type KeyPath, NodeType } from '../types';\nimport type { ContentNode } from '../types/dictionary';\n\nexport const renameContentNodeByKeyPath = (\n  dictionaryContent: ContentNode,\n  newKey: KeyPath['key'],\n  keyPath: KeyPath[]\n): ContentNode => {\n  let currentValue: any = dictionaryContent;\n  let parentValue: any = null;\n  let lastKey: string | number | null = null;\n\n  for (const keyObj of keyPath) {\n    parentValue = currentValue;\n\n    if (keyObj.type === NodeType.Object || keyObj.type === NodeType.Array) {\n      lastKey = keyObj.key;\n      currentValue = currentValue[keyObj.key];\n    } else if (keyObj.type === NodeType.Translation) {\n      lastKey = NodeType.Translation;\n      currentValue = currentValue[NodeType.Translation][keyObj.key];\n    } else if (keyObj.type === NodeType.Enumeration) {\n      lastKey = NodeType.Enumeration;\n      currentValue = currentValue[NodeType.Enumeration][keyObj.key];\n    } else if (keyObj.type === NodeType.Condition) {\n      lastKey = NodeType.Condition;\n      currentValue = currentValue[NodeType.Condition];\n    } else if (keyObj.type === NodeType.Markdown) {\n      lastKey = NodeType.Markdown;\n      currentValue = currentValue[NodeType.Markdown];\n    } else if (keyObj.type === NodeType.ReactNode) {\n      lastKey = NodeType.ReactNode;\n      currentValue = currentValue[NodeType.ReactNode];\n    }\n  }\n\n  // Assign the new value to the last key of the parent while preserving the order\n  if (parentValue && lastKey !== null) {\n    if (Array.isArray(parentValue)) {\n      parentValue[lastKey as number] = currentValue;\n    } else {\n      const newParentValue: any = {};\n      for (const key of Object.keys(parentValue)) {\n        if (key === lastKey && typeof newKey !== 'undefined') {\n          newParentValue[newKey] = currentValue;\n        } else {\n          newParentValue[key] = parentValue[key];\n        }\n      }\n      // Replace the contents of parentValue with newParentValue\n      Object.keys(parentValue).forEach((key) => delete parentValue[key]);\n      Object.assign(parentValue, newParentValue);\n    }\n  }\n\n  return dictionaryContent;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAuC;AAGhC,MAAM,6BAA6B,CACxC,mBACA,QACA,YACgB;AAChB,MAAI,eAAoB;AACxB,MAAI,cAAmB;AACvB,MAAI,UAAkC;AAEtC,aAAW,UAAU,SAAS;AAC5B,kBAAc;AAEd,QAAI,OAAO,SAAS,sBAAS,UAAU,OAAO,SAAS,sBAAS,OAAO;AACrE,gBAAU,OAAO;AACjB,qBAAe,aAAa,OAAO,GAAG;AAAA,IACxC,WAAW,OAAO,SAAS,sBAAS,aAAa;AAC/C,gBAAU,sBAAS;AACnB,qBAAe,aAAa,sBAAS,WAAW,EAAE,OAAO,GAAG;AAAA,IAC9D,WAAW,OAAO,SAAS,sBAAS,aAAa;AAC/C,gBAAU,sBAAS;AACnB,qBAAe,aAAa,sBAAS,WAAW,EAAE,OAAO,GAAG;AAAA,IAC9D,WAAW,OAAO,SAAS,sBAAS,WAAW;AAC7C,gBAAU,sBAAS;AACnB,qBAAe,aAAa,sBAAS,SAAS;AAAA,IAChD,WAAW,OAAO,SAAS,sBAAS,UAAU;AAC5C,gBAAU,sBAAS;AACnB,qBAAe,aAAa,sBAAS,QAAQ;AAAA,IAC/C,WAAW,OAAO,SAAS,sBAAS,WAAW;AAC7C,gBAAU,sBAAS;AACnB,qBAAe,aAAa,sBAAS,SAAS;AAAA,IAChD;AAAA,EACF;AAGA,MAAI,eAAe,YAAY,MAAM;AACnC,QAAI,MAAM,QAAQ,WAAW,GAAG;AAC9B,kBAAY,OAAiB,IAAI;AAAA,IACnC,OAAO;AACL,YAAM,iBAAsB,CAAC;AAC7B,iBAAW,OAAO,OAAO,KAAK,WAAW,GAAG;AAC1C,YAAI,QAAQ,WAAW,OAAO,WAAW,aAAa;AACpD,yBAAe,MAAM,IAAI;AAAA,QAC3B,OAAO;AACL,yBAAe,GAAG,IAAI,YAAY,GAAG;AAAA,QACvC;AAAA,MACF;AAEA,aAAO,KAAK,WAAW,EAAE,QAAQ,CAAC,QAAQ,OAAO,YAAY,GAAG,CAAC;AACjE,aAAO,OAAO,aAAa,cAAc;AAAA,IAC3C;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/cjs/index.cjs

@@ -3,10 +3,6 @@ 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))
@@ -15,53 +11,27 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var index_exports = {};
-__export(index_exports, {
-  NodeType: () => import_types.NodeType,
-  enu: () => import_content_transformers.enu,
-  findMatchingCondition: () => import_content_transformers.findMatchingCondition,
-  getEnumerationContent: () => import_content_transformers.getEnumerationContent,
-  getHTMLTextDir: () => import_getHTMLTextDir.getHTMLTextDir,
-  getLocaleLang: () => import_getLocaleLang.getLocaleLang,
-  getLocaleName: () => import_getLocaleName.getLocaleName,
-  getLocalizedUrl: () => import_getLocalizedUrl.getLocalizedUrl,
-  getMultilingualUrls: () => import_getMultilingualUrls.getMultilingualUrls,
-  getPathWithoutLocale: () => import_getPathWithoutLocale.getPathWithoutLocale,
-  getTranslationContent: () => import_content_transformers.getTranslationContent,
-  isSameKeyPath: () => import_isSameKeyPath.isSameKeyPath,
-  localeDetector: () => import_localeDetector.localeDetector,
-  localeList: () => import_localeList.localeList,
-  t: () => import_content_transformers.t
-});
 module.exports = __toCommonJS(index_exports);
-var import_content_transformers = require('./transpiler/content_transformers/index.cjs');
-var import_types = require('./types/index.cjs');
-var import_getLocaleName = require('./getLocaleName.cjs');
-var import_getHTMLTextDir = require('./getHTMLTextDir.cjs');
-var import_getLocaleLang = require('./getLocaleLang.cjs');
-var import_localeList = require('./localeList.cjs');
-var import_isSameKeyPath = require('./utils/isSameKeyPath.cjs');
-var import_localeDetector = require('./localeDetector.cjs');
-var import_getPathWithoutLocale = require('./getPathWithoutLocale.cjs');
-var import_getMultilingualUrls = require('./getMultilingualUrls.cjs');
-var import_getLocalizedUrl = require('./getLocalizedUrl.cjs');
+__reExport(index_exports, require('./transpiler/index.cjs'), module.exports);
+__reExport(index_exports, require('./interpreter/index.cjs'), module.exports);
+__reExport(index_exports, require('./dictionaryManipulator/index.cjs'), module.exports);
+__reExport(index_exports, require('./types/index.cjs'), module.exports);
+__reExport(index_exports, require('./utils/isSameKeyPath.cjs'), module.exports);
+__reExport(index_exports, require('./utils/checkIsURLAbsolute.cjs'), module.exports);
+__reExport(index_exports, require('./utils/isValidReactElement.cjs'), module.exports);
+__reExport(index_exports, require('./localization/index.cjs'), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  NodeType,
-  enu,
-  findMatchingCondition,
-  getEnumerationContent,
-  getHTMLTextDir,
-  getLocaleLang,
-  getLocaleName,
-  getLocalizedUrl,
-  getMultilingualUrls,
-  getPathWithoutLocale,
-  getTranslationContent,
-  isSameKeyPath,
-  localeDetector,
-  localeList,
-  t
+  ...require('./transpiler/index.cjs'),
+  ...require('./interpreter/index.cjs'),
+  ...require('./dictionaryManipulator/index.cjs'),
+  ...require('./types/index.cjs'),
+  ...require('./utils/isSameKeyPath.cjs'),
+  ...require('./utils/checkIsURLAbsolute.cjs'),
+  ...require('./utils/isValidReactElement.cjs'),
+  ...require('./localization/index.cjs')
 });
 //# sourceMappingURL=index.cjs.map

package/dist/cjs/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["export type {\n  CustomizableLanguageContent,\n  LanguageContent,\n  TranslationContent,\n  EnumerationContent,\n  QuantityContent,\n  CustomLocales as Locales,\n} from './transpiler/content_transformers/index';\nexport {\n  t,\n  enu,\n  getTranslationContent,\n  findMatchingCondition,\n  getEnumerationContent,\n} from './transpiler/content_transformers/index';\nexport type {\n  ContentValue,\n  Content,\n  FlatContentValue,\n  FlatContent,\n  TypedNode,\n  DeclarationContent,\n  KeyPath,\n  ObjectNode,\n  ArrayNode,\n  RecursiveDictionaryValue,\n  TranslationNode,\n  EnumerationNode,\n  DictionaryValue,\n  Dictionary,\n} from './types/index';\nexport { NodeType } from './types/index';\nexport { getLocaleName } from './getLocaleName';\nexport { getHTMLTextDir } from './getHTMLTextDir';\nexport { getLocaleLang } from './getLocaleLang';\nexport { localeList } from './localeList';\nexport { isSameKeyPath } from './utils/isSameKeyPath';\nexport { localeDetector } from './localeDetector';\nexport { getPathWithoutLocale } from './getPathWithoutLocale';\nexport { getMultilingualUrls } from './getMultilingualUrls';\nexport { getLocalizedUrl } from './getLocalizedUrl';\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,kCAMO;AAiBP,mBAAyB;AACzB,2BAA8B;AAC9B,4BAA+B;AAC/B,2BAA8B;AAC9B,wBAA2B;AAC3B,2BAA8B;AAC9B,4BAA+B;AAC/B,kCAAqC;AACrC,iCAAoC;AACpC,6BAAgC;","names":[]}
+{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["export * from './transpiler/index';\nexport * from './interpreter/index';\nexport * from './dictionaryManipulator/index';\nexport * from './types/index';\nexport * from './utils/isSameKeyPath';\nexport * from './utils/checkIsURLAbsolute';\nexport * from './utils/isValidReactElement';\nexport * from './localization/index';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,0BAAc,+BAAd;AACA,0BAAc,gCADd;AAEA,0BAAc,0CAFd;AAGA,0BAAc,0BAHd;AAIA,0BAAc,kCAJd;AAKA,0BAAc,uCALd;AAMA,0BAAc,wCANd;AAOA,0BAAc,iCAPd;","names":[]}

package/dist/cjs/{transpiler/content_transformers/enumeration/getEnumerationContent.cjs → interpreter/getCondition.cjs}

@@ -16,18 +16,18 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var getEnumerationContent_exports = {};
-__export(getEnumerationContent_exports, {
-  getEnumerationContent: () => getEnumerationContent
+var getCondition_exports = {};
+__export(getCondition_exports, {
+  getCondition: () => getCondition
 });
-module.exports = __toCommonJS(getEnumerationContent_exports);
-var import_findMatchingCondition = require('./findMatchingCondition.cjs');
-const getEnumerationContent = (enumerationContent, quantity) => {
-  const key = (0, import_findMatchingCondition.findMatchingCondition)(enumerationContent, quantity);
-  return enumerationContent[key];
+module.exports = __toCommonJS(getCondition_exports);
+const getCondition = (conditionContent, state) => {
+  const stateList = Object.keys(conditionContent);
+  const fallbackState = stateList[stateList.length - 1];
+  return conditionContent[`${state}`] ?? conditionContent["fallback"] ?? conditionContent[fallbackState];
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  getEnumerationContent
+  getCondition
 });
-//# sourceMappingURL=getEnumerationContent.cjs.map
+//# sourceMappingURL=getCondition.cjs.map

package/dist/cjs/interpreter/getCondition.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/interpreter/getCondition.ts"],"sourcesContent":["import type { ConditionContentStates } from '../transpiler/condition/condition';\n\n/**\n * Allow to pick a content based on a condition.\n *\n * Usage:\n *\n * ```ts\n * const content = getCondition({\n *  'true': 'The condition is validated',\n *  'false': 'The condition is not validated',\n * }, true);\n * // 'The condition is validated'\n * ```\n *\n * The last key provided will be used as the fallback value.\n *\n * ```ts\n * const content = getCondition({\n *  'false': 'The condition is not validated',\n *  'true': 'The condition is validated',\n * }, undefined);\n * // 'The condition is validated'\n */\nexport const getCondition = <Content>(\n  conditionContent: ConditionContentStates<Content>,\n  state?: boolean\n): Content => {\n  const stateList = Object.keys(conditionContent);\n  const fallbackState = stateList[\n    stateList.length - 1\n  ] as keyof typeof conditionContent;\n\n  // Default or error handling if no keys match\n  return (\n    conditionContent[`${state}` as keyof typeof conditionContent] ??\n    conditionContent['fallback'] ??\n    (conditionContent[fallbackState] as Content)\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAwBO,MAAM,eAAe,CAC1B,kBACA,UACY;AACZ,QAAM,YAAY,OAAO,KAAK,gBAAgB;AAC9C,QAAM,gBAAgB,UACpB,UAAU,SAAS,CACrB;AAGA,SACE,iBAAiB,GAAG,KAAK,EAAmC,KAC5D,iBAAiB,UAAU,KAC1B,iBAAiB,aAAa;AAEnC;","names":[]}

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

@@ -0,0 +1,66 @@
+"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 deepTransform_exports = {};
+__export(deepTransform_exports, {
+  deepTransformNode: () => deepTransformNode
+});
+module.exports = __toCommonJS(deepTransform_exports);
+var import_types = require('../../types/index.cjs');
+const deepTransformNode = (node, props) => {
+  for (const plugin of props.plugins ?? []) {
+    if (plugin.canHandle(node)) {
+      return plugin.transform(
+        node,
+        props,
+        (node2, props2) => deepTransformNode(node2, props2)
+      );
+    }
+  }
+  if (node === null || typeof node !== "object") {
+    return node;
+  }
+  if (Array.isArray(node)) {
+    return node.map((child, index) => {
+      const childProps = {
+        ...props,
+        content: child,
+        keyPath: [
+          ...props.keyPath,
+          { type: import_types.NodeType.Array, key: index }
+        ]
+      };
+      return deepTransformNode(child, childProps);
+    });
+  }
+  const result = {};
+  for (const key in node) {
+    const childProps = {
+      ...props,
+      content: node[key],
+      keyPath: [...props.keyPath, { type: import_types.NodeType.Object, key }]
+    };
+    result[key] = deepTransformNode(node[key], childProps);
+  }
+  return result;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  deepTransformNode
+});
+//# sourceMappingURL=deepTransform.cjs.map

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

@@ -0,0 +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"]}