@intlayer/core 4.1.11 → 5.0.0

package/dist/cjs/transpiler/nesting/nesting.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/transpiler/nesting/nesting.ts"],"sourcesContent":["// @ts-ignore intlayer declared for module augmentation\nimport type { IntlayerDictionaryTypesConnector } from 'intlayer';\nimport type { DictionaryKeys } from '../../types/dictionary';\nimport { NodeType } from '../../types/index';\nimport type { DeepTransformContent } from '../../interpreter';\n\n/**\n * Recursively builds dot-notation strings for all valid paths in T.\n * Example:\n *   type X = { a: { b: { c: string }}, d: number };\n *   DotPath<X> = \"a\" | \"a.b\" | \"a.b.c\" | \"d\"\n */\nexport type DotPath<T> = T extends object\n  ? {\n      [K in keyof T & (string | number)]: T[K] extends object\n        ? // Either just K, or K + '.' + deeper path\n          `${K}` | `${K}.${DotPath<T[K]>}`\n        : `${K}`;\n    }[keyof T & (string | number)]\n  : never;\n\ntype DeepReplace<T, From, To> = T extends From\n  ? To\n  : T extends object\n    ? { [K in keyof T]: DeepReplace<T[K], From, To> }\n    : T;\n\n/** Build all valid dot-notation strings for a dictionary entry. */\nexport type ValidDotPathsFor<K extends DictionaryKeys> = DotPath<\n  DeepReplace<\n    DeepTransformContent<IntlayerDictionaryTypesConnector[K]['content']>,\n    // Replace ReactElement type with string\n    {\n      type: any;\n      props: any;\n      key: any;\n    },\n    string\n  >\n>;\n\nexport type NestedContentState<K extends DictionaryKeys> = {\n  dictionaryKey: K;\n\n  /**\n   * Path must match existing keys in IntlayerDictionaryTypesConnector[K].\n   * Can be either:\n   *  - \"dot.dot.dot\" format\n   */\n  path?: ValidDotPathsFor<K>;\n};\n\nexport type NestedContent<K extends DictionaryKeys = never> = {\n  nodeType: NodeType.Nested;\n  [NodeType.Nested]: NestedContentState<K>;\n};\n\n/**\n * Function intended to be used to build intlayer dictionaries.\n *\n * Allow to extract the content of another dictionary and nest it in the current dictionary.\n *\n * Usage:\n *\n * ```ts\n * nest(\"dictionaryKey\");\n * nest(\"dictionaryKey\", \"path.to.content\");\n * ```\n *\n * The order of the keys will define the priority of the content.\n *\n */\nconst nesting = <K extends DictionaryKeys>(\n  dictionaryKey: K,\n  path?: ValidDotPathsFor<K>\n): NestedContent<K> => ({\n  nodeType: NodeType.Nested,\n  [NodeType.Nested]: {\n    dictionaryKey,\n    path,\n  },\n});\n\nexport { nesting as nest };\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,mBAAyB;AAqEzB,MAAM,UAAU,CACd,eACA,UACsB;AAAA,EACtB,UAAU,sBAAS;AAAA,EACnB,CAAC,sBAAS,MAAM,GAAG;AAAA,IACjB;AAAA,IACA;AAAA,EACF;AACF;","names":[]}

package/dist/cjs/transpiler/{content_transformers/translation → translation}/index.cjs

@@ -16,12 +16,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var translation_exports = {};
 module.exports = __toCommonJS(translation_exports);
 __reExport(translation_exports, require('./translation.cjs'), module.exports);
-__reExport(translation_exports, require('./getTranslationContent.cjs'), module.exports);
 __reExport(translation_exports, require('./types.cjs'), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ...require('./translation.cjs'),
-  ...require('./getTranslationContent.cjs'),
   ...require('./types.cjs')
 });
 //# sourceMappingURL=index.cjs.map

package/dist/cjs/transpiler/translation/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/transpiler/translation/index.ts"],"sourcesContent":["export * from './translation';\nexport * from './types';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,gCAAc,0BAAd;AACA,gCAAc,oBADd;","names":[]}

package/dist/cjs/transpiler/translation/translation.cjs

@@ -0,0 +1,33 @@
+"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 translation_exports = {};
+__export(translation_exports, {
+  t: () => translation
+});
+module.exports = __toCommonJS(translation_exports);
+var import_types = require('../../types/index.cjs');
+const translation = (content) => ({
+  nodeType: import_types.NodeType.Translation,
+  [import_types.NodeType.Translation]: content
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  t
+});
+//# sourceMappingURL=translation.cjs.map

package/dist/cjs/transpiler/translation/translation.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/transpiler/translation/translation.ts"],"sourcesContent":["import { NodeType } from '../../types/index';\nimport type { LanguageContent, TranslationContent } from './types';\n\n/**\n *\n * Function intended to be used to build intlayer dictionaries.\n *\n * Get the content of a translation based on the locale.\n *\n * Usage:\n *\n * ```ts\n * translation<string>({\n *   \"en\": \"Hello\",\n *   \"fr\": \"Bonjour\",\n *   // ... any other available locale\n * })\n * ```\n *\n * Using TypeScript:\n * - this function require each locale to be defined if defined in the project configuration.\n * - If a locale is missing, it will make each existing locale optional and raise an error if the locale is not found.\n */\nconst translation = <Content = string>(content?: LanguageContent<Content>) =>\n  ({\n    nodeType: NodeType.Translation,\n    [NodeType.Translation]: content,\n  }) as TranslationContent<Content>;\n\nexport { translation as t };\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAyB;AAuBzB,MAAM,cAAc,CAAmB,aACpC;AAAA,EACC,UAAU,sBAAS;AAAA,EACnB,CAAC,sBAAS,WAAW,GAAG;AAC1B;","names":[]}

package/dist/cjs/{types/declarationContent.cjs → transpiler/translation/types.cjs}

@@ -12,6 +12,6 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var declarationContent_exports = {};
-module.exports = __toCommonJS(declarationContent_exports);
-//# sourceMappingURL=declarationContent.cjs.map
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);
+//# sourceMappingURL=types.cjs.map

package/dist/cjs/transpiler/translation/types.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/transpiler/translation/types.ts"],"sourcesContent":["/** @ts-nocheck */\n\nimport type { LocalesValues } from '@intlayer/config/client';\n// @ts-ignore intlayer declared for module augmentation\nimport type { IConfigLocales } from 'intlayer';\nimport type { NodeType } from '../../types/index';\n\n/**\n * If module augmented, it will return the configured locales such as Locales.ENGLISH | Locales.FRENCH | Locales.SPANISH | ...\n * If not, it will return never\n */\nexport type ConfigLocales = keyof IConfigLocales<unknown>;\n\n/**\n * If module augmented, it will return the configured locales such as Locales.ENGLISH | Locales.FRENCH | Locales.SPANISH | ...\n * If not, it will return all available locales such as Locales.ENGLISH | Locales.FRENCH | Locales.SPANISH | ...\n */\nexport type CustomLocales = ConfigLocales extends never\n  ? LocalesValues\n  : ConfigLocales;\n\n/**\n * Record of locales and content\n *\n * const myVar1: LanguageContent<string> = {\n *  \"en\": \"\",\n *  \"fr\": \"\"\n * }\n *\n * const myVar2: LanguageContent<{age: number, name: string}> = {\n *  \"en\": {age: 1, name: \"test\"},\n *  \"fr\": {age: 1, name: \"test\"}\n * }\n */\nexport type TranslationContentState<Content = unknown> = Partial<\n  Record<LocalesValues, Content>\n>;\n\n/**\n * Valid\n * const test: CustomizableLanguageContent<string, Locales.ENGLISH | Locales.FRENCH> = {\n *  \"en\": \"test\",\n *  \"fr\": \"test\"\n * }\n *\n * const test: CustomizableLanguageContent<number> = {\n *  \"fr\": 1,\n *  \"en\": 1,\n *  ... any other available locale\n * }\n *\n * Invalid\n *\n * const test: CustomizableLanguageContent<string> = {\n * \"en\": \"test\",\n * \"fr\": \"test\",\n * \"sss\": \"test\" // Does not exist in Locales\n * }\n *\n * const test: CustomizableLanguageContent<string, Locales.ENGLISH | Locales.FRENCH> = {\n *  \"fr\": \"test\"\n *  // Locales.ENGLISH is missing\n * }\n *\n */\nexport type LanguageContent<Content = string> = ConfigLocales extends never\n  ? IConfigLocales<Content>\n  : TranslationContentState<Content>;\n\nexport type TranslationContent<Content = unknown> = {\n  nodeType: NodeType.Translation;\n  [NodeType.Translation]: LanguageContent<Content>;\n};\n"],"mappings":";;;;;;;;;;;;;;AAAA;AAAA;","names":[]}

package/dist/cjs/types/dictionary.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/dictionary.ts"],"sourcesContent":["import type {\n  EnumerationContent,\n  TranslationContent,\n} from '../transpiler/index';\n\nexport type RecursiveDictionaryValue =\n  | number\n  | string\n  | undefined\n  | { [paramKey: string]: DictionaryValue };\n\nexport type DictionaryValue =\n  | RecursiveDictionaryValue\n  | TranslationContent<RecursiveDictionaryValue>\n  | EnumerationContent<RecursiveDictionaryValue>\n  | RecursiveDictionaryValue[];\n\nexport type Dictionary = {\n  $schema?: string;\n  key: string;\n  content: DictionaryValue;\n  title?: string;\n  description?: string;\n  filePath?: string;\n  publishedVersion?: string | null;\n};\n"],"mappings":";;;;;;;;;;;;;;AAAA;AAAA;","names":[]}
+{"version":3,"sources":["../../../src/types/dictionary.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n// @ts-ignore intlayer declared for module augmentation\nimport { IntlayerDictionaryTypesConnector } from 'intlayer';\nimport type {\n  ConditionContent,\n  EnumerationContent,\n  MarkdownContent,\n  NestedContent,\n  TranslationContent,\n} from '../transpiler/index';\n\n/**\n * Provides a fallback to string type if the generic type T is never,\n * otherwise returns T. This is useful for handling cases where no keys are found.\n * Example: StringFallback<never> -> string; StringFallback<'key'> -> 'key'\n */\nexport type StringFallback<T> = T extends never ? string : T; // If no keys are found, return string to disable error, and accept any string as dictionary key\n\n/**\n * Represents the keys of the IntlayerDictionaryTypesConnector,\n * ensuring they are valid dictionary keys or fallback to string if none exist.\n *\n * Example:\n * ```ts\n * DictionaryKeys -> 'key1' | 'key2'\n * // or if IntlayerDictionaryTypesConnector is not defined,\n * DictionaryKeys -> string\n * ```\n */\nexport type DictionaryKeys = StringFallback<\n  keyof IntlayerDictionaryTypesConnector\n>;\n\nexport type TypedNode<NodeType = never> =\n  | TranslationContent<NodeType>\n  | EnumerationContent<NodeType>\n  | ConditionContent<NodeType>\n  | MarkdownContent\n  | NestedContent<DictionaryKeys>;\n\nexport type BaseNode = string | number | bigint | boolean | null | undefined;\n\nexport type FetchableContentNode<NodeType = ContentNode> = (\n  args?: any\n) => ContentNode<NodeType> | Promise<ContentNode<NodeType>>;\n\nexport type ContentNode<NodeType = never, FetchableNode = false> =\n  | NodeType\n  | TypedNode<NodeType>\n  | { [paramKey: string | number]: ContentNode<NodeType[keyof NodeType]> }\n  | ((args?: any) => ContentNode<NodeType>)\n  | (FetchableNode extends true ? FetchableContentNode<NodeType> : never);\n\ntype IsArray<T> = T extends any[] ? true : false;\n\ntype ReplaceContentValueArray<T> = T extends (infer U)[]\n  ? ReplaceContentValue<U>[]\n  : ReplaceContentValue<T>;\n\n// Utility type that performs recursive replacement\ntype ReplaceContentValue<NodeType, FetchableNode = true> = {\n  [P in keyof NodeType]: IsArray<NodeType[P]> extends true\n    ? ReplaceContentValueArray<NodeType[P]>\n    : NodeType[P] extends object\n      ? ReplaceContentValue<NodeType[P]>\n      : ContentNode<NodeType[P], FetchableNode>;\n};\n\nexport type Dictionary<NodeType = undefined, FetchableNode = false> = {\n  $schema?: string;\n  key: string;\n  title?: string;\n  description?: string;\n  availableVersions?: string[];\n  version?: string;\n  filePath?: string;\n  tags?: string[];\n  content: NodeType extends undefined // Applying the generic to replace ContentValue with Replacement\n    ? ContentNode<any, FetchableNode>\n    : ReplaceContentValue<NodeType>;\n};\n"],"mappings":";;;;;;;;;;;;;;AAAA;AAAA;","names":[]}

package/dist/cjs/types/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,15 +11,17 @@ 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 types_exports = {};
-__export(types_exports, {
-  NodeType: () => import_nodeType.NodeType
-});
 module.exports = __toCommonJS(types_exports);
-var import_nodeType = require('./nodeType.cjs');
+__reExport(types_exports, require('./dictionary.cjs'), module.exports);
+__reExport(types_exports, require('./nodeType.cjs'), module.exports);
+__reExport(types_exports, require('./keyPath.cjs'), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  NodeType
+  ...require('./dictionary.cjs'),
+  ...require('./nodeType.cjs'),
+  ...require('./keyPath.cjs')
 });
 //# sourceMappingURL=index.cjs.map

package/dist/cjs/types/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/index.ts"],"sourcesContent":["export type {\n  ContentValue,\n  Content,\n  FlatContentValue,\n  FlatContent,\n  TypedNode,\n  DeclarationContent,\n} from './declarationContent';\nexport { NodeType } from './nodeType';\nexport type {\n  KeyPath,\n  ObjectNode,\n  ArrayNode,\n  TranslationNode,\n  EnumerationNode,\n} from './keyPath';\nexport type {\n  DictionaryValue,\n  Dictionary,\n  RecursiveDictionaryValue,\n} from './dictionary';\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,sBAAyB;","names":[]}
+{"version":3,"sources":["../../../src/types/index.ts"],"sourcesContent":["export * from './dictionary';\nexport * from './nodeType';\nexport * from './keyPath';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,0BAAc,yBAAd;AACA,0BAAc,uBADd;AAEA,0BAAc,sBAFd;","names":[]}

package/dist/cjs/types/keyPath.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/keyPath.ts"],"sourcesContent":["import type { NodeType } from './nodeType';\n\nexport type ObjectNode = {\n  type: NodeType.Object;\n  key: string;\n};\n\nexport type ArrayNode = {\n  type: NodeType.Array;\n  key: number;\n};\n\nexport type EnumerationNode = {\n  type: NodeType.Enumeration;\n  key: string;\n};\n\nexport type TranslationNode = {\n  type: NodeType.Translation;\n  key: string;\n};\n\nexport type KeyPath =\n  | ObjectNode\n  | ArrayNode\n  | TranslationNode\n  | EnumerationNode;\n"],"mappings":";;;;;;;;;;;;;;AAAA;AAAA;","names":[]}
+{"version":3,"sources":["../../../src/types/keyPath.ts"],"sourcesContent":["import type { NodeType } from './nodeType';\n\nexport type ObjectNode = {\n  type: NodeType.Object;\n  key: string;\n};\n\nexport type ArrayNode = {\n  type: NodeType.Array;\n  key: number;\n};\n\nexport type EnumerationNode = {\n  type: NodeType.Enumeration;\n  key: string;\n};\n\nexport type TranslationNode = {\n  type: NodeType.Translation;\n  key: string;\n};\n\nexport type ConditionNode = {\n  type: NodeType.Condition;\n  key: string;\n};\n\nexport type MarkdownNode = {\n  type: NodeType.Markdown;\n  key?: undefined;\n};\n\nexport type ReactNode = {\n  type: NodeType.ReactNode;\n  key?: undefined;\n};\n\nexport type NestedNode = {\n  type: NodeType.Nested;\n  key?: undefined;\n};\n\nexport type KeyPath =\n  | ObjectNode\n  | ArrayNode\n  | TranslationNode\n  | EnumerationNode\n  | MarkdownNode\n  | ReactNode\n  | ConditionNode\n  | NestedNode;\n"],"mappings":";;;;;;;;;;;;;;AAAA;AAAA;","names":[]}

package/dist/cjs/types/nodeType.cjs

@@ -24,10 +24,13 @@ module.exports = __toCommonJS(nodeType_exports);
 var NodeType = /* @__PURE__ */ ((NodeType2) => {
   NodeType2["Translation"] = "translation";
   NodeType2["Enumeration"] = "enumeration";
+  NodeType2["Condition"] = "condition";
   NodeType2["Object"] = "object";
   NodeType2["Array"] = "array";
   NodeType2["Text"] = "text";
+  NodeType2["Nested"] = "nested";
   NodeType2["ReactNode"] = "reactNode";
+  NodeType2["Markdown"] = "markdown";
   return NodeType2;
 })(NodeType || {});
 // Annotate the CommonJS export names for ESM import in node:

package/dist/cjs/types/nodeType.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/nodeType.ts"],"sourcesContent":["export enum NodeType {\n  Translation = 'translation',\n  Enumeration = 'enumeration',\n  Object = 'object',\n  Array = 'array',\n  Text = 'text',\n  ReactNode = 'reactNode',\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAO,IAAK,WAAL,kBAAKA,cAAL;AACL,EAAAA,UAAA,iBAAc;AACd,EAAAA,UAAA,iBAAc;AACd,EAAAA,UAAA,YAAS;AACT,EAAAA,UAAA,WAAQ;AACR,EAAAA,UAAA,UAAO;AACP,EAAAA,UAAA,eAAY;AANF,SAAAA;AAAA,GAAA;","names":["NodeType"]}
+{"version":3,"sources":["../../../src/types/nodeType.ts"],"sourcesContent":["export enum NodeType {\n  Translation = 'translation',\n  Enumeration = 'enumeration',\n  Condition = 'condition',\n  Object = 'object',\n  Array = 'array',\n  Text = 'text',\n  Nested = 'nested',\n  ReactNode = 'reactNode',\n  Markdown = 'markdown',\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAO,IAAK,WAAL,kBAAKA,cAAL;AACL,EAAAA,UAAA,iBAAc;AACd,EAAAA,UAAA,iBAAc;AACd,EAAAA,UAAA,eAAY;AACZ,EAAAA,UAAA,YAAS;AACT,EAAAA,UAAA,WAAQ;AACR,EAAAA,UAAA,UAAO;AACP,EAAAA,UAAA,YAAS;AACT,EAAAA,UAAA,eAAY;AACZ,EAAAA,UAAA,cAAW;AATD,SAAAA;AAAA,GAAA;","names":["NodeType"]}

package/dist/cjs/utils/checkIsURLAbsolute.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/checkIsURLAbsolute.ts"],"sourcesContent":["export const checkIsURLAbsolute = (url: string): boolean =>\n  /^[a-zA-Z][a-zA-Z\\d+\\-.]*:/.test(url);\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAO,MAAM,qBAAqB,CAAC,QACjC,4BAA4B,KAAK,GAAG;","names":[]}

package/dist/cjs/utils/isSameKeyPath.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/utils/isSameKeyPath.ts"],"sourcesContent":["import type { KeyPath } from '../types';\n\nexport const isSameKeyPath = (keyPath1: KeyPath[], keyPath2: KeyPath[]) =>\n  keyPath1.every(\n    (element, index) =>\n      keyPath2[index] &&\n      keyPath2[index].key === element.key &&\n      keyPath2[index].type === element.type\n  );\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEO,MAAM,gBAAgB,CAAC,UAAqB,aACjD,SAAS;AAAA,EACP,CAAC,SAAS,UACR,SAAS,KAAK,KACd,SAAS,KAAK,EAAE,QAAQ,QAAQ,OAChC,SAAS,KAAK,EAAE,SAAS,QAAQ;AACrC;","names":[]}
+{"version":3,"sources":["../../../src/utils/isSameKeyPath.ts"],"sourcesContent":["import type { KeyPath } from '../types';\n\ntype KeyPathWithKey = KeyPath & { key: string };\n\nexport const isSameKeyPath = (keyPath1: KeyPath[], keyPath2: KeyPath[]) =>\n  keyPath1.every(\n    (element, index) =>\n      keyPath2[index] &&\n      (keyPath2[index] as KeyPathWithKey).key ===\n        (element as KeyPathWithKey).key &&\n      keyPath2[index].type === element.type\n  );\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAIO,MAAM,gBAAgB,CAAC,UAAqB,aACjD,SAAS;AAAA,EACP,CAAC,SAAS,UACR,SAAS,KAAK,KACb,SAAS,KAAK,EAAqB,QACjC,QAA2B,OAC9B,SAAS,KAAK,EAAE,SAAS,QAAQ;AACrC;","names":[]}

package/dist/cjs/utils/isValidReactElement.cjs

@@ -0,0 +1,30 @@
+"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 isValidReactElement_exports = {};
+__export(isValidReactElement_exports, {
+  isValidElement: () => isValidElement
+});
+module.exports = __toCommonJS(isValidReactElement_exports);
+const REACT_ELEMENT_TYPE = Symbol.for("react.element");
+const isValidElement = (object) => typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isValidElement
+});
+//# sourceMappingURL=isValidReactElement.cjs.map

package/dist/cjs/utils/isValidReactElement.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/isValidReactElement.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nconst REACT_ELEMENT_TYPE = Symbol.for('react.element');\n\n/**\n * Verifies the object is a ReactElement.\n * See https://reactjs.org/docs/react-api.html#isvalidelement\n * @param object\n * @return True if `object` is a ReactElement.\n * @final\n */\n\nexport const isValidElement = (object: any): boolean =>\n  typeof object === 'object' &&\n  object !== null &&\n  object.$$typeof === REACT_ELEMENT_TYPE;\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,MAAM,qBAAqB,OAAO,IAAI,eAAe;AAU9C,MAAM,iBAAiB,CAAC,WAC7B,OAAO,WAAW,YAClB,WAAW,QACX,OAAO,aAAa;","names":[]}

package/dist/esm/dictionaryManipulator/editDictionaryByKeyPath.mjs

@@ -0,0 +1,73 @@
+import { NodeType } from "../types/index.mjs";
+const editDictionaryByKeyPath = (dictionaryContent, keyPath, newValue) => {
+  let currentValue = dictionaryContent;
+  let parentValue = null;
+  let lastKeys = [];
+  for (const keyObj of keyPath) {
+    parentValue = currentValue;
+    if (keyObj.type === NodeType.Object) {
+      lastKeys = [keyObj.key];
+      if (!currentValue[keyObj.key]) {
+        currentValue = {
+          ...currentValue,
+          [keyObj.key]: {}
+        };
+      }
+      currentValue = currentValue[keyObj.key];
+    } else if (keyObj.type === NodeType.Array) {
+      lastKeys = [keyObj.key];
+      if (!currentValue[keyObj.key]) {
+        currentValue[keyObj.key] = {};
+      }
+      currentValue = currentValue[keyObj.key];
+    } else if (keyObj.type === NodeType.Translation) {
+      lastKeys = [NodeType.Translation, keyObj.key];
+      if (!currentValue[NodeType.Translation]) {
+        currentValue[NodeType.Translation] = {
+          ...currentValue[NodeType.Translation],
+          [keyObj.key]: newValue
+        };
+      }
+      currentValue = currentValue[NodeType.Translation][keyObj.key];
+    } else if (keyObj.type === NodeType.Enumeration) {
+      lastKeys = [NodeType.Enumeration, keyObj.key];
+      if (!currentValue[NodeType.Enumeration]) {
+        currentValue[NodeType.Enumeration] = {
+          ...currentValue[NodeType.Enumeration],
+          [keyObj.key]: newValue
+        };
+      }
+      currentValue = currentValue[NodeType.Enumeration][keyObj.key];
+    } else if (keyObj.type === NodeType.Markdown) {
+      lastKeys = [NodeType.Markdown];
+      if (!currentValue[NodeType.Markdown]) {
+        currentValue[NodeType.Markdown] = newValue;
+      }
+      currentValue = currentValue[NodeType.Markdown];
+    } else if (keyObj.type === NodeType.Nested) {
+      lastKeys = [NodeType.Nested];
+      if (!currentValue[NodeType.Nested]) {
+        currentValue[NodeType.Nested] = newValue;
+      }
+      currentValue = currentValue[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;
+};
+export {
+  editDictionaryByKeyPath
+};
+//# sourceMappingURL=editDictionaryByKeyPath.mjs.map

package/dist/esm/dictionaryManipulator/editDictionaryByKeyPath.mjs.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":"AACA,SAAuB,gBAAgB;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,SAAS,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,SAAS,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,SAAS,aAAa;AAC/C,iBAAW,CAAC,SAAS,aAAa,OAAO,GAAG;AAE5C,UAAI,CAAC,aAAa,SAAS,WAAW,GAAG;AACvC,qBAAa,SAAS,WAAW,IAAI;AAAA,UACnC,GAAG,aAAa,SAAS,WAAW;AAAA,UACpC,CAAC,OAAO,GAAG,GAAG;AAAA,QAChB;AAAA,MACF;AACA,qBAAe,aAAa,SAAS,WAAW,EAAE,OAAO,GAAG;AAAA,IAC9D,WAAW,OAAO,SAAS,SAAS,aAAa;AAC/C,iBAAW,CAAC,SAAS,aAAa,OAAO,GAAG;AAE5C,UAAI,CAAC,aAAa,SAAS,WAAW,GAAG;AACvC,qBAAa,SAAS,WAAW,IAAI;AAAA,UACnC,GAAG,aAAa,SAAS,WAAW;AAAA,UACpC,CAAC,OAAO,GAAG,GAAG;AAAA,QAChB;AAAA,MACF;AACA,qBAAe,aAAa,SAAS,WAAW,EAAE,OAAO,GAAG;AAAA,IAC9D,WAAW,OAAO,SAAS,SAAS,UAAU;AAC5C,iBAAW,CAAC,SAAS,QAAQ;AAC7B,UAAI,CAAC,aAAa,SAAS,QAAQ,GAAG;AACpC,qBAAa,SAAS,QAAQ,IAAI;AAAA,MACpC;AACA,qBAAe,aAAa,SAAS,QAAQ;AAAA,IAC/C,WAAW,OAAO,SAAS,SAAS,QAAQ;AAC1C,iBAAW,CAAC,SAAS,MAAM;AAC3B,UAAI,CAAC,aAAa,SAAS,MAAM,GAAG;AAClC,qBAAa,SAAS,MAAM,IAAI;AAAA,MAClC;AACA,qBAAe,aAAa,SAAS,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/esm/dictionaryManipulator/getContentNodeByKeyPath.mjs

@@ -0,0 +1,22 @@
+import { NodeType } from "../types/index.mjs";
+const getContentNodeByKeyPath = (dictionaryContent, keyPath) => {
+  let currentValue = JSON.parse(JSON.stringify(dictionaryContent ?? {}));
+  for (const keyObj of keyPath) {
+    if (keyObj.type === NodeType.Object || keyObj.type === NodeType.Array) {
+      currentValue = currentValue?.[keyObj.key];
+    } else if (keyObj.type === NodeType.Translation) {
+      currentValue = currentValue?.[NodeType.Translation][keyObj.key];
+    } else if (keyObj.type === NodeType.Enumeration) {
+      currentValue = currentValue?.[NodeType.Enumeration][keyObj.key];
+    } else if (keyObj.type === NodeType.Condition) {
+      currentValue = currentValue[NodeType.Condition];
+    } else if (keyObj.type === NodeType.Markdown) {
+      currentValue = currentValue[NodeType.Markdown];
+    }
+  }
+  return currentValue;
+};
+export {
+  getContentNodeByKeyPath
+};
+//# sourceMappingURL=getContentNodeByKeyPath.mjs.map

package/dist/esm/dictionaryManipulator/getContentNodeByKeyPath.mjs.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,SAAuB,gBAAgB;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,SAAS,UAAU,OAAO,SAAS,SAAS,OAAO;AACrE,qBAAe,eAAe,OAAO,GAAG;AAAA,IAC1C,WAAW,OAAO,SAAS,SAAS,aAAa;AAC/C,qBAAe,eAAe,SAAS,WAAW,EAAE,OAAO,GAAG;AAAA,IAChE,WAAW,OAAO,SAAS,SAAS,aAAa;AAC/C,qBAAe,eAAe,SAAS,WAAW,EAAE,OAAO,GAAG;AAAA,IAChE,WAAW,OAAO,SAAS,SAAS,WAAW;AAC7C,qBAAe,aAAa,SAAS,SAAS;AAAA,IAChD,WAAW,OAAO,SAAS,SAAS,UAAU;AAC5C,qBAAe,aAAa,SAAS,QAAQ;AAAA,IAC/C;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/esm/dictionaryManipulator/getSectionType.mjs

@@ -0,0 +1,33 @@
+import { NodeType } from "../types/index.mjs";
+import { isValidElement } from "../utils/isValidReactElement.mjs";
+const getSectionType = (section) => {
+  if (typeof section === "string") {
+    return NodeType.Text;
+  }
+  if (section?.nodeType === NodeType.Translation) {
+    return NodeType.Translation;
+  }
+  if (section?.nodeType === NodeType.Enumeration) {
+    return NodeType.Enumeration;
+  }
+  if (section?.nodeType === NodeType.Condition) {
+    return NodeType.Condition;
+  }
+  if (section?.nodeType === NodeType.Markdown) {
+    return NodeType.Markdown;
+  }
+  if (section?.nodeType === NodeType.Nested) {
+    return NodeType.Nested;
+  }
+  if (Array.isArray(section)) {
+    return NodeType.Array;
+  }
+  if (isValidElement(section)) {
+    return NodeType.ReactNode;
+  }
+  return NodeType.Object;
+};
+export {
+  getSectionType
+};
+//# sourceMappingURL=getSectionType.mjs.map

package/dist/esm/dictionaryManipulator/getSectionType.mjs.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":"AAOA,SAAS,gBAAqC;AAE9C,SAAS,sBAAsB;AAExB,MAAM,iBAAiB,CAAC,YAAmC;AAChE,MAAI,OAAO,YAAY,UAAU;AAC/B,WAAO,SAAS;AAAA,EAClB;AAEA,MACG,SAAyC,aAAa,SAAS,aAChE;AACA,WAAO,SAAS;AAAA,EAClB;AAEA,MACG,SAAyC,aAAa,SAAS,aAChE;AACA,WAAO,SAAS;AAAA,EAClB;AAEA,MAAK,SAAuC,aAAa,SAAS,WAAW;AAC3E,WAAO,SAAS;AAAA,EAClB;AAEA,MAAK,SAA6B,aAAa,SAAS,UAAU;AAChE,WAAO,SAAS;AAAA,EAClB;AAEA,MACG,SAA2C,aAAa,SAAS,QAClE;AACA,WAAO,SAAS;AAAA,EAClB;AAEA,MAAI,MAAM,QAAQ,OAAO,GAAG;AAC1B,WAAO,SAAS;AAAA,EAClB;AAEA,MAAI,eAAe,OAAO,GAAG;AAC3B,WAAO,SAAS;AAAA,EAClB;AAEA,SAAO,SAAS;AAClB;","names":[]}

package/dist/esm/dictionaryManipulator/index.mjs

@@ -0,0 +1,6 @@
+export * from "./editDictionaryByKeyPath.mjs";
+export * from "./getContentNodeByKeyPath.mjs";
+export * from "./getSectionType.mjs";
+export * from "./removeContentNodeByKeyPath.mjs";
+export * from "./renameContentNodeByKeyPath.mjs";
+//# sourceMappingURL=index.mjs.map

package/dist/esm/dictionaryManipulator/index.mjs.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,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;","names":[]}

package/dist/esm/dictionaryManipulator/removeContentNodeByKeyPath.mjs

@@ -0,0 +1,40 @@
+import { NodeType } from "../types/index.mjs";
+const removeContentNodeByKeyPath = (dictionaryContent, keyPath) => {
+  let currentValue = dictionaryContent;
+  let parentValue = null;
+  let lastKey = null;
+  for (const keyObj of keyPath) {
+    parentValue = currentValue;
+    if (keyObj.type === NodeType.Object || keyObj.type === NodeType.Array) {
+      lastKey = keyObj.key;
+      currentValue = currentValue[keyObj.key];
+    } else if (keyObj.type === NodeType.Translation) {
+      lastKey = NodeType.Translation;
+      currentValue = currentValue[NodeType.Translation][keyObj.key];
+    } else if (keyObj.type === NodeType.Enumeration) {
+      lastKey = NodeType.Enumeration;
+      currentValue = currentValue[NodeType.Enumeration][keyObj.key];
+    } else if (keyObj.type === NodeType.Condition) {
+      lastKey = NodeType.Condition;
+      currentValue = currentValue[NodeType.Condition];
+    } else if (keyObj.type === NodeType.Markdown) {
+      lastKey = NodeType.Markdown;
+      currentValue = currentValue[NodeType.Markdown];
+    } else if (keyObj.type === NodeType.ReactNode) {
+      lastKey = NodeType.ReactNode;
+      currentValue = currentValue[NodeType.ReactNode];
+    }
+  }
+  if (parentValue && lastKey !== null) {
+    if (Array.isArray(parentValue)) {
+      parentValue.splice(lastKey, 1);
+    } else {
+      delete parentValue[lastKey];
+    }
+  }
+  return dictionaryContent;
+};
+export {
+  removeContentNodeByKeyPath
+};
+//# sourceMappingURL=removeContentNodeByKeyPath.mjs.map

package/dist/esm/dictionaryManipulator/removeContentNodeByKeyPath.mjs.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,SAAuB,gBAAgB;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,SAAS,UAAU,OAAO,SAAS,SAAS,OAAO;AACrE,gBAAU,OAAO;AACjB,qBAAe,aAAa,OAAO,GAAG;AAAA,IACxC,WAAW,OAAO,SAAS,SAAS,aAAa;AAC/C,gBAAU,SAAS;AACnB,qBAAe,aAAa,SAAS,WAAW,EAAE,OAAO,GAAG;AAAA,IAC9D,WAAW,OAAO,SAAS,SAAS,aAAa;AAC/C,gBAAU,SAAS;AACnB,qBAAe,aAAa,SAAS,WAAW,EAAE,OAAO,GAAG;AAAA,IAC9D,WAAW,OAAO,SAAS,SAAS,WAAW;AAC7C,gBAAU,SAAS;AACnB,qBAAe,aAAa,SAAS,SAAS;AAAA,IAChD,WAAW,OAAO,SAAS,SAAS,UAAU;AAC5C,gBAAU,SAAS;AACnB,qBAAe,aAAa,SAAS,QAAQ;AAAA,IAC/C,WAAW,OAAO,SAAS,SAAS,WAAW;AAC7C,gBAAU,SAAS;AACnB,qBAAe,aAAa,SAAS,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/esm/dictionaryManipulator/renameContentNodeByKeyPath.mjs

@@ -0,0 +1,49 @@
+import { NodeType } from "../types/index.mjs";
+const renameContentNodeByKeyPath = (dictionaryContent, newKey, keyPath) => {
+  let currentValue = dictionaryContent;
+  let parentValue = null;
+  let lastKey = null;
+  for (const keyObj of keyPath) {
+    parentValue = currentValue;
+    if (keyObj.type === NodeType.Object || keyObj.type === NodeType.Array) {
+      lastKey = keyObj.key;
+      currentValue = currentValue[keyObj.key];
+    } else if (keyObj.type === NodeType.Translation) {
+      lastKey = NodeType.Translation;
+      currentValue = currentValue[NodeType.Translation][keyObj.key];
+    } else if (keyObj.type === NodeType.Enumeration) {
+      lastKey = NodeType.Enumeration;
+      currentValue = currentValue[NodeType.Enumeration][keyObj.key];
+    } else if (keyObj.type === NodeType.Condition) {
+      lastKey = NodeType.Condition;
+      currentValue = currentValue[NodeType.Condition];
+    } else if (keyObj.type === NodeType.Markdown) {
+      lastKey = NodeType.Markdown;
+      currentValue = currentValue[NodeType.Markdown];
+    } else if (keyObj.type === NodeType.ReactNode) {
+      lastKey = NodeType.ReactNode;
+      currentValue = currentValue[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;
+};
+export {
+  renameContentNodeByKeyPath
+};
+//# sourceMappingURL=renameContentNodeByKeyPath.mjs.map

package/dist/esm/dictionaryManipulator/renameContentNodeByKeyPath.mjs.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,SAAuB,gBAAgB;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,SAAS,UAAU,OAAO,SAAS,SAAS,OAAO;AACrE,gBAAU,OAAO;AACjB,qBAAe,aAAa,OAAO,GAAG;AAAA,IACxC,WAAW,OAAO,SAAS,SAAS,aAAa;AAC/C,gBAAU,SAAS;AACnB,qBAAe,aAAa,SAAS,WAAW,EAAE,OAAO,GAAG;AAAA,IAC9D,WAAW,OAAO,SAAS,SAAS,aAAa;AAC/C,gBAAU,SAAS;AACnB,qBAAe,aAAa,SAAS,WAAW,EAAE,OAAO,GAAG;AAAA,IAC9D,WAAW,OAAO,SAAS,SAAS,WAAW;AAC7C,gBAAU,SAAS;AACnB,qBAAe,aAAa,SAAS,SAAS;AAAA,IAChD,WAAW,OAAO,SAAS,SAAS,UAAU;AAC5C,gBAAU,SAAS;AACnB,qBAAe,aAAa,SAAS,QAAQ;AAAA,IAC/C,WAAW,OAAO,SAAS,SAAS,WAAW;AAC7C,gBAAU,SAAS;AACnB,qBAAe,aAAa,SAAS,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/esm/index.mjs

@@ -1,35 +1,9 @@
-import {
-  t,
-  enu,
-  getTranslationContent,
-  findMatchingCondition,
-  getEnumerationContent
-} from "./transpiler/content_transformers/index.mjs";
-import { NodeType } from "./types/index.mjs";
-import { getLocaleName } from "./getLocaleName.mjs";
-import { getHTMLTextDir } from "./getHTMLTextDir.mjs";
-import { getLocaleLang } from "./getLocaleLang.mjs";
-import { localeList } from "./localeList.mjs";
-import { isSameKeyPath } from "./utils/isSameKeyPath.mjs";
-import { localeDetector } from "./localeDetector.mjs";
-import { getPathWithoutLocale } from "./getPathWithoutLocale.mjs";
-import { getMultilingualUrls } from "./getMultilingualUrls.mjs";
-import { getLocalizedUrl } from "./getLocalizedUrl.mjs";
-export {
-  NodeType,
-  enu,
-  findMatchingCondition,
-  getEnumerationContent,
-  getHTMLTextDir,
-  getLocaleLang,
-  getLocaleName,
-  getLocalizedUrl,
-  getMultilingualUrls,
-  getPathWithoutLocale,
-  getTranslationContent,
-  isSameKeyPath,
-  localeDetector,
-  localeList,
-  t
-};
+export * from "./transpiler/index.mjs";
+export * from "./interpreter/index.mjs";
+export * from "./dictionaryManipulator/index.mjs";
+export * from "./types/index.mjs";
+export * from "./utils/isSameKeyPath.mjs";
+export * from "./utils/checkIsURLAbsolute.mjs";
+export * from "./utils/isValidReactElement.mjs";
+export * from "./localization/index.mjs";
 //# sourceMappingURL=index.mjs.map

package/dist/esm/index.mjs.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":"AAQA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAiBP,SAAS,gBAAgB;AACzB,SAAS,qBAAqB;AAC9B,SAAS,sBAAsB;AAC/B,SAAS,qBAAqB;AAC9B,SAAS,kBAAkB;AAC3B,SAAS,qBAAqB;AAC9B,SAAS,sBAAsB;AAC/B,SAAS,4BAA4B;AACrC,SAAS,2BAA2B;AACpC,SAAS,uBAAuB;","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,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;","names":[]}

package/dist/esm/interpreter/getCondition.mjs

@@ -0,0 +1,9 @@
+const getCondition = (conditionContent, state) => {
+  const stateList = Object.keys(conditionContent);
+  const fallbackState = stateList[stateList.length - 1];
+  return conditionContent[`${state}`] ?? conditionContent["fallback"] ?? conditionContent[fallbackState];
+};
+export {
+  getCondition
+};
+//# sourceMappingURL=getCondition.mjs.map

package/dist/esm/interpreter/getCondition.mjs.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":"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/esm/interpreter/getContent/deepTransform.mjs

@@ -0,0 +1,42 @@
+import { NodeType } from "../../types/index.mjs";
+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: 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: NodeType.Object, key }]
+    };
+    result[key] = deepTransformNode(node[key], childProps);
+  }
+  return result;
+};
+export {
+  deepTransformNode
+};
+//# sourceMappingURL=deepTransform.mjs.map

package/dist/esm/interpreter/getContent/deepTransform.mjs.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":"AACA,SAAuB,gBAAgB;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,SAAS,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,SAAS,QAAQ,IAAI,CAAY;AAAA,IACvE;AACA,WAAO,GAAG,IAAI,kBAAkB,KAAK,GAAG,GAAG,UAAU;AAAA,EACvD;AAEA,SAAO;AACT;","names":["node","props"]}