@intlayer/core 6.1.6 → 7.0.0-canary.0

package/dist/cjs/dictionaryManipulator/getEmptyNode.cjs

@@ -1,71 +1,27 @@
-"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 getEmptyNode_exports = {};
-__export(getEmptyNode_exports, {
-  getEmptyNode: () => getEmptyNode
-});
-module.exports = __toCommonJS(getEmptyNode_exports);
-var import_types = require('../types/index.cjs');
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+let __intlayer_types = require("@intlayer/types");
+__intlayer_types = require_rolldown_runtime.__toESM(__intlayer_types);
+
+//#region src/dictionaryManipulator/getEmptyNode.ts
 const getEmptyNode = (section) => {
-  if (typeof section === "string") {
-    return "";
-  }
-  if (typeof section === "number") {
-    return 0;
-  }
-  if (typeof section === "boolean") {
-    return true;
-  }
-  if (typeof section?.nodeType === "string") {
-    const typedNode = section;
-    const content = typedNode[typedNode.nodeType];
-    if (typedNode.nodeType === import_types.NodeType.Translation || typedNode.nodeType === import_types.NodeType.Enumeration || typedNode.nodeType === import_types.NodeType.Condition || typedNode.nodeType === import_types.NodeType.Insertion) {
-      return getEmptyNode(content);
-    }
-    if (typedNode.nodeType === import_types.NodeType.Nested) {
-      return "dictionary-key";
-    }
-    if (typedNode.nodeType === import_types.NodeType.File) {
-      return "file/path";
-    }
-    if (typedNode.nodeType === import_types.NodeType.Markdown) {
-      return getEmptyNode(typedNode);
-    }
-    return content;
-  }
-  if (!section || typeof section !== "object") {
-    return section;
-  }
-  if (Array.isArray(section)) {
-    return section.map(
-      getEmptyNode
-    );
-  }
-  const mappedSectionObject = Object.entries(section).map(([key, value]) => [
-    key,
-    getEmptyNode(value)
-  ]);
-  const mappedSectionArray = Object.fromEntries(mappedSectionObject);
-  return mappedSectionArray;
+	if (typeof section === "string") return "";
+	if (typeof section === "number") return 0;
+	if (typeof section === "boolean") return true;
+	if (typeof section?.nodeType === "string") {
+		const typedNode = section;
+		const content = typedNode[typedNode.nodeType];
+		if (typedNode.nodeType === __intlayer_types.NodeType.Translation || typedNode.nodeType === __intlayer_types.NodeType.Enumeration || typedNode.nodeType === __intlayer_types.NodeType.Condition || typedNode.nodeType === __intlayer_types.NodeType.Insertion) return getEmptyNode(content);
+		if (typedNode.nodeType === __intlayer_types.NodeType.Nested) return "dictionary-key";
+		if (typedNode.nodeType === __intlayer_types.NodeType.File) return "file/path";
+		if (typedNode.nodeType === __intlayer_types.NodeType.Markdown) return getEmptyNode(typedNode);
+		return content;
+	}
+	if (!section || typeof section !== "object") return section;
+	if (Array.isArray(section)) return section.map(getEmptyNode);
+	const mappedSectionObject = Object.entries(section).map(([key, value]) => [key, getEmptyNode(value)]);
+	return Object.fromEntries(mappedSectionObject);
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  getEmptyNode
-});
+
+//#endregion
+exports.getEmptyNode = getEmptyNode;
 //# sourceMappingURL=getEmptyNode.cjs.map

package/dist/cjs/dictionaryManipulator/getEmptyNode.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/dictionaryManipulator/getEmptyNode.ts"],"sourcesContent":["import { type ContentNode, type TypedNode, NodeType } from '../types';\n\nexport const getEmptyNode = (section: ContentNode): ContentNode => {\n  if (typeof section === 'string') {\n    return '';\n  }\n  if (typeof section === 'number') {\n    return 0;\n  }\n  if (typeof section === 'boolean') {\n    return true;\n  }\n  if (typeof (section as TypedNode)?.nodeType === 'string') {\n    const typedNode = section as TypedNode;\n    const content = typedNode[typedNode.nodeType as keyof TypedNode];\n\n    if (\n      typedNode.nodeType === NodeType.Translation ||\n      typedNode.nodeType === NodeType.Enumeration ||\n      typedNode.nodeType === NodeType.Condition ||\n      typedNode.nodeType === NodeType.Insertion\n    ) {\n      return getEmptyNode(content as ContentNode);\n    }\n\n    if (typedNode.nodeType === NodeType.Nested) {\n      return 'dictionary-key';\n    }\n\n    if (typedNode.nodeType === NodeType.File) {\n      return 'file/path';\n    }\n\n    if (typedNode.nodeType === NodeType.Markdown) {\n      return getEmptyNode(typedNode);\n    }\n\n    return content;\n  }\n\n  if (!section || typeof section !== 'object') {\n    return section;\n  }\n\n  if (Array.isArray(section)) {\n    return (section as ContentNode[]).map(\n      getEmptyNode\n    ) as unknown as ContentNode;\n  }\n\n  const mappedSectionObject = Object.entries(section).map(([key, value]) => [\n    key,\n    getEmptyNode(value as ContentNode),\n  ]);\n\n  const mappedSectionArray = Object.fromEntries(mappedSectionObject);\n\n  return mappedSectionArray;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAA2D;AAEpD,MAAM,eAAe,CAAC,YAAsC;AACjE,MAAI,OAAO,YAAY,UAAU;AAC/B,WAAO;AAAA,EACT;AACA,MAAI,OAAO,YAAY,UAAU;AAC/B,WAAO;AAAA,EACT;AACA,MAAI,OAAO,YAAY,WAAW;AAChC,WAAO;AAAA,EACT;AACA,MAAI,OAAQ,SAAuB,aAAa,UAAU;AACxD,UAAM,YAAY;AAClB,UAAM,UAAU,UAAU,UAAU,QAA2B;AAE/D,QACE,UAAU,aAAa,sBAAS,eAChC,UAAU,aAAa,sBAAS,eAChC,UAAU,aAAa,sBAAS,aAChC,UAAU,aAAa,sBAAS,WAChC;AACA,aAAO,aAAa,OAAsB;AAAA,IAC5C;AAEA,QAAI,UAAU,aAAa,sBAAS,QAAQ;AAC1C,aAAO;AAAA,IACT;AAEA,QAAI,UAAU,aAAa,sBAAS,MAAM;AACxC,aAAO;AAAA,IACT;AAEA,QAAI,UAAU,aAAa,sBAAS,UAAU;AAC5C,aAAO,aAAa,SAAS;AAAA,IAC/B;AAEA,WAAO;AAAA,EACT;AAEA,MAAI,CAAC,WAAW,OAAO,YAAY,UAAU;AAC3C,WAAO;AAAA,EACT;AAEA,MAAI,MAAM,QAAQ,OAAO,GAAG;AAC1B,WAAQ,QAA0B;AAAA,MAChC;AAAA,IACF;AAAA,EACF;AAEA,QAAM,sBAAsB,OAAO,QAAQ,OAAO,EAAE,IAAI,CAAC,CAAC,KAAK,KAAK,MAAM;AAAA,IACxE;AAAA,IACA,aAAa,KAAoB;AAAA,EACnC,CAAC;AAED,QAAM,qBAAqB,OAAO,YAAY,mBAAmB;AAEjE,SAAO;AACT;","names":[]}
+{"version":3,"file":"getEmptyNode.cjs","names":["NodeType"],"sources":["../../../src/dictionaryManipulator/getEmptyNode.ts"],"sourcesContent":["import { type ContentNode, NodeType, type TypedNode } from '@intlayer/types';\n\nexport const getEmptyNode = (section: ContentNode): ContentNode => {\n  if (typeof section === 'string') {\n    return '';\n  }\n  if (typeof section === 'number') {\n    return 0;\n  }\n  if (typeof section === 'boolean') {\n    return true;\n  }\n  if (typeof (section as TypedNode)?.nodeType === 'string') {\n    const typedNode = section as TypedNode;\n    const content =\n      typedNode[typedNode.nodeType as unknown as keyof typeof typedNode];\n\n    if (\n      typedNode.nodeType === NodeType.Translation ||\n      typedNode.nodeType === NodeType.Enumeration ||\n      typedNode.nodeType === NodeType.Condition ||\n      typedNode.nodeType === NodeType.Insertion\n    ) {\n      return getEmptyNode(content as ContentNode);\n    }\n\n    if (typedNode.nodeType === NodeType.Nested) {\n      return 'dictionary-key';\n    }\n\n    if (typedNode.nodeType === NodeType.File) {\n      return 'file/path';\n    }\n\n    if (typedNode.nodeType === NodeType.Markdown) {\n      return getEmptyNode(typedNode);\n    }\n\n    return content;\n  }\n\n  if (!section || typeof section !== 'object') {\n    return section;\n  }\n\n  if (Array.isArray(section)) {\n    return (section as ContentNode[]).map(\n      getEmptyNode\n    ) as unknown as ContentNode;\n  }\n\n  const mappedSectionObject = Object.entries(section).map(([key, value]) => [\n    key,\n    getEmptyNode(value as ContentNode),\n  ]);\n\n  const mappedSectionArray = Object.fromEntries(mappedSectionObject);\n\n  return mappedSectionArray;\n};\n"],"mappings":";;;;;AAEA,MAAa,gBAAgB,YAAsC;AACjE,KAAI,OAAO,YAAY,SACrB,QAAO;AAET,KAAI,OAAO,YAAY,SACrB,QAAO;AAET,KAAI,OAAO,YAAY,UACrB,QAAO;AAET,KAAI,OAAQ,SAAuB,aAAa,UAAU;EACxD,MAAM,YAAY;EAClB,MAAM,UACJ,UAAU,UAAU;AAEtB,MACE,UAAU,aAAaA,0BAAS,eAChC,UAAU,aAAaA,0BAAS,eAChC,UAAU,aAAaA,0BAAS,aAChC,UAAU,aAAaA,0BAAS,UAEhC,QAAO,aAAa,QAAuB;AAG7C,MAAI,UAAU,aAAaA,0BAAS,OAClC,QAAO;AAGT,MAAI,UAAU,aAAaA,0BAAS,KAClC,QAAO;AAGT,MAAI,UAAU,aAAaA,0BAAS,SAClC,QAAO,aAAa,UAAU;AAGhC,SAAO;;AAGT,KAAI,CAAC,WAAW,OAAO,YAAY,SACjC,QAAO;AAGT,KAAI,MAAM,QAAQ,QAAQ,CACxB,QAAQ,QAA0B,IAChC,aACD;CAGH,MAAM,sBAAsB,OAAO,QAAQ,QAAQ,CAAC,KAAK,CAAC,KAAK,WAAW,CACxE,KACA,aAAa,MAAqB,CACnC,CAAC;AAIF,QAF2B,OAAO,YAAY,oBAAoB"}

package/dist/cjs/dictionaryManipulator/getNodeChildren.cjs

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

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/dictionaryManipulator/getNodeChildren.ts"],"sourcesContent":["import { type ContentNode, type TypedNode, NodeType } from '../types';\n\nexport const getNodeChildren = (section: ContentNode): ContentNode => {\n  if (typeof section === 'string') {\n    return section;\n  }\n  if (typeof section === 'number') {\n    return section;\n  }\n  if (typeof section === 'boolean') {\n    return section;\n  }\n  if (typeof (section as TypedNode)?.nodeType === 'string') {\n    const typedNode = section as TypedNode;\n    const content = typedNode[typedNode.nodeType as keyof TypedNode];\n\n    if (\n      typedNode.nodeType === NodeType.Translation ||\n      typedNode.nodeType === NodeType.Enumeration ||\n      typedNode.nodeType === NodeType.Condition ||\n      typedNode.nodeType === NodeType.Insertion ||\n      typedNode.nodeType === NodeType.Gender ||\n      typedNode.nodeType === NodeType.File ||\n      typedNode.nodeType === NodeType.Markdown\n    ) {\n      const firstKey = Object.keys(content)[0] as keyof typeof content;\n      return content[firstKey] as ContentNode;\n    }\n\n    if (typedNode.nodeType === NodeType.Nested) {\n      return undefined;\n    }\n\n    return content;\n  }\n\n  if (!section || typeof section !== 'object') {\n    return section;\n  }\n\n  if (Array.isArray(section)) {\n    return (section as ContentNode[])[0];\n  }\n\n  return section;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAA2D;AAEpD,MAAM,kBAAkB,CAAC,YAAsC;AACpE,MAAI,OAAO,YAAY,UAAU;AAC/B,WAAO;AAAA,EACT;AACA,MAAI,OAAO,YAAY,UAAU;AAC/B,WAAO;AAAA,EACT;AACA,MAAI,OAAO,YAAY,WAAW;AAChC,WAAO;AAAA,EACT;AACA,MAAI,OAAQ,SAAuB,aAAa,UAAU;AACxD,UAAM,YAAY;AAClB,UAAM,UAAU,UAAU,UAAU,QAA2B;AAE/D,QACE,UAAU,aAAa,sBAAS,eAChC,UAAU,aAAa,sBAAS,eAChC,UAAU,aAAa,sBAAS,aAChC,UAAU,aAAa,sBAAS,aAChC,UAAU,aAAa,sBAAS,UAChC,UAAU,aAAa,sBAAS,QAChC,UAAU,aAAa,sBAAS,UAChC;AACA,YAAM,WAAW,OAAO,KAAK,OAAO,EAAE,CAAC;AACvC,aAAO,QAAQ,QAAQ;AAAA,IACzB;AAEA,QAAI,UAAU,aAAa,sBAAS,QAAQ;AAC1C,aAAO;AAAA,IACT;AAEA,WAAO;AAAA,EACT;AAEA,MAAI,CAAC,WAAW,OAAO,YAAY,UAAU;AAC3C,WAAO;AAAA,EACT;AAEA,MAAI,MAAM,QAAQ,OAAO,GAAG;AAC1B,WAAQ,QAA0B,CAAC;AAAA,EACrC;AAEA,SAAO;AACT;","names":[]}
+{"version":3,"file":"getNodeChildren.cjs","names":["NodeType"],"sources":["../../../src/dictionaryManipulator/getNodeChildren.ts"],"sourcesContent":["import { type ContentNode, NodeType, type TypedNode } from '@intlayer/types';\n\nexport const getNodeChildren = (section: ContentNode): ContentNode => {\n  if (typeof section === 'string') {\n    return section;\n  }\n  if (typeof section === 'number') {\n    return section;\n  }\n  if (typeof section === 'boolean') {\n    return section;\n  }\n  if (typeof (section as TypedNode)?.nodeType === 'string') {\n    const typedNode = section as TypedNode;\n    const content =\n      typedNode[typedNode.nodeType as unknown as keyof typeof typedNode];\n\n    if (\n      typedNode.nodeType === NodeType.Translation ||\n      typedNode.nodeType === NodeType.Enumeration ||\n      typedNode.nodeType === NodeType.Condition ||\n      typedNode.nodeType === NodeType.Insertion ||\n      typedNode.nodeType === NodeType.Gender ||\n      typedNode.nodeType === NodeType.File ||\n      typedNode.nodeType === NodeType.Markdown\n    ) {\n      const firstKey = Object.keys(content)[0] as keyof typeof content;\n      return content[firstKey] as ContentNode;\n    }\n\n    if (typedNode.nodeType === NodeType.Nested) {\n      return undefined;\n    }\n\n    return content;\n  }\n\n  if (!section || typeof section !== 'object') {\n    return section;\n  }\n\n  if (Array.isArray(section)) {\n    return (section as ContentNode[])[0];\n  }\n\n  return section;\n};\n"],"mappings":";;;;;AAEA,MAAa,mBAAmB,YAAsC;AACpE,KAAI,OAAO,YAAY,SACrB,QAAO;AAET,KAAI,OAAO,YAAY,SACrB,QAAO;AAET,KAAI,OAAO,YAAY,UACrB,QAAO;AAET,KAAI,OAAQ,SAAuB,aAAa,UAAU;EACxD,MAAM,YAAY;EAClB,MAAM,UACJ,UAAU,UAAU;AAEtB,MACE,UAAU,aAAaA,0BAAS,eAChC,UAAU,aAAaA,0BAAS,eAChC,UAAU,aAAaA,0BAAS,aAChC,UAAU,aAAaA,0BAAS,aAChC,UAAU,aAAaA,0BAAS,UAChC,UAAU,aAAaA,0BAAS,QAChC,UAAU,aAAaA,0BAAS,SAGhC,QAAO,QADU,OAAO,KAAK,QAAQ,CAAC;AAIxC,MAAI,UAAU,aAAaA,0BAAS,OAClC;AAGF,SAAO;;AAGT,KAAI,CAAC,WAAW,OAAO,YAAY,SACjC,QAAO;AAGT,KAAI,MAAM,QAAQ,QAAQ,CACxB,QAAQ,QAA0B;AAGpC,QAAO"}

package/dist/cjs/dictionaryManipulator/getNodeType.cjs

@@ -1,54 +1,37 @@
-"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 });
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_utils_isValidReactElement = require('../utils/isValidReactElement.cjs');
+let __intlayer_types = require("@intlayer/types");
+__intlayer_types = require_rolldown_runtime.__toESM(__intlayer_types);
+
+//#region src/dictionaryManipulator/getNodeType.ts
+/**
+* Type guard to check if content is a TypedNode
+*/
+const isTypedNode = (content) => {
+	return typeof content === "object" && content !== null && "nodeType" in content && typeof content.nodeType === "string";
 };
-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;
+/**
+* Type guard to check if content is a valid NodeType
+*/
+const isValidNodeType = (nodeType) => {
+	return Object.values(__intlayer_types.NodeType).includes(nodeType);
 };
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var getNodeType_exports = {};
-__export(getNodeType_exports, {
-  getNodeType: () => getNodeType
-});
-module.exports = __toCommonJS(getNodeType_exports);
-var import_types = require('../types/index.cjs');
-var import_isValidReactElement = require('../utils/isValidReactElement.cjs');
 const getNodeType = (content) => {
-  if (typeof content === "string") {
-    return import_types.NodeType.Text;
-  }
-  if (typeof content?.nodeType === "string") {
-    return content.nodeType;
-  }
-  if (Array.isArray(content)) {
-    return import_types.NodeType.Array;
-  }
-  if ((0, import_isValidReactElement.isValidElement)(content)) {
-    return import_types.NodeType.ReactNode;
-  }
-  if (typeof content === "number") {
-    return import_types.NodeType.Number;
-  }
-  if (typeof content === "boolean") {
-    return import_types.NodeType.Boolean;
-  }
-  if (content && typeof content === "object") {
-    return import_types.NodeType.Object;
-  }
-  return import_types.NodeType.Unknown;
+	if (typeof content === "string") return __intlayer_types.NodeType.Text;
+	if (isTypedNode(content)) {
+		const nodeType = content.nodeType;
+		if (isValidNodeType(nodeType)) return nodeType;
+		return __intlayer_types.NodeType.Unknown;
+	}
+	if (Array.isArray(content)) return __intlayer_types.NodeType.Array;
+	if (require_utils_isValidReactElement.isValidElement(content)) return __intlayer_types.NodeType.ReactNode;
+	if (typeof content === "number") return __intlayer_types.NodeType.Number;
+	if (typeof content === "boolean") return __intlayer_types.NodeType.Boolean;
+	if (content && typeof content === "object") return __intlayer_types.NodeType.Object;
+	if (content === null) return __intlayer_types.NodeType.Null;
+	return __intlayer_types.NodeType.Unknown;
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  getNodeType
-});
+
+//#endregion
+exports.getNodeType = getNodeType;
 //# sourceMappingURL=getNodeType.cjs.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/dictionaryManipulator/getNodeType.ts"],"sourcesContent":["import { NodeType, type TypedNode } from '../types';\nimport type { ContentNode } from '../types/dictionary';\nimport { isValidElement } from '../utils/isValidReactElement';\n\nexport const getNodeType = (content: ContentNode): NodeType => {\n  if (typeof content === 'string') {\n    return NodeType.Text;\n  }\n\n  if (typeof (content as TypedNode)?.nodeType === 'string') {\n    return (content as TypedNode).nodeType as NodeType;\n  }\n\n  if (Array.isArray(content)) {\n    return NodeType.Array;\n  }\n\n  if (isValidElement(content)) {\n    return NodeType.ReactNode;\n  }\n\n  if (typeof content === 'number') {\n    return NodeType.Number;\n  }\n\n  if (typeof content === 'boolean') {\n    return NodeType.Boolean;\n  }\n\n  if (content && typeof content === 'object') {\n    return NodeType.Object;\n  }\n\n  return NodeType.Unknown;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAyC;AAEzC,iCAA+B;AAExB,MAAM,cAAc,CAAC,YAAmC;AAC7D,MAAI,OAAO,YAAY,UAAU;AAC/B,WAAO,sBAAS;AAAA,EAClB;AAEA,MAAI,OAAQ,SAAuB,aAAa,UAAU;AACxD,WAAQ,QAAsB;AAAA,EAChC;AAEA,MAAI,MAAM,QAAQ,OAAO,GAAG;AAC1B,WAAO,sBAAS;AAAA,EAClB;AAEA,UAAI,2CAAe,OAAO,GAAG;AAC3B,WAAO,sBAAS;AAAA,EAClB;AAEA,MAAI,OAAO,YAAY,UAAU;AAC/B,WAAO,sBAAS;AAAA,EAClB;AAEA,MAAI,OAAO,YAAY,WAAW;AAChC,WAAO,sBAAS;AAAA,EAClB;AAEA,MAAI,WAAW,OAAO,YAAY,UAAU;AAC1C,WAAO,sBAAS;AAAA,EAClB;AAEA,SAAO,sBAAS;AAClB;","names":[]}
+{"version":3,"file":"getNodeType.cjs","names":["NodeType","isValidElement"],"sources":["../../../src/dictionaryManipulator/getNodeType.ts"],"sourcesContent":["import { type ContentNode, NodeType, type TypedNode } from '@intlayer/types';\nimport { isValidElement } from '../utils/isValidReactElement';\n\n/**\n * Type guard to check if content is a TypedNode\n */\nconst isTypedNode = (content: unknown): content is TypedNode => {\n  return (\n    typeof content === 'object' &&\n    content !== null &&\n    'nodeType' in content &&\n    typeof (content as TypedNode).nodeType === 'string'\n  );\n};\n\n/**\n * Type guard to check if content is a valid NodeType\n */\nconst isValidNodeType = (nodeType: string): nodeType is NodeType => {\n  return Object.values(NodeType).includes(nodeType as NodeType);\n};\n\nexport const getNodeType = (content: ContentNode): NodeType => {\n  if (typeof content === 'string') {\n    return NodeType.Text;\n  }\n\n  if (isTypedNode(content)) {\n    const nodeType = content.nodeType;\n    if (isValidNodeType(nodeType)) {\n      return nodeType;\n    }\n    // Fallback for unknown node types\n    return NodeType.Unknown;\n  }\n\n  if (Array.isArray(content)) {\n    return NodeType.Array;\n  }\n\n  if (isValidElement(content)) {\n    return NodeType.ReactNode;\n  }\n\n  if (typeof content === 'number') {\n    return NodeType.Number;\n  }\n\n  if (typeof content === 'boolean') {\n    return NodeType.Boolean;\n  }\n\n  if (content && typeof content === 'object') {\n    return NodeType.Object;\n  }\n\n  if (content === null) {\n    return NodeType.Null;\n  }\n\n  return NodeType.Unknown;\n};\n"],"mappings":";;;;;;;;;AAMA,MAAM,eAAe,YAA2C;AAC9D,QACE,OAAO,YAAY,YACnB,YAAY,QACZ,cAAc,WACd,OAAQ,QAAsB,aAAa;;;;;AAO/C,MAAM,mBAAmB,aAA2C;AAClE,QAAO,OAAO,OAAOA,0BAAS,CAAC,SAAS,SAAqB;;AAG/D,MAAa,eAAe,YAAmC;AAC7D,KAAI,OAAO,YAAY,SACrB,QAAOA,0BAAS;AAGlB,KAAI,YAAY,QAAQ,EAAE;EACxB,MAAM,WAAW,QAAQ;AACzB,MAAI,gBAAgB,SAAS,CAC3B,QAAO;AAGT,SAAOA,0BAAS;;AAGlB,KAAI,MAAM,QAAQ,QAAQ,CACxB,QAAOA,0BAAS;AAGlB,KAAIC,iDAAe,QAAQ,CACzB,QAAOD,0BAAS;AAGlB,KAAI,OAAO,YAAY,SACrB,QAAOA,0BAAS;AAGlB,KAAI,OAAO,YAAY,UACrB,QAAOA,0BAAS;AAGlB,KAAI,WAAW,OAAO,YAAY,SAChC,QAAOA,0BAAS;AAGlB,KAAI,YAAY,KACd,QAAOA,0BAAS;AAGlB,QAAOA,0BAAS"}

package/dist/cjs/dictionaryManipulator/getUnmergedDictionaryByKeyPath.cjs

@@ -1,52 +1,20 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_dictionaryManipulator_getContentNodeByKeyPath = require('./getContentNodeByKeyPath.cjs');
+const require_dictionaryManipulator_normalizeDictionary = require('./normalizeDictionary.cjs');
+let __intlayer_config_built = require("@intlayer/config/built");
+__intlayer_config_built = require_rolldown_runtime.__toESM(__intlayer_config_built);
+let __intlayer_unmerged_dictionaries_entry = require("@intlayer/unmerged-dictionaries-entry");
+__intlayer_unmerged_dictionaries_entry = require_rolldown_runtime.__toESM(__intlayer_unmerged_dictionaries_entry);
+
+//#region src/dictionaryManipulator/getUnmergedDictionaryByKeyPath.ts
+const getUnmergedDictionaryByKeyPath = (dictionaryKey, keyPath, dictionariesRecord, configuration = __intlayer_config_built.default) => {
+	const unmergedEntries = (dictionariesRecord ?? (0, __intlayer_unmerged_dictionaries_entry.getUnmergedDictionaries)(configuration))?.[dictionaryKey];
+	if (!unmergedEntries) return null;
+	const normalizedUnmergedEntries = require_dictionaryManipulator_normalizeDictionary.normalizeDictionaries(unmergedEntries, configuration);
+	for (const dictionary of normalizedUnmergedEntries) if (require_dictionaryManipulator_getContentNodeByKeyPath.getContentNodeByKeyPath(dictionary.content, keyPath)) return dictionary;
+	for (const dictionary of unmergedEntries) if (require_dictionaryManipulator_getContentNodeByKeyPath.getContentNodeByKeyPath(dictionary.content, keyPath)) return dictionary;
 };
-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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var getUnmergedDictionaryByKeyPath_exports = {};
-__export(getUnmergedDictionaryByKeyPath_exports, {
-  getUnmergedDictionaryByKeyPath: () => getUnmergedDictionaryByKeyPath
-});
-module.exports = __toCommonJS(getUnmergedDictionaryByKeyPath_exports);
-var import_unmerged_dictionaries_entry = __toESM(require("@intlayer/unmerged-dictionaries-entry"));
-var import_getContentNodeByKeyPath = require('./getContentNodeByKeyPath.cjs');
-const getUnmergedDictionaryByKeyPath = (dictionaryKey, keyPath, dictionariesRecord = import_unmerged_dictionaries_entry.default) => {
-  const unmergedEntries = dictionariesRecord?.[dictionaryKey];
-  if (!unmergedEntries) {
-    return null;
-  }
-  for (const dictionary of unmergedEntries) {
-    const content = (0, import_getContentNodeByKeyPath.getContentNodeByKeyPath)(dictionary.content, keyPath);
-    if (content) {
-      return dictionary;
-    }
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  getUnmergedDictionaryByKeyPath
-});
+
+//#endregion
+exports.getUnmergedDictionaryByKeyPath = getUnmergedDictionaryByKeyPath;
 //# sourceMappingURL=getUnmergedDictionaryByKeyPath.cjs.map

package/dist/cjs/dictionaryManipulator/getUnmergedDictionaryByKeyPath.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/dictionaryManipulator/getUnmergedDictionaryByKeyPath.ts"],"sourcesContent":["import unmergedDictionary from '@intlayer/unmerged-dictionaries-entry';\nimport { type KeyPath } from '../types';\nimport { getContentNodeByKeyPath } from './getContentNodeByKeyPath';\n\nexport const getUnmergedDictionaryByKeyPath = (\n  dictionaryKey: string,\n  keyPath: KeyPath[],\n  dictionariesRecord: keyof typeof unmergedDictionary = unmergedDictionary\n) => {\n  const unmergedEntries = dictionariesRecord?.[dictionaryKey];\n\n  if (!unmergedEntries) {\n    return null;\n  }\n\n  for (const dictionary of unmergedEntries) {\n    const content = getContentNodeByKeyPath(dictionary.content, keyPath);\n\n    if (content) {\n      return dictionary;\n    }\n  }\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,yCAA+B;AAE/B,qCAAwC;AAEjC,MAAM,iCAAiC,CAC5C,eACA,SACA,qBAAsD,mCAAAA,YACnD;AACH,QAAM,kBAAkB,qBAAqB,aAAa;AAE1D,MAAI,CAAC,iBAAiB;AACpB,WAAO;AAAA,EACT;AAEA,aAAW,cAAc,iBAAiB;AACxC,UAAM,cAAU,wDAAwB,WAAW,SAAS,OAAO;AAEnE,QAAI,SAAS;AACX,aAAO;AAAA,IACT;AAAA,EACF;AACF;","names":["unmergedDictionary"]}
+{"version":3,"file":"getUnmergedDictionaryByKeyPath.cjs","names":["intlayerConfiguration","normalizeDictionaries","getContentNodeByKeyPath"],"sources":["../../../src/dictionaryManipulator/getUnmergedDictionaryByKeyPath.ts"],"sourcesContent":["import intlayerConfiguration from '@intlayer/config/built';\nimport type { IntlayerConfig, KeyPath } from '@intlayer/types';\nimport {\n  getUnmergedDictionaries,\n  type UnmergedDictionaries,\n} from '@intlayer/unmerged-dictionaries-entry';\nimport { getContentNodeByKeyPath } from './getContentNodeByKeyPath';\nimport { normalizeDictionaries } from './normalizeDictionary';\n\nexport const getUnmergedDictionaryByKeyPath = (\n  dictionaryKey: string,\n  keyPath: KeyPath[],\n  dictionariesRecord?: UnmergedDictionaries,\n  configuration: IntlayerConfig = intlayerConfiguration\n) => {\n  const unmergedEntries = (dictionariesRecord ??\n    getUnmergedDictionaries(configuration))?.[dictionaryKey];\n\n  if (!unmergedEntries) {\n    return null;\n  }\n\n  const normalizedUnmergedEntries = normalizeDictionaries(\n    unmergedEntries,\n    configuration\n  );\n\n  for (const dictionary of normalizedUnmergedEntries) {\n    const content = getContentNodeByKeyPath(dictionary.content, keyPath);\n\n    if (content) {\n      return dictionary;\n    }\n  }\n\n  for (const dictionary of unmergedEntries) {\n    const content = getContentNodeByKeyPath(dictionary.content, keyPath);\n\n    if (content) {\n      return dictionary;\n    }\n  }\n};\n"],"mappings":";;;;;;;;;AASA,MAAa,kCACX,eACA,SACA,oBACA,gBAAgCA,oCAC7B;CACH,MAAM,mBAAmB,0FACC,cAAc,IAAI;AAE5C,KAAI,CAAC,gBACH,QAAO;CAGT,MAAM,4BAA4BC,wEAChC,iBACA,cACD;AAED,MAAK,MAAM,cAAc,0BAGvB,KAFgBC,8EAAwB,WAAW,SAAS,QAAQ,CAGlE,QAAO;AAIX,MAAK,MAAM,cAAc,gBAGvB,KAFgBA,8EAAwB,WAAW,SAAS,QAAQ,CAGlE,QAAO"}

package/dist/cjs/dictionaryManipulator/index.cjs

@@ -1,41 +1,28 @@
-"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('./getDefaultNode.cjs'), module.exports);
-__reExport(dictionaryManipulator_exports, require('./getEmptyNode.cjs'), module.exports);
-__reExport(dictionaryManipulator_exports, require('./getNodeChildren.cjs'), module.exports);
-__reExport(dictionaryManipulator_exports, require('./getNodeType.cjs'), module.exports);
-__reExport(dictionaryManipulator_exports, require('./getUnmergedDictionaryByKeyPath.cjs'), module.exports);
-__reExport(dictionaryManipulator_exports, require('./removeContentNodeByKeyPath.cjs'), module.exports);
-__reExport(dictionaryManipulator_exports, require('./renameContentNodeByKeyPath.cjs'), module.exports);
-__reExport(dictionaryManipulator_exports, require('./updateNodeChildren.cjs'), module.exports);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ...require('./editDictionaryByKeyPath.cjs'),
-  ...require('./getContentNodeByKeyPath.cjs'),
-  ...require('./getDefaultNode.cjs'),
-  ...require('./getEmptyNode.cjs'),
-  ...require('./getNodeChildren.cjs'),
-  ...require('./getNodeType.cjs'),
-  ...require('./getUnmergedDictionaryByKeyPath.cjs'),
-  ...require('./removeContentNodeByKeyPath.cjs'),
-  ...require('./renameContentNodeByKeyPath.cjs'),
-  ...require('./updateNodeChildren.cjs')
-});
-//# sourceMappingURL=index.cjs.map
+const require_dictionaryManipulator_editDictionaryByKeyPath = require('./editDictionaryByKeyPath.cjs');
+const require_dictionaryManipulator_getContentNodeByKeyPath = require('./getContentNodeByKeyPath.cjs');
+const require_dictionaryManipulator_getDefaultNode = require('./getDefaultNode.cjs');
+const require_dictionaryManipulator_getEmptyNode = require('./getEmptyNode.cjs');
+const require_dictionaryManipulator_getNodeChildren = require('./getNodeChildren.cjs');
+const require_dictionaryManipulator_getNodeType = require('./getNodeType.cjs');
+const require_dictionaryManipulator_orderDictionaries = require('./orderDictionaries.cjs');
+const require_dictionaryManipulator_normalizeDictionary = require('./normalizeDictionary.cjs');
+const require_dictionaryManipulator_getUnmergedDictionaryByKeyPath = require('./getUnmergedDictionaryByKeyPath.cjs');
+const require_dictionaryManipulator_mergeDictionaries = require('./mergeDictionaries.cjs');
+const require_dictionaryManipulator_removeContentNodeByKeyPath = require('./removeContentNodeByKeyPath.cjs');
+const require_dictionaryManipulator_renameContentNodeByKeyPath = require('./renameContentNodeByKeyPath.cjs');
+const require_dictionaryManipulator_updateNodeChildren = require('./updateNodeChildren.cjs');
+
+exports.editDictionaryByKeyPath = require_dictionaryManipulator_editDictionaryByKeyPath.editDictionaryByKeyPath;
+exports.getContentNodeByKeyPath = require_dictionaryManipulator_getContentNodeByKeyPath.getContentNodeByKeyPath;
+exports.getDefaultNode = require_dictionaryManipulator_getDefaultNode.getDefaultNode;
+exports.getEmptyNode = require_dictionaryManipulator_getEmptyNode.getEmptyNode;
+exports.getNodeChildren = require_dictionaryManipulator_getNodeChildren.getNodeChildren;
+exports.getNodeType = require_dictionaryManipulator_getNodeType.getNodeType;
+exports.getUnmergedDictionaryByKeyPath = require_dictionaryManipulator_getUnmergedDictionaryByKeyPath.getUnmergedDictionaryByKeyPath;
+exports.mergeDictionaries = require_dictionaryManipulator_mergeDictionaries.mergeDictionaries;
+exports.normalizeDictionaries = require_dictionaryManipulator_normalizeDictionary.normalizeDictionaries;
+exports.normalizeDictionary = require_dictionaryManipulator_normalizeDictionary.normalizeDictionary;
+exports.orderDictionaries = require_dictionaryManipulator_orderDictionaries.orderDictionaries;
+exports.removeContentNodeByKeyPath = require_dictionaryManipulator_removeContentNodeByKeyPath.removeContentNodeByKeyPath;
+exports.renameContentNodeByKeyPath = require_dictionaryManipulator_renameContentNodeByKeyPath.renameContentNodeByKeyPath;
+exports.updateNodeChildren = require_dictionaryManipulator_updateNodeChildren.updateNodeChildren;

package/dist/cjs/dictionaryManipulator/mergeDictionaries.cjs

@@ -0,0 +1,69 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_dictionaryManipulator_getNodeType = require('./getNodeType.cjs');
+let __intlayer_config_client = require("@intlayer/config/client");
+__intlayer_config_client = require_rolldown_runtime.__toESM(__intlayer_config_client);
+let __intlayer_config_built = require("@intlayer/config/built");
+__intlayer_config_built = require_rolldown_runtime.__toESM(__intlayer_config_built);
+
+//#region src/dictionaryManipulator/mergeDictionaries.ts
+const checkTypesMatch = (object1, object2, object2LocalId, dictionaryKey, path = []) => {
+	const appLogger = (0, __intlayer_config_client.getAppLogger)(__intlayer_config_built.default);
+	if (object1 === void 0 || object1 === null || object2 === void 0 || object2 === null) return;
+	const type1 = require_dictionaryManipulator_getNodeType.getNodeType(object1);
+	const type2 = require_dictionaryManipulator_getNodeType.getNodeType(object2);
+	if (type1 === "unknown" || type2 === "unknown") return;
+	if (type1 !== type2) {
+		appLogger([`Error: Dictionary ${(0, __intlayer_config_client.colorizeKey)(dictionaryKey)} has a multiple content files with type mismatch at path "${path.join(".")}": Cannot merge ${type1} with ${type2} while merging ${object2LocalId}`], { level: "error" });
+		return;
+	}
+};
+const customMerge = (destination, source) => {
+	if (destination === void 0 || destination === null) return source;
+	if (source === void 0 || source === null) return destination;
+	if (typeof destination !== "object" || typeof source !== "object") return destination;
+	if (Array.isArray(destination) && Array.isArray(source)) return arrayMerge(destination, source);
+	if (typeof destination === "object" && typeof source === "object") {
+		const result = {};
+		const allKeys = new Set([...Object.keys(destination), ...Object.keys(source)]);
+		for (const key of allKeys) result[key] = customMerge(destination[key], source[key]);
+		return result;
+	}
+	return destination;
+};
+const arrayMerge = (destinationArray, sourceArray) => {
+	const destHasOnlyPrimitives = destinationArray.every((item) => typeof item !== "object" || item === null);
+	const sourceHasOnlyPrimitives = sourceArray.every((item) => typeof item !== "object" || item === null);
+	if (destHasOnlyPrimitives && sourceHasOnlyPrimitives) return sourceArray;
+	const result = [];
+	const maxLength = Math.max(destinationArray.length, sourceArray.length);
+	for (let i = 0; i < maxLength; i++) {
+		const destItem = destinationArray[i];
+		const sourceItem = sourceArray[i];
+		if (destItem === void 0 && sourceItem === void 0) {} else if (destItem === void 0) result.push(sourceItem);
+		else if (sourceItem === void 0) result.push(destItem);
+		else if (typeof destItem === "object" && typeof sourceItem === "object" && destItem !== null && sourceItem !== null) if ("key" in destItem && "key" in sourceItem && destItem.key === sourceItem.key) result.push(customMerge(destItem, sourceItem));
+		else result.push(customMerge(destItem, sourceItem));
+		else result.push(destItem);
+	}
+	return result;
+};
+const mergeDictionaries = (dictionaries) => {
+	const localIds = Array.from(new Set(dictionaries.filter((dict) => dict.localId).map((dict) => dict.localId)));
+	const dictionariesKeys = dictionaries.map((dict) => dict.key);
+	if (new Set(dictionariesKeys).size !== 1) throw new Error("All dictionaries must have the same key");
+	let mergedContent = dictionaries[0].content;
+	for (let i = 1; i < dictionaries.length; i++) {
+		const currentDictionary = dictionaries[i];
+		checkTypesMatch(mergedContent, currentDictionary.content, currentDictionary.localId, currentDictionary.key, []);
+		mergedContent = customMerge(mergedContent, currentDictionary.content);
+	}
+	return {
+		key: dictionaries[0].key,
+		content: mergedContent,
+		localIds
+	};
+};
+
+//#endregion
+exports.mergeDictionaries = mergeDictionaries;
+//# sourceMappingURL=mergeDictionaries.cjs.map

package/dist/cjs/dictionaryManipulator/mergeDictionaries.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mergeDictionaries.cjs","names":["configuration","getNodeType","result: Record<string, MergeableContent>","result: MergeableContent[]","mergedContent: Dictionary['content']"],"sources":["../../../src/dictionaryManipulator/mergeDictionaries.ts"],"sourcesContent":["import configuration from '@intlayer/config/built';\nimport { colorizeKey, getAppLogger } from '@intlayer/config/client';\nimport type {\n  ContentNode,\n  Dictionary,\n  LocalDictionaryId,\n} from '@intlayer/types';\nimport { getNodeType } from './getNodeType';\n\n// Extended type that includes arrays for internal merge operations\ntype MergeableContent = ContentNode | ContentNode[];\n\nconst checkTypesMatch = (\n  object1: ContentNode,\n  object2: ContentNode,\n  object2LocalId: LocalDictionaryId | undefined,\n  dictionaryKey: string,\n  path: string[] = []\n): void => {\n  const appLogger = getAppLogger(configuration);\n\n  // If either side is missing/undefined, allow merge without error\n  if (\n    object1 === undefined ||\n    object1 === null ||\n    object2 === undefined ||\n    object2 === null\n  )\n    return;\n\n  const type1 = getNodeType(object1);\n  const type2 = getNodeType(object2);\n\n  // Unknown types are treated as flexible; skip strict mismatch reporting\n  if (type1 === 'unknown' || type2 === 'unknown') return;\n\n  if (type1 !== type2) {\n    appLogger(\n      [\n        `Error: Dictionary ${colorizeKey(dictionaryKey)} has a multiple content files with type mismatch at path \"${path.join('.')}\": Cannot merge ${type1} with ${type2} while merging ${object2LocalId}`,\n      ],\n      {\n        level: 'error',\n      }\n    );\n\n    return;\n  }\n};\n\n// Custom merge function that prefers destination (first dictionary) values\nconst customMerge = (\n  destination: ContentNode,\n  source: ContentNode\n): MergeableContent => {\n  // If destination is undefined/null, use source\n  if (destination === undefined || destination === null) {\n    return source;\n  }\n\n  // If source is undefined/null, use destination\n  if (source === undefined || source === null) {\n    return destination;\n  }\n\n  // For primitive values, prefer destination (first dictionary)\n  if (typeof destination !== 'object' || typeof source !== 'object') {\n    return destination;\n  }\n\n  // For arrays, use our custom array merge\n  if (Array.isArray(destination) && Array.isArray(source)) {\n    return arrayMerge(\n      destination as ContentNode[],\n      source as ContentNode[]\n    ) as MergeableContent;\n  }\n\n  // For objects, recursively merge with our custom logic\n  if (typeof destination === 'object' && typeof source === 'object') {\n    const result: Record<string, MergeableContent> = {};\n    const allKeys = new Set([\n      ...Object.keys(destination as unknown as Record<string, ContentNode>),\n      ...Object.keys(source as unknown as Record<string, ContentNode>),\n    ]);\n\n    for (const key of allKeys) {\n      result[key] = customMerge(\n        (destination as unknown as Record<string, ContentNode>)[key],\n        (source as unknown as Record<string, ContentNode>)[key]\n      );\n    }\n\n    return result as unknown as MergeableContent;\n  }\n\n  // Fallback to destination\n  return destination;\n};\n\n// Custom array merge strategy that merges arrays by key when present, otherwise by index\nconst arrayMerge = (\n  destinationArray: ContentNode[],\n  sourceArray: ContentNode[]\n): MergeableContent[] => {\n  // Check if both arrays contain only primitives\n  const destHasOnlyPrimitives = destinationArray.every(\n    (item) => typeof item !== 'object' || item === null\n  );\n  const sourceHasOnlyPrimitives = sourceArray.every(\n    (item) => typeof item !== 'object' || item === null\n  );\n\n  // If both arrays contain only primitives, use the source array (second dictionary)\n  if (destHasOnlyPrimitives && sourceHasOnlyPrimitives) {\n    return sourceArray;\n  }\n\n  // Otherwise, merge by index with object merging logic\n  const result: MergeableContent[] = [];\n  const maxLength = Math.max(destinationArray.length, sourceArray.length);\n\n  for (let i = 0; i < maxLength; i++) {\n    const destItem = destinationArray[i];\n    const sourceItem = sourceArray[i];\n\n    if (destItem === undefined && sourceItem === undefined) {\n    } else if (destItem === undefined) {\n      // Only source exists, add it\n      result.push(sourceItem);\n    } else if (sourceItem === undefined) {\n      // Only destination exists, add it\n      result.push(destItem);\n    } else {\n      // Both exist, merge them\n      if (\n        typeof destItem === 'object' &&\n        typeof sourceItem === 'object' &&\n        destItem !== null &&\n        sourceItem !== null\n      ) {\n        // Check if both objects have a 'key' property for keyed merging\n        if (\n          'key' in destItem &&\n          'key' in sourceItem &&\n          (destItem as Record<string, string>).key ===\n            (sourceItem as Record<string, string>).key\n        ) {\n          // Merge objects with same key, preferring destination (first dictionary) values\n          result.push(customMerge(destItem, sourceItem));\n        } else {\n          // Merge objects by index, preferring destination (first dictionary) values\n          result.push(customMerge(destItem, sourceItem));\n        }\n      } else {\n        // For primitives or non-objects, use destination value (first dictionary)\n        result.push(destItem);\n      }\n    }\n  }\n\n  return result;\n};\n\nexport const mergeDictionaries = (dictionaries: Dictionary[]): Dictionary => {\n  const localIds = Array.from(\n    new Set<LocalDictionaryId>(\n      dictionaries.filter((dict) => dict.localId).map((dict) => dict.localId!)\n    )\n  );\n\n  const dictionariesKeys = dictionaries.map((dict) => dict.key);\n\n  // Check if all dictionaries have the same key\n  if (new Set(dictionariesKeys).size !== 1) {\n    throw new Error('All dictionaries must have the same key');\n  }\n\n  let mergedContent: Dictionary['content'] = dictionaries[0].content;\n\n  for (let i = 1; i < dictionaries.length; i++) {\n    const currentDictionary = dictionaries[i];\n\n    // Check types before merging\n    checkTypesMatch(\n      mergedContent,\n      currentDictionary.content,\n      currentDictionary.localId,\n      currentDictionary.key,\n      []\n    );\n\n    mergedContent = customMerge(\n      mergedContent,\n      currentDictionary.content\n    ) as ContentNode;\n  }\n\n  const mergedDictionary: Dictionary = {\n    key: dictionaries[0].key,\n\n    content: mergedContent,\n    localIds,\n  };\n\n  return mergedDictionary;\n};\n"],"mappings":";;;;;;;;AAYA,MAAM,mBACJ,SACA,SACA,gBACA,eACA,OAAiB,EAAE,KACV;CACT,MAAM,uDAAyBA,gCAAc;AAG7C,KACE,YAAY,UACZ,YAAY,QACZ,YAAY,UACZ,YAAY,KAEZ;CAEF,MAAM,QAAQC,sDAAY,QAAQ;CAClC,MAAM,QAAQA,sDAAY,QAAQ;AAGlC,KAAI,UAAU,aAAa,UAAU,UAAW;AAEhD,KAAI,UAAU,OAAO;AACnB,YACE,CACE,+DAAiC,cAAc,CAAC,4DAA4D,KAAK,KAAK,IAAI,CAAC,kBAAkB,MAAM,QAAQ,MAAM,iBAAiB,iBACnL,EACD,EACE,OAAO,SACR,CACF;AAED;;;AAKJ,MAAM,eACJ,aACA,WACqB;AAErB,KAAI,gBAAgB,UAAa,gBAAgB,KAC/C,QAAO;AAIT,KAAI,WAAW,UAAa,WAAW,KACrC,QAAO;AAIT,KAAI,OAAO,gBAAgB,YAAY,OAAO,WAAW,SACvD,QAAO;AAIT,KAAI,MAAM,QAAQ,YAAY,IAAI,MAAM,QAAQ,OAAO,CACrD,QAAO,WACL,aACA,OACD;AAIH,KAAI,OAAO,gBAAgB,YAAY,OAAO,WAAW,UAAU;EACjE,MAAMC,SAA2C,EAAE;EACnD,MAAM,UAAU,IAAI,IAAI,CACtB,GAAG,OAAO,KAAK,YAAsD,EACrE,GAAG,OAAO,KAAK,OAAiD,CACjE,CAAC;AAEF,OAAK,MAAM,OAAO,QAChB,QAAO,OAAO,YACX,YAAuD,MACvD,OAAkD,KACpD;AAGH,SAAO;;AAIT,QAAO;;AAIT,MAAM,cACJ,kBACA,gBACuB;CAEvB,MAAM,wBAAwB,iBAAiB,OAC5C,SAAS,OAAO,SAAS,YAAY,SAAS,KAChD;CACD,MAAM,0BAA0B,YAAY,OACzC,SAAS,OAAO,SAAS,YAAY,SAAS,KAChD;AAGD,KAAI,yBAAyB,wBAC3B,QAAO;CAIT,MAAMC,SAA6B,EAAE;CACrC,MAAM,YAAY,KAAK,IAAI,iBAAiB,QAAQ,YAAY,OAAO;AAEvE,MAAK,IAAI,IAAI,GAAG,IAAI,WAAW,KAAK;EAClC,MAAM,WAAW,iBAAiB;EAClC,MAAM,aAAa,YAAY;AAE/B,MAAI,aAAa,UAAa,eAAe,QAAW,YAC7C,aAAa,OAEtB,QAAO,KAAK,WAAW;WACd,eAAe,OAExB,QAAO,KAAK,SAAS;WAInB,OAAO,aAAa,YACpB,OAAO,eAAe,YACtB,aAAa,QACb,eAAe,KAGf,KACE,SAAS,YACT,SAAS,cACR,SAAoC,QAClC,WAAsC,IAGzC,QAAO,KAAK,YAAY,UAAU,WAAW,CAAC;MAG9C,QAAO,KAAK,YAAY,UAAU,WAAW,CAAC;MAIhD,QAAO,KAAK,SAAS;;AAK3B,QAAO;;AAGT,MAAa,qBAAqB,iBAA2C;CAC3E,MAAM,WAAW,MAAM,KACrB,IAAI,IACF,aAAa,QAAQ,SAAS,KAAK,QAAQ,CAAC,KAAK,SAAS,KAAK,QAAS,CACzE,CACF;CAED,MAAM,mBAAmB,aAAa,KAAK,SAAS,KAAK,IAAI;AAG7D,KAAI,IAAI,IAAI,iBAAiB,CAAC,SAAS,EACrC,OAAM,IAAI,MAAM,0CAA0C;CAG5D,IAAIC,gBAAuC,aAAa,GAAG;AAE3D,MAAK,IAAI,IAAI,GAAG,IAAI,aAAa,QAAQ,KAAK;EAC5C,MAAM,oBAAoB,aAAa;AAGvC,kBACE,eACA,kBAAkB,SAClB,kBAAkB,SAClB,kBAAkB,KAClB,EAAE,CACH;AAED,kBAAgB,YACd,eACA,kBAAkB,QACnB;;AAUH,QAPqC;EACnC,KAAK,aAAa,GAAG;EAErB,SAAS;EACT;EACD"}

package/dist/cjs/dictionaryManipulator/normalizeDictionary.cjs

@@ -0,0 +1,30 @@
+const require_transpiler_translation_translation = require('../transpiler/translation/translation.cjs');
+const require_deepTransformPlugins_getLocalizedContent = require('../deepTransformPlugins/getLocalizedContent.cjs');
+const require_dictionaryManipulator_orderDictionaries = require('./orderDictionaries.cjs');
+
+//#region src/dictionaryManipulator/normalizeDictionary.ts
+const normalizeDictionary = (dictionary, configuration) => {
+	const { locales } = configuration.internationalization;
+	const parsedDictionary = JSON.parse(JSON.stringify(dictionary));
+	if (dictionary.locale) return {
+		...dictionary,
+		locale: void 0,
+		content: require_transpiler_translation_translation.t({ [dictionary.locale]: require_deepTransformPlugins_getLocalizedContent.getPerLocaleDictionary(dictionary.content, dictionary.locale) })
+	};
+	const perLocaleContent = locales.reduce((acc, locale) => {
+		acc[locale] = require_deepTransformPlugins_getLocalizedContent.getPerLocaleDictionary(parsedDictionary, locale).content;
+		return acc;
+	}, {});
+	return {
+		...dictionary,
+		content: require_transpiler_translation_translation.t(perLocaleContent)
+	};
+};
+const normalizeDictionaries = (dictionaries, configuration) => {
+	return require_dictionaryManipulator_orderDictionaries.orderDictionaries(dictionaries, configuration).map((dictionary) => normalizeDictionary(dictionary, configuration));
+};
+
+//#endregion
+exports.normalizeDictionaries = normalizeDictionaries;
+exports.normalizeDictionary = normalizeDictionary;
+//# sourceMappingURL=normalizeDictionary.cjs.map

package/dist/cjs/dictionaryManipulator/normalizeDictionary.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizeDictionary.cjs","names":["t","getPerLocaleDictionary","orderDictionaries"],"sources":["../../../src/dictionaryManipulator/normalizeDictionary.ts"],"sourcesContent":["import type { Dictionary, IntlayerConfig, Locale } from '@intlayer/types';\nimport { getPerLocaleDictionary } from '../deepTransformPlugins';\nimport { t } from '../transpiler/translation';\nimport { orderDictionaries } from './orderDictionaries';\n\nexport const normalizeDictionary = (\n  dictionary: Dictionary,\n  configuration: IntlayerConfig\n): Dictionary => {\n  const { locales } = configuration.internationalization;\n\n  const parsedDictionary = JSON.parse(JSON.stringify(dictionary));\n\n  // If the dictionary is a per-locale dictionary, transform it to a partial multilingual dictionary\n  if (dictionary.locale) {\n    return {\n      ...dictionary,\n      locale: undefined,\n      content: t({\n        // @ts-ignore Type instantiation is excessively deep and possibly infinite.\n        [dictionary.locale]: getPerLocaleDictionary(\n          dictionary.content,\n          dictionary.locale\n        ),\n      }),\n    };\n  }\n\n  const perLocaleContent = locales.reduce(\n    (acc, locale) => {\n      const perLocaleDictionary = getPerLocaleDictionary(\n        parsedDictionary,\n        locale\n      );\n\n      acc[locale] = perLocaleDictionary.content;\n      return acc;\n    },\n    {} as Record<Locale, Dictionary['content']>\n  );\n\n  return {\n    ...dictionary,\n    content: t(perLocaleContent),\n  };\n};\n\nexport const normalizeDictionaries = (\n  dictionaries: Dictionary[],\n  configuration: IntlayerConfig\n): Dictionary[] => {\n  const orderedDictionaries = orderDictionaries(dictionaries, configuration);\n\n  const structuredDictionaries = orderedDictionaries.map((dictionary) =>\n    normalizeDictionary(dictionary, configuration)\n  );\n\n  return structuredDictionaries;\n};\n"],"mappings":";;;;;AAKA,MAAa,uBACX,YACA,kBACe;CACf,MAAM,EAAE,YAAY,cAAc;CAElC,MAAM,mBAAmB,KAAK,MAAM,KAAK,UAAU,WAAW,CAAC;AAG/D,KAAI,WAAW,OACb,QAAO;EACL,GAAG;EACH,QAAQ;EACR,SAASA,6CAAE,GAER,WAAW,SAASC,wEACnB,WAAW,SACX,WAAW,OACZ,EACF,CAAC;EACH;CAGH,MAAM,mBAAmB,QAAQ,QAC9B,KAAK,WAAW;AAMf,MAAI,UALwBA,wEAC1B,kBACA,OACD,CAEiC;AAClC,SAAO;IAET,EAAE,CACH;AAED,QAAO;EACL,GAAG;EACH,SAASD,6CAAE,iBAAiB;EAC7B;;AAGH,MAAa,yBACX,cACA,kBACiB;AAOjB,QAN4BE,kEAAkB,cAAc,cAAc,CAEvB,KAAK,eACtD,oBAAoB,YAAY,cAAc,CAC/C"}