@intlayer/core 8.4.4 → 8.4.5

package/dist/esm/deepTransformPlugins/getMissingLocalesContent.mjs

@@ -1,2 +1,146 @@
-import{deepTransformNode as e}from"../interpreter/getContent/deepTransform.mjs";import{NodeType as t}from"@intlayer/types/nodeType";import n from"@intlayer/config/built";const r=(e,t=[])=>typeof e!=`object`||!e||Array.isArray(e)?[]:Object.keys(e).flatMap(n=>{let i=[...t,n],a=e[n];return a===null?[i]:[i,...r(a,i)]}),i=(e,t=[])=>typeof e!=`object`||!e||Array.isArray(e)?[]:Object.keys(e).flatMap(n=>{let r=[...t,n],a=e[n];return a===null?[]:[r,...i(a,r)]}),a=(e,t)=>{let n=e;for(let e of t){if(typeof n!=`object`||!n||!(e in n))return!1;n=n[e]}return!0},o=(e,t)=>{let n=e;for(let e of t){if(typeof n!=`object`||!n||!(e in n))return!1;n=n[e]}return n!==null},s=(e,n)=>({id:`check-missing-locales-plugin`,canHandle:e=>typeof e==`object`&&e?.nodeType===t.Translation,transform:(s,c,l)=>{let u=s[t.Translation],d=new Set,f=new Set;for(let t of e){let e=u[t];e&&typeof e==`object`&&!Array.isArray(e)&&(r(e).forEach(e=>{d.add(JSON.stringify(e))}),i(e).forEach(e=>{f.add(JSON.stringify(e))}))}let p=e.some(e=>u[e]!==void 0&&u[e]!==null);for(let t of e){let e=u[t];if(e===null){p&&n(t);continue}if(!e){n(t);continue}let r=!1;for(let i of d)if(!a(e,JSON.parse(i))){n(t),r=!0;break}if(!r){for(let r of f)if(!o(e,JSON.parse(r))){n(t);break}}}for(let e in u){let t=u[e];l(t,{...c,children:t})}return s}}),c=(t,r=n?.internationalization?.locales,i)=>{let a=new Set,o=[s(r,e=>a.add(e)),...i.plugins??[]];return e(t,{...i,plugins:o}),Array.from(a)},l=(e,t=n?.internationalization?.locales)=>c(e.content,t,{dictionaryKey:e.key,keyPath:[]});export{s as checkMissingLocalesPlugin,c as getMissingLocalesContent,l as getMissingLocalesContentFromDictionary};
+import { deepTransformNode } from "../interpreter/getContent/deepTransform.mjs";
+import * as NodeTypes from "@intlayer/types/nodeType";
+import configuration from "@intlayer/config/built";
+
+//#region src/deepTransformPlugins/getMissingLocalesContent.ts
+/**
+* Returns all key paths present in obj, INCLUDING those whose leaf value is null.
+* Used for structural presence checks (a locale must have every key another locale has,
+* even if the value is a null placeholder).
+*/
+const getAllKeyPaths = (obj, prefix = []) => {
+	if (typeof obj !== "object" || obj === null || Array.isArray(obj)) return [];
+	return Object.keys(obj).flatMap((key) => {
+		const newPath = [...prefix, key];
+		const value = obj[key];
+		if (value === null) return [newPath];
+		return [newPath, ...getAllKeyPaths(value, newPath)];
+	});
+};
+/**
+* Returns key paths whose leaf value is non-null.
+* Used for translation value checks (a locale must not have null where another locale
+* already has a real translated value).
+*/
+const getNonNullKeyPaths = (obj, prefix = []) => {
+	if (typeof obj !== "object" || obj === null || Array.isArray(obj)) return [];
+	return Object.keys(obj).flatMap((key) => {
+		const newPath = [...prefix, key];
+		const value = obj[key];
+		if (value === null) return [];
+		return [newPath, ...getNonNullKeyPaths(value, newPath)];
+	});
+};
+/**
+* Returns true if the key path EXISTS in obj (even if the terminal value is null).
+* Used for the structural presence check.
+*/
+const hasKey = (obj, keyPath) => {
+	let current = obj;
+	for (const key of keyPath) {
+		if (current === void 0 || current === null || typeof current !== "object") return false;
+		if (!(key in current)) return false;
+		current = current[key];
+	}
+	return true;
+};
+/**
+* Returns true if the key path exists in obj AND the terminal value is non-null.
+* Used for the translation value check.
+*/
+const hasNonNullValue = (obj, keyPath) => {
+	let current = obj;
+	for (const key of keyPath) {
+		if (current === void 0 || current === null || typeof current !== "object") return false;
+		if (!(key in current)) return false;
+		current = current[key];
+	}
+	return current !== null;
+};
+/** Translation plugin. Replaces node with a locale string if nodeType = Translation. */
+const checkMissingLocalesPlugin = (locales, onMissingLocale) => ({
+	id: "check-missing-locales-plugin",
+	canHandle: (node) => typeof node === "object" && node?.nodeType === NodeTypes.TRANSLATION,
+	transform: (node, props, deepTransformNode) => {
+		const translations = node[NodeTypes.TRANSLATION];
+		/**
+		* Two path sets built from all locales' content:
+		*
+		* presentPaths — every key path that exists in ANY locale, even those whose value
+		*   is null. A locale that is missing a path from this set is structurally incomplete
+		*   (the key doesn't exist at all).
+		*
+		* nonNullPaths — every key path that has a non-null value in at least one locale.
+		*   A locale that has the key but with null, when another locale already has a real
+		*   value, needs translation.
+		*/
+		const presentPaths = /* @__PURE__ */ new Set();
+		const nonNullPaths = /* @__PURE__ */ new Set();
+		for (const locale of locales) {
+			const value = translations[locale];
+			if (value && typeof value === "object" && !Array.isArray(value)) {
+				getAllKeyPaths(value).forEach((path) => {
+					presentPaths.add(JSON.stringify(path));
+				});
+				getNonNullKeyPaths(value).forEach((path) => {
+					nonNullPaths.add(JSON.stringify(path));
+				});
+			}
+		}
+		const hasAnyDefinedValue = locales.some((locale) => translations[locale] !== void 0 && translations[locale] !== null);
+		for (const locale of locales) {
+			const value = translations[locale];
+			if (value === null) {
+				if (hasAnyDefinedValue) onMissingLocale(locale);
+				continue;
+			}
+			if (!value) {
+				onMissingLocale(locale);
+				continue;
+			}
+			let flagged = false;
+			for (const pathStr of presentPaths) if (!hasKey(value, JSON.parse(pathStr))) {
+				onMissingLocale(locale);
+				flagged = true;
+				break;
+			}
+			if (!flagged) {
+				for (const pathStr of nonNullPaths) if (!hasNonNullValue(value, JSON.parse(pathStr))) {
+					onMissingLocale(locale);
+					break;
+				}
+			}
+		}
+		for (const key in translations) {
+			const child = translations[key];
+			deepTransformNode(child, {
+				...props,
+				children: child
+			});
+		}
+		return node;
+	}
+});
+/**
+* Return the content of a node with only the translation plugin.
+*
+* @param node The node to transform.
+* @param locales The locales to check for missing translations.
+*/
+const getMissingLocalesContent = (node, locales = configuration?.internationalization?.locales, nodeProps) => {
+	const missingLocales = /* @__PURE__ */ new Set();
+	const plugins = [checkMissingLocalesPlugin(locales, (locale) => missingLocales.add(locale)), ...nodeProps.plugins ?? []];
+	deepTransformNode(node, {
+		...nodeProps,
+		plugins
+	});
+	return Array.from(missingLocales);
+};
+const getMissingLocalesContentFromDictionary = (dictionary, locales = configuration?.internationalization?.locales) => getMissingLocalesContent(dictionary.content, locales, {
+	dictionaryKey: dictionary.key,
+	keyPath: []
+});
+
+//#endregion
+export { checkMissingLocalesPlugin, getMissingLocalesContent, getMissingLocalesContentFromDictionary };
 //# sourceMappingURL=getMissingLocalesContent.mjs.map

package/dist/esm/deepTransformPlugins/getMissingLocalesContent.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"getMissingLocalesContent.mjs","names":[],"sources":["../../../src/deepTransformPlugins/getMissingLocalesContent.ts"],"sourcesContent":["import configuration from '@intlayer/config/built';\nimport type { Locale } from '@intlayer/types/allLocales';\nimport type { ContentNode, Dictionary } from '@intlayer/types/dictionary';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { NodeType } from '@intlayer/types/nodeType';\nimport type { DeepTransformContent, NodeProps, Plugins } from '../interpreter';\nimport { deepTransformNode } from '../interpreter/getContent/deepTransform';\nimport type { TranslationContent } from '../transpiler';\n\n/**\n * Returns all key paths present in obj, INCLUDING those whose leaf value is null.\n * Used for structural presence checks (a locale must have every key another locale has,\n * even if the value is a null placeholder).\n */\nconst getAllKeyPaths = (obj: any, prefix: string[] = []): string[][] => {\n  if (typeof obj !== 'object' || obj === null || Array.isArray(obj)) {\n    return [];\n  }\n\n  return Object.keys(obj).flatMap((key) => {\n    const newPath = [...prefix, key];\n    const value = obj[key];\n    // Stop recursing into null — include the path but don't descend further\n    if (value === null) {\n      return [newPath];\n    }\n    return [newPath, ...getAllKeyPaths(value, newPath)];\n  });\n};\n\n/**\n * Returns key paths whose leaf value is non-null.\n * Used for translation value checks (a locale must not have null where another locale\n * already has a real translated value).\n */\nconst getNonNullKeyPaths = (obj: any, prefix: string[] = []): string[][] => {\n  if (typeof obj !== 'object' || obj === null || Array.isArray(obj)) {\n    return [];\n  }\n\n  return Object.keys(obj).flatMap((key) => {\n    const newPath = [...prefix, key];\n    const value = obj[key];\n    // Skip null-valued keys entirely\n    if (value === null) {\n      return [];\n    }\n    return [newPath, ...getNonNullKeyPaths(value, newPath)];\n  });\n};\n\n/**\n * Returns true if the key path EXISTS in obj (even if the terminal value is null).\n * Used for the structural presence check.\n */\nconst hasKey = (obj: any, keyPath: string[]): boolean => {\n  let current = obj;\n  for (const key of keyPath) {\n    if (\n      current === undefined ||\n      current === null ||\n      typeof current !== 'object'\n    ) {\n      return false;\n    }\n    if (!(key in current)) {\n      return false;\n    }\n    current = current[key];\n  }\n  return true; // key exists; value may be null\n};\n\n/**\n * Returns true if the key path exists in obj AND the terminal value is non-null.\n * Used for the translation value check.\n */\nconst hasNonNullValue = (obj: any, keyPath: string[]): boolean => {\n  let current = obj;\n  for (const key of keyPath) {\n    if (\n      current === undefined ||\n      current === null ||\n      typeof current !== 'object'\n    ) {\n      return false;\n    }\n    if (!(key in current)) {\n      return false;\n    }\n    current = current[key];\n  }\n  // null is treated as a missing translation (e.g., i18next-scanner sets null for untranslated keys)\n  return current !== null;\n};\n\n/** Translation plugin. Replaces node with a locale string if nodeType = Translation. */\nexport const checkMissingLocalesPlugin = (\n  locales: Locale[],\n  onMissingLocale: (locale: Locale) => void\n): Plugins => ({\n  id: 'check-missing-locales-plugin',\n  canHandle: (node) =>\n    typeof node === 'object' && node?.nodeType === NodeType.Translation,\n  transform: (node: TranslationContent, props, deepTransformNode) => {\n    const translations = node[NodeType.Translation] as Record<string, any>;\n\n    /**\n     * Two path sets built from all locales' content:\n     *\n     * presentPaths — every key path that exists in ANY locale, even those whose value\n     *   is null. A locale that is missing a path from this set is structurally incomplete\n     *   (the key doesn't exist at all).\n     *\n     * nonNullPaths — every key path that has a non-null value in at least one locale.\n     *   A locale that has the key but with null, when another locale already has a real\n     *   value, needs translation.\n     */\n    const presentPaths = new Set<string>();\n    const nonNullPaths = new Set<string>();\n\n    for (const locale of locales) {\n      const value = translations[locale];\n      if (value && typeof value === 'object' && !Array.isArray(value)) {\n        getAllKeyPaths(value).forEach((path) => {\n          presentPaths.add(JSON.stringify(path));\n        });\n\n        getNonNullKeyPaths(value).forEach((path) => {\n          nonNullPaths.add(JSON.stringify(path));\n        });\n      }\n    }\n\n    // If no locale has any content at all (all are null/undefined), the key is\n    // universally pending — don't flag anyone.\n    const hasAnyDefinedValue = locales.some(\n      (locale) =>\n        translations[locale] !== undefined && translations[locale] !== null\n    );\n\n    for (const locale of locales) {\n      const value = translations[locale];\n\n      if (value === null) {\n        // Entire locale content is a null placeholder.\n        // Flag only when some other locale already has real content.\n        if (hasAnyDefinedValue) {\n          onMissingLocale(locale);\n        }\n        continue;\n      }\n\n      if (!value) {\n        // undefined / entirely absent\n        onMissingLocale(locale);\n        continue;\n      }\n\n      let flagged = false;\n\n      // Structural check: every key that exists in any locale must also exist here\n      // (even if the local value is null — at least the key must be present).\n      for (const pathStr of presentPaths) {\n        if (!hasKey(value, JSON.parse(pathStr))) {\n          onMissingLocale(locale);\n          flagged = true;\n          break;\n        }\n      }\n\n      if (!flagged) {\n        // Value check: every key that has a non-null value in some locale must also\n        // be non-null here (null = untranslated, needs filling).\n        for (const pathStr of nonNullPaths) {\n          if (!hasNonNullValue(value, JSON.parse(pathStr))) {\n            onMissingLocale(locale);\n            break;\n          }\n        }\n      }\n    }\n\n    // Continue traversal inside the translation values\n    for (const key in translations) {\n      const child = translations[key];\n      deepTransformNode(child, {\n        ...props,\n        children: child,\n      });\n    }\n\n    // Return the original node; the return value is ignored by the caller\n    return node;\n  },\n});\n\n/**\n * Return the content of a node with only the translation plugin.\n *\n * @param node The node to transform.\n * @param locales The locales to check for missing translations.\n */\nexport const getMissingLocalesContent = <T extends ContentNode>(\n  node: T,\n  locales: LocalesValues[] = configuration?.internationalization?.locales,\n  nodeProps: NodeProps\n): Locale[] => {\n  const missingLocales = new Set<Locale>();\n\n  const plugins: Plugins[] = [\n    checkMissingLocalesPlugin(locales as Locale[], (locale) =>\n      missingLocales.add(locale)\n    ),\n    ...(nodeProps.plugins ?? []),\n  ];\n\n  deepTransformNode(node, {\n    ...nodeProps,\n    plugins,\n  }) as DeepTransformContent<T>;\n\n  return Array.from(missingLocales);\n};\n\nexport const getMissingLocalesContentFromDictionary = (\n  dictionary: Dictionary,\n  locales: LocalesValues[] = configuration?.internationalization?.locales\n) =>\n  getMissingLocalesContent(dictionary.content, locales, {\n    dictionaryKey: dictionary.key,\n    keyPath: [],\n  });\n"],"mappings":"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"}
+{"version":3,"file":"getMissingLocalesContent.mjs","names":[],"sources":["../../../src/deepTransformPlugins/getMissingLocalesContent.ts"],"sourcesContent":["import configuration from '@intlayer/config/built';\nimport type { Locale } from '@intlayer/types/allLocales';\nimport type { ContentNode, Dictionary } from '@intlayer/types/dictionary';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport * as NodeTypes from '@intlayer/types/nodeType';\nimport type { DeepTransformContent, NodeProps, Plugins } from '../interpreter';\nimport { deepTransformNode } from '../interpreter/getContent/deepTransform';\nimport type { TranslationContent } from '../transpiler';\n\n/**\n * Returns all key paths present in obj, INCLUDING those whose leaf value is null.\n * Used for structural presence checks (a locale must have every key another locale has,\n * even if the value is a null placeholder).\n */\nconst getAllKeyPaths = (obj: any, prefix: string[] = []): string[][] => {\n  if (typeof obj !== 'object' || obj === null || Array.isArray(obj)) {\n    return [];\n  }\n\n  return Object.keys(obj).flatMap((key) => {\n    const newPath = [...prefix, key];\n    const value = obj[key];\n    // Stop recursing into null — include the path but don't descend further\n    if (value === null) {\n      return [newPath];\n    }\n    return [newPath, ...getAllKeyPaths(value, newPath)];\n  });\n};\n\n/**\n * Returns key paths whose leaf value is non-null.\n * Used for translation value checks (a locale must not have null where another locale\n * already has a real translated value).\n */\nconst getNonNullKeyPaths = (obj: any, prefix: string[] = []): string[][] => {\n  if (typeof obj !== 'object' || obj === null || Array.isArray(obj)) {\n    return [];\n  }\n\n  return Object.keys(obj).flatMap((key) => {\n    const newPath = [...prefix, key];\n    const value = obj[key];\n    // Skip null-valued keys entirely\n    if (value === null) {\n      return [];\n    }\n    return [newPath, ...getNonNullKeyPaths(value, newPath)];\n  });\n};\n\n/**\n * Returns true if the key path EXISTS in obj (even if the terminal value is null).\n * Used for the structural presence check.\n */\nconst hasKey = (obj: any, keyPath: string[]): boolean => {\n  let current = obj;\n  for (const key of keyPath) {\n    if (\n      current === undefined ||\n      current === null ||\n      typeof current !== 'object'\n    ) {\n      return false;\n    }\n    if (!(key in current)) {\n      return false;\n    }\n    current = current[key];\n  }\n  return true; // key exists; value may be null\n};\n\n/**\n * Returns true if the key path exists in obj AND the terminal value is non-null.\n * Used for the translation value check.\n */\nconst hasNonNullValue = (obj: any, keyPath: string[]): boolean => {\n  let current = obj;\n  for (const key of keyPath) {\n    if (\n      current === undefined ||\n      current === null ||\n      typeof current !== 'object'\n    ) {\n      return false;\n    }\n    if (!(key in current)) {\n      return false;\n    }\n    current = current[key];\n  }\n  // null is treated as a missing translation (e.g., i18next-scanner sets null for untranslated keys)\n  return current !== null;\n};\n\n/** Translation plugin. Replaces node with a locale string if nodeType = Translation. */\nexport const checkMissingLocalesPlugin = (\n  locales: Locale[],\n  onMissingLocale: (locale: Locale) => void\n): Plugins => ({\n  id: 'check-missing-locales-plugin',\n  canHandle: (node) =>\n    typeof node === 'object' && node?.nodeType === NodeTypes.TRANSLATION,\n  transform: (node: TranslationContent, props, deepTransformNode) => {\n    const translations = node[NodeTypes.TRANSLATION] as Record<string, any>;\n\n    /**\n     * Two path sets built from all locales' content:\n     *\n     * presentPaths — every key path that exists in ANY locale, even those whose value\n     *   is null. A locale that is missing a path from this set is structurally incomplete\n     *   (the key doesn't exist at all).\n     *\n     * nonNullPaths — every key path that has a non-null value in at least one locale.\n     *   A locale that has the key but with null, when another locale already has a real\n     *   value, needs translation.\n     */\n    const presentPaths = new Set<string>();\n    const nonNullPaths = new Set<string>();\n\n    for (const locale of locales) {\n      const value = translations[locale];\n      if (value && typeof value === 'object' && !Array.isArray(value)) {\n        getAllKeyPaths(value).forEach((path) => {\n          presentPaths.add(JSON.stringify(path));\n        });\n\n        getNonNullKeyPaths(value).forEach((path) => {\n          nonNullPaths.add(JSON.stringify(path));\n        });\n      }\n    }\n\n    // If no locale has any content at all (all are null/undefined), the key is\n    // universally pending — don't flag anyone.\n    const hasAnyDefinedValue = locales.some(\n      (locale) =>\n        translations[locale] !== undefined && translations[locale] !== null\n    );\n\n    for (const locale of locales) {\n      const value = translations[locale];\n\n      if (value === null) {\n        // Entire locale content is a null placeholder.\n        // Flag only when some other locale already has real content.\n        if (hasAnyDefinedValue) {\n          onMissingLocale(locale);\n        }\n        continue;\n      }\n\n      if (!value) {\n        // undefined / entirely absent\n        onMissingLocale(locale);\n        continue;\n      }\n\n      let flagged = false;\n\n      // Structural check: every key that exists in any locale must also exist here\n      // (even if the local value is null — at least the key must be present).\n      for (const pathStr of presentPaths) {\n        if (!hasKey(value, JSON.parse(pathStr))) {\n          onMissingLocale(locale);\n          flagged = true;\n          break;\n        }\n      }\n\n      if (!flagged) {\n        // Value check: every key that has a non-null value in some locale must also\n        // be non-null here (null = untranslated, needs filling).\n        for (const pathStr of nonNullPaths) {\n          if (!hasNonNullValue(value, JSON.parse(pathStr))) {\n            onMissingLocale(locale);\n            break;\n          }\n        }\n      }\n    }\n\n    // Continue traversal inside the translation values\n    for (const key in translations) {\n      const child = translations[key];\n      deepTransformNode(child, {\n        ...props,\n        children: child,\n      });\n    }\n\n    // Return the original node; the return value is ignored by the caller\n    return node;\n  },\n});\n\n/**\n * Return the content of a node with only the translation plugin.\n *\n * @param node The node to transform.\n * @param locales The locales to check for missing translations.\n */\nexport const getMissingLocalesContent = <T extends ContentNode>(\n  node: T,\n  locales: LocalesValues[] = configuration?.internationalization?.locales,\n  nodeProps: NodeProps\n): Locale[] => {\n  const missingLocales = new Set<Locale>();\n\n  const plugins: Plugins[] = [\n    checkMissingLocalesPlugin(locales as Locale[], (locale) =>\n      missingLocales.add(locale)\n    ),\n    ...(nodeProps.plugins ?? []),\n  ];\n\n  deepTransformNode(node, {\n    ...nodeProps,\n    plugins,\n  }) as DeepTransformContent<T>;\n\n  return Array.from(missingLocales);\n};\n\nexport const getMissingLocalesContentFromDictionary = (\n  dictionary: Dictionary,\n  locales: LocalesValues[] = configuration?.internationalization?.locales\n) =>\n  getMissingLocalesContent(dictionary.content, locales, {\n    dictionaryKey: dictionary.key,\n    keyPath: [],\n  });\n"],"mappings":"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"}

package/dist/esm/deepTransformPlugins/getMultilingualDictionary.mjs

@@ -1,2 +1,87 @@
-import{deepTransformNode as e}from"../interpreter/getContent/deepTransform.mjs";import{t}from"../transpiler/translation/translation.mjs";const n=n=>{if(!n.locale)return n;let r=n.locale,i=e(JSON.parse(JSON.stringify(n.content)),{dictionaryKey:n.key,keyPath:[],plugins:[{id:`traverse-typed-node-plugin`,canHandle:e=>typeof e==`object`&&typeof e?.nodeType==`string`,transform:(e,t,n)=>{let r=e.nodeType,i=structuredClone(e[r]);if(typeof i!=`object`||!i){let a=n(i,{...t,children:i,keyPath:[...t.keyPath,{type:r,key:r}]});return{...e,[r]:a}}for(let e in i){let a={...t,children:i[e],keyPath:[...t.keyPath,{type:r,key:e}]};i[e]=n(i[e],a)}return{...e,[r]:i}}},{id:`wrap-primitive-in-translation`,canHandle:e=>typeof e==`string`||typeof e==`number`||typeof e==`boolean`,transform:e=>t({[r]:e})}]}),{locale:a,...o}=n;return{...o,content:i}};export{n as getMultilingualDictionary};
+import { deepTransformNode } from "../interpreter/getContent/deepTransform.mjs";
+import { t as translation } from "../transpiler/translation/translation.mjs";
+
+//#region src/deepTransformPlugins/getMultilingualDictionary.ts
+/**
+* Transform a per-locale dictionary into a multilingual dictionary.
+*
+* Example:
+* ```json
+* {
+*   "key": "about-page",
+*   "locale": "en",
+*   "content": {
+*     "myContent": "English content"
+*   }
+* }
+* ```
+*
+* ```json
+* {
+*   "key": "about-page",
+*   "content": {
+*     "myContent": t({
+*       "en": "English content",
+*     })
+*   }
+* }
+* ```
+*/
+const getMultilingualDictionary = (dictionary) => {
+	if (!dictionary.locale) return dictionary;
+	const locale = dictionary.locale;
+	const transformedContent = deepTransformNode(JSON.parse(JSON.stringify(dictionary.content)), {
+		dictionaryKey: dictionary.key,
+		keyPath: [],
+		plugins: [{
+			id: "traverse-typed-node-plugin",
+			canHandle: (node) => typeof node === "object" && typeof node?.nodeType === "string",
+			transform: (node, props, transformFn) => {
+				const nodeType = node.nodeType;
+				const inner = structuredClone(node[nodeType]);
+				if (typeof inner !== "object" || inner === null) {
+					const transformed = transformFn(inner, {
+						...props,
+						children: inner,
+						keyPath: [...props.keyPath, {
+							type: nodeType,
+							key: nodeType
+						}]
+					});
+					return {
+						...node,
+						[nodeType]: transformed
+					};
+				}
+				for (const key in inner) {
+					const childProps = {
+						...props,
+						children: inner[key],
+						keyPath: [...props.keyPath, {
+							type: nodeType,
+							key
+						}]
+					};
+					inner[key] = transformFn(inner[key], childProps);
+				}
+				return {
+					...node,
+					[nodeType]: inner
+				};
+			}
+		}, {
+			id: "wrap-primitive-in-translation",
+			canHandle: (node) => typeof node === "string" || typeof node === "number" || typeof node === "boolean",
+			transform: (node) => translation({ [locale]: node })
+		}]
+	});
+	const { locale: _omitLocale, ...rest } = dictionary;
+	return {
+		...rest,
+		content: transformedContent
+	};
+};
+
+//#endregion
+export { getMultilingualDictionary };
 //# sourceMappingURL=getMultilingualDictionary.mjs.map

package/dist/esm/deepTransformPlugins/getMultilingualDictionary.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"getMultilingualDictionary.mjs","names":["t"],"sources":["../../../src/deepTransformPlugins/getMultilingualDictionary.ts"],"sourcesContent":["import type { Dictionary, TypedNode } from '@intlayer/types/dictionary';\nimport type { KeyPath } from '@intlayer/types/keyPath';\nimport type { NodeType } from '@intlayer/types/nodeType';\nimport {\n  deepTransformNode,\n  type NodeProps,\n  type Plugins,\n} from '../interpreter';\nimport { t } from '../transpiler';\n\n/**\n * Transform a per-locale dictionary into a multilingual dictionary.\n *\n * Example:\n * ```json\n * {\n *   \"key\": \"about-page\",\n *   \"locale\": \"en\",\n *   \"content\": {\n *     \"myContent\": \"English content\"\n *   }\n * }\n * ```\n *\n * ```json\n * {\n *   \"key\": \"about-page\",\n *   \"content\": {\n *     \"myContent\": t({\n *       \"en\": \"English content\",\n *     })\n *   }\n * }\n * ```\n */\nexport const getMultilingualDictionary = (\n  dictionary: Dictionary\n): Dictionary => {\n  if (!dictionary.locale) {\n    return dictionary;\n  }\n\n  const locale = dictionary.locale;\n\n  const wrapPrimitiveInTranslationPlugin: Plugins = {\n    id: 'wrap-primitive-in-translation',\n    canHandle: (node) =>\n      typeof node === 'string' ||\n      typeof node === 'number' ||\n      typeof node === 'boolean',\n    transform: (node) => t({ [locale]: node } as Record<string, unknown>),\n  };\n\n  const traverseTypedNodePlugin: Plugins = {\n    id: 'traverse-typed-node-plugin',\n    canHandle: (node) =>\n      typeof node === 'object' && typeof (node as any)?.nodeType === 'string',\n    transform: (node: TypedNode, props, transformFn) => {\n      const nodeType = (node as any).nodeType as NodeType;\n      const inner = structuredClone(\n        (node as any)[nodeType as unknown as keyof TypedNode] as any\n      );\n\n      if (typeof inner !== 'object' || inner === null) {\n        const transformed = transformFn(inner, {\n          ...props,\n          children: inner,\n          keyPath: [\n            ...props.keyPath,\n            { type: nodeType, key: nodeType } as KeyPath,\n          ],\n        });\n        return {\n          ...node,\n          [nodeType as unknown as keyof TypedNode]: transformed,\n        };\n      }\n\n      for (const key in inner) {\n        const childProps: NodeProps = {\n          ...props,\n          children: inner[key as unknown as keyof typeof inner],\n          keyPath: [...props.keyPath, { type: nodeType, key } as KeyPath],\n        };\n        inner[key as unknown as keyof typeof inner] = transformFn(\n          inner[key as unknown as keyof typeof inner],\n          childProps\n        );\n      }\n\n      return { ...node, [nodeType as unknown as keyof TypedNode]: inner };\n    },\n  };\n\n  const transformedContent = deepTransformNode(\n    JSON.parse(JSON.stringify(dictionary.content)),\n    {\n      dictionaryKey: dictionary.key,\n      keyPath: [],\n      plugins: [traverseTypedNodePlugin, wrapPrimitiveInTranslationPlugin],\n    }\n  );\n\n  const { locale: _omitLocale, ...rest } = dictionary as any;\n  return {\n    ...rest,\n    content: transformedContent,\n  } as Dictionary;\n};\n"],"mappings":"yIAmCA,MAAa,EACX,GACe,CACf,GAAI,CAAC,EAAW,OACd,OAAO,EAGT,IAAM,EAAS,EAAW,OAoDpB,EAAqB,EACzB,KAAK,MAAM,KAAK,UAAU,EAAW,QAAQ,CAAC,CAC9C,CACE,cAAe,EAAW,IAC1B,QAAS,EAAE,CACX,QAAS,CA9C4B,CACvC,GAAI,6BACJ,UAAY,GACV,OAAO,GAAS,UAAY,OAAQ,GAAc,UAAa,SACjE,WAAY,EAAiB,EAAO,IAAgB,CAClD,IAAM,EAAY,EAAa,SACzB,EAAQ,gBACX,EAAa,GACf,CAED,GAAI,OAAO,GAAU,WAAY,EAAgB,CAC/C,IAAM,EAAc,EAAY,EAAO,CACrC,GAAG,EACH,SAAU,EACV,QAAS,CACP,GAAG,EAAM,QACT,CAAE,KAAM,EAAU,IAAK,EAAU,CAClC,CACF,CAAC,CACF,MAAO,CACL,GAAG,GACF,GAAyC,EAC3C,CAGH,IAAK,IAAM,KAAO,EAAO,CACvB,IAAM,EAAwB,CAC5B,GAAG,EACH,SAAU,EAAM,GAChB,QAAS,CAAC,GAAG,EAAM,QAAS,CAAE,KAAM,EAAU,MAAK,CAAY,CAChE,CACD,EAAM,GAAwC,EAC5C,EAAM,GACN,EACD,CAGH,MAAO,CAAE,GAAG,GAAO,GAAyC,EAAO,EAEtE,CAhDiD,CAChD,GAAI,gCACJ,UAAY,GACV,OAAO,GAAS,UAChB,OAAO,GAAS,UAChB,OAAO,GAAS,UAClB,UAAY,GAASA,EAAE,EAAG,GAAS,EAAM,CAA4B,CACtE,CAgDuE,CACrE,CACF,CAEK,CAAE,OAAQ,EAAa,GAAG,GAAS,EACzC,MAAO,CACL,GAAG,EACH,QAAS,EACV"}
+{"version":3,"file":"getMultilingualDictionary.mjs","names":["t"],"sources":["../../../src/deepTransformPlugins/getMultilingualDictionary.ts"],"sourcesContent":["import type { Dictionary, TypedNode } from '@intlayer/types/dictionary';\nimport type { KeyPath } from '@intlayer/types/keyPath';\nimport type { NodeType } from '@intlayer/types/nodeType';\nimport {\n  deepTransformNode,\n  type NodeProps,\n  type Plugins,\n} from '../interpreter';\nimport { t } from '../transpiler';\n\n/**\n * Transform a per-locale dictionary into a multilingual dictionary.\n *\n * Example:\n * ```json\n * {\n *   \"key\": \"about-page\",\n *   \"locale\": \"en\",\n *   \"content\": {\n *     \"myContent\": \"English content\"\n *   }\n * }\n * ```\n *\n * ```json\n * {\n *   \"key\": \"about-page\",\n *   \"content\": {\n *     \"myContent\": t({\n *       \"en\": \"English content\",\n *     })\n *   }\n * }\n * ```\n */\nexport const getMultilingualDictionary = (\n  dictionary: Dictionary\n): Dictionary => {\n  if (!dictionary.locale) {\n    return dictionary;\n  }\n\n  const locale = dictionary.locale;\n\n  const wrapPrimitiveInTranslationPlugin: Plugins = {\n    id: 'wrap-primitive-in-translation',\n    canHandle: (node) =>\n      typeof node === 'string' ||\n      typeof node === 'number' ||\n      typeof node === 'boolean',\n    transform: (node) => t({ [locale]: node } as Record<string, unknown>),\n  };\n\n  const traverseTypedNodePlugin: Plugins = {\n    id: 'traverse-typed-node-plugin',\n    canHandle: (node) =>\n      typeof node === 'object' && typeof (node as any)?.nodeType === 'string',\n    transform: (node: TypedNode, props, transformFn) => {\n      const nodeType = (node as any).nodeType as NodeType;\n      const inner = structuredClone(\n        (node as any)[nodeType as unknown as keyof TypedNode] as any\n      );\n\n      if (typeof inner !== 'object' || inner === null) {\n        const transformed = transformFn(inner, {\n          ...props,\n          children: inner,\n          keyPath: [\n            ...props.keyPath,\n            { type: nodeType, key: nodeType } as KeyPath,\n          ],\n        });\n        return {\n          ...node,\n          [nodeType as unknown as keyof TypedNode]: transformed,\n        };\n      }\n\n      for (const key in inner) {\n        const childProps: NodeProps = {\n          ...props,\n          children: inner[key as unknown as keyof typeof inner],\n          keyPath: [...props.keyPath, { type: nodeType, key } as KeyPath],\n        };\n        inner[key as unknown as keyof typeof inner] = transformFn(\n          inner[key as unknown as keyof typeof inner],\n          childProps\n        );\n      }\n\n      return { ...node, [nodeType as unknown as keyof TypedNode]: inner };\n    },\n  };\n\n  const transformedContent = deepTransformNode(\n    JSON.parse(JSON.stringify(dictionary.content)),\n    {\n      dictionaryKey: dictionary.key,\n      keyPath: [],\n      plugins: [traverseTypedNodePlugin, wrapPrimitiveInTranslationPlugin],\n    }\n  );\n\n  const { locale: _omitLocale, ...rest } = dictionary as any;\n  return {\n    ...rest,\n    content: transformedContent,\n  } as Dictionary;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,MAAa,6BACX,eACe;AACf,KAAI,CAAC,WAAW,OACd,QAAO;CAGT,MAAM,SAAS,WAAW;CAoD1B,MAAM,qBAAqB,kBACzB,KAAK,MAAM,KAAK,UAAU,WAAW,QAAQ,CAAC,EAC9C;EACE,eAAe,WAAW;EAC1B,SAAS,EAAE;EACX,SAAS,CA9C4B;GACvC,IAAI;GACJ,YAAY,SACV,OAAO,SAAS,YAAY,OAAQ,MAAc,aAAa;GACjE,YAAY,MAAiB,OAAO,gBAAgB;IAClD,MAAM,WAAY,KAAa;IAC/B,MAAM,QAAQ,gBACX,KAAa,UACf;AAED,QAAI,OAAO,UAAU,YAAY,UAAU,MAAM;KAC/C,MAAM,cAAc,YAAY,OAAO;MACrC,GAAG;MACH,UAAU;MACV,SAAS,CACP,GAAG,MAAM,SACT;OAAE,MAAM;OAAU,KAAK;OAAU,CAClC;MACF,CAAC;AACF,YAAO;MACL,GAAG;OACF,WAAyC;MAC3C;;AAGH,SAAK,MAAM,OAAO,OAAO;KACvB,MAAM,aAAwB;MAC5B,GAAG;MACH,UAAU,MAAM;MAChB,SAAS,CAAC,GAAG,MAAM,SAAS;OAAE,MAAM;OAAU;OAAK,CAAY;MAChE;AACD,WAAM,OAAwC,YAC5C,MAAM,MACN,WACD;;AAGH,WAAO;KAAE,GAAG;MAAO,WAAyC;KAAO;;GAEtE,EAhDiD;GAChD,IAAI;GACJ,YAAY,SACV,OAAO,SAAS,YAChB,OAAO,SAAS,YAChB,OAAO,SAAS;GAClB,YAAY,SAASA,YAAE,GAAG,SAAS,MAAM,CAA4B;GACtE,CAgDuE;EACrE,CACF;CAED,MAAM,EAAE,QAAQ,aAAa,GAAG,SAAS;AACzC,QAAO;EACL,GAAG;EACH,SAAS;EACV"}

package/dist/esm/deepTransformPlugins/getReplacedValuesContent.mjs

@@ -1,2 +1,60 @@
-import{deepTransformNode as e}from"../interpreter/getContent/deepTransform.mjs";const t=e=>({id:`replace-values-plugin`,canHandle:e=>typeof e==`string`||typeof e==`number`||typeof e==`boolean`,transform:()=>e}),n={id:`skip-typed-node-plugin`,canHandle:e=>typeof e==`object`&&typeof e?.nodeType==`string`,transform:(e,t,n)=>{let r=e.nodeType,i=structuredClone(e[r]);if(typeof i!=`object`||!i){let a=n(i,{...t,children:i,keyPath:[...t.keyPath,{type:r,key:r}]});return{...e,[r]:a}}for(let e in i){let a={...t,children:i[e],keyPath:[...t.keyPath,{type:r,key:e}]};i[e]=n(i[e],a)}return{...e,[r]:i}}},r=(r,i,a)=>{let o=[n,t(i),...a.plugins??[]];return e(JSON.parse(JSON.stringify(r)),{...a,plugins:o})};export{r as getReplacedValuesContent};
+import { deepTransformNode } from "../interpreter/getContent/deepTransform.mjs";
+
+//#region src/deepTransformPlugins/getReplacedValuesContent.ts
+const replaceValuesPlugin = (value) => ({
+	id: "replace-values-plugin",
+	canHandle: (node) => typeof node === "string" || typeof node === "number" || typeof node === "boolean",
+	transform: () => value
+});
+const skipTypedNodePlugin = {
+	id: "skip-typed-node-plugin",
+	canHandle: (node) => typeof node === "object" && typeof node?.nodeType === "string",
+	transform: (node, props, deepTransformNode) => {
+		const nodeType = node.nodeType;
+		const result = structuredClone(node[nodeType]);
+		if (typeof result !== "object" || result === null) {
+			const transformedResult = deepTransformNode(result, {
+				...props,
+				children: result,
+				keyPath: [...props.keyPath, {
+					type: nodeType,
+					key: nodeType
+				}]
+			});
+			return {
+				...node,
+				[nodeType]: transformedResult
+			};
+		}
+		for (const key in result) {
+			const childProps = {
+				...props,
+				children: result[key],
+				keyPath: [...props.keyPath, {
+					type: nodeType,
+					key
+				}]
+			};
+			result[key] = deepTransformNode(result[key], childProps);
+		}
+		return {
+			...node,
+			[nodeType]: result
+		};
+	}
+};
+const getReplacedValuesContent = (node, value, nodeProps) => {
+	const plugins = [
+		skipTypedNodePlugin,
+		replaceValuesPlugin(value),
+		...nodeProps.plugins ?? []
+	];
+	return deepTransformNode(JSON.parse(JSON.stringify(node)), {
+		...nodeProps,
+		plugins
+	});
+};
+
+//#endregion
+export { getReplacedValuesContent };
 //# sourceMappingURL=getReplacedValuesContent.mjs.map

package/dist/esm/deepTransformPlugins/getReplacedValuesContent.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"getReplacedValuesContent.mjs","names":[],"sources":["../../../src/deepTransformPlugins/getReplacedValuesContent.ts"],"sourcesContent":["import type { ContentNode, TypedNode } from '@intlayer/types/dictionary';\nimport type { KeyPath } from '@intlayer/types/keyPath';\nimport type { NodeType } from '@intlayer/types/nodeType';\nimport {\n  deepTransformNode,\n  type NodeProps,\n  type Plugins,\n} from '../interpreter';\n\nconst replaceValuesPlugin = (value: string | number | boolean): Plugins => ({\n  id: 'replace-values-plugin',\n  canHandle: (node) =>\n    typeof node === 'string' ||\n    typeof node === 'number' ||\n    typeof node === 'boolean',\n  transform: () => value,\n});\n\nconst skipTypedNodePlugin: Plugins = {\n  id: 'skip-typed-node-plugin',\n  canHandle: (node) =>\n    typeof node === 'object' && typeof node?.nodeType === 'string',\n  transform: (node: TypedNode, props, deepTransformNode) => {\n    const nodeType = node.nodeType as NodeType;\n    const result = structuredClone(\n      node[nodeType as unknown as keyof TypedNode] as any\n    );\n\n    // If the result is a primitive value (string, number, boolean),\n    // we need to transform it directly instead of iterating over its properties\n    if (typeof result !== 'object' || result === null) {\n      const transformedResult = deepTransformNode(result, {\n        ...props,\n        children: result,\n        keyPath: [\n          ...props.keyPath,\n          { type: nodeType, key: nodeType } as KeyPath,\n        ],\n      });\n      return {\n        ...node,\n        [nodeType as unknown as keyof TypedNode]: transformedResult,\n      };\n    }\n\n    // For objects and arrays, iterate over their properties\n    for (const key in result) {\n      const childProps = {\n        ...props,\n        children: result[key as unknown as keyof typeof result],\n        keyPath: [...props.keyPath, { type: nodeType, key } as KeyPath],\n      };\n      result[key as unknown as keyof typeof result] = deepTransformNode(\n        result[key as unknown as keyof typeof result],\n        childProps\n      );\n    }\n\n    return { ...node, [nodeType as unknown as keyof TypedNode]: result };\n  },\n};\n\nexport const getReplacedValuesContent = (\n  node: ContentNode,\n  value: string | number | boolean,\n  nodeProps: NodeProps\n) => {\n  const plugins: Plugins[] = [\n    skipTypedNodePlugin,\n    replaceValuesPlugin(value),\n    ...(nodeProps.plugins ?? []),\n  ];\n\n  const JSONNode = JSON.parse(JSON.stringify(node));\n\n  return deepTransformNode(JSONNode, {\n    ...nodeProps,\n    plugins,\n  });\n};\n"],"mappings":"gFASA,MAAM,EAAuB,IAA+C,CAC1E,GAAI,wBACJ,UAAY,GACV,OAAO,GAAS,UAChB,OAAO,GAAS,UAChB,OAAO,GAAS,UAClB,cAAiB,EAClB,EAEK,EAA+B,CACnC,GAAI,yBACJ,UAAY,GACV,OAAO,GAAS,UAAY,OAAO,GAAM,UAAa,SACxD,WAAY,EAAiB,EAAO,IAAsB,CACxD,IAAM,EAAW,EAAK,SAChB,EAAS,gBACb,EAAK,GACN,CAID,GAAI,OAAO,GAAW,WAAY,EAAiB,CACjD,IAAM,EAAoB,EAAkB,EAAQ,CAClD,GAAG,EACH,SAAU,EACV,QAAS,CACP,GAAG,EAAM,QACT,CAAE,KAAM,EAAU,IAAK,EAAU,CAClC,CACF,CAAC,CACF,MAAO,CACL,GAAG,GACF,GAAyC,EAC3C,CAIH,IAAK,IAAM,KAAO,EAAQ,CACxB,IAAM,EAAa,CACjB,GAAG,EACH,SAAU,EAAO,GACjB,QAAS,CAAC,GAAG,EAAM,QAAS,CAAE,KAAM,EAAU,MAAK,CAAY,CAChE,CACD,EAAO,GAAyC,EAC9C,EAAO,GACP,EACD,CAGH,MAAO,CAAE,GAAG,GAAO,GAAyC,EAAQ,EAEvE,CAEY,GACX,EACA,EACA,IACG,CACH,IAAM,EAAqB,CACzB,EACA,EAAoB,EAAM,CAC1B,GAAI,EAAU,SAAW,EAAE,CAC5B,CAID,OAAO,EAFU,KAAK,MAAM,KAAK,UAAU,EAAK,CAAC,CAEd,CACjC,GAAG,EACH,UACD,CAAC"}
+{"version":3,"file":"getReplacedValuesContent.mjs","names":[],"sources":["../../../src/deepTransformPlugins/getReplacedValuesContent.ts"],"sourcesContent":["import type { ContentNode, TypedNode } from '@intlayer/types/dictionary';\nimport type { KeyPath } from '@intlayer/types/keyPath';\nimport type { NodeType } from '@intlayer/types/nodeType';\nimport {\n  deepTransformNode,\n  type NodeProps,\n  type Plugins,\n} from '../interpreter';\n\nconst replaceValuesPlugin = (value: string | number | boolean): Plugins => ({\n  id: 'replace-values-plugin',\n  canHandle: (node) =>\n    typeof node === 'string' ||\n    typeof node === 'number' ||\n    typeof node === 'boolean',\n  transform: () => value,\n});\n\nconst skipTypedNodePlugin: Plugins = {\n  id: 'skip-typed-node-plugin',\n  canHandle: (node) =>\n    typeof node === 'object' && typeof node?.nodeType === 'string',\n  transform: (node: TypedNode, props, deepTransformNode) => {\n    const nodeType = node.nodeType as NodeType;\n    const result = structuredClone(\n      node[nodeType as unknown as keyof TypedNode] as any\n    );\n\n    // If the result is a primitive value (string, number, boolean),\n    // we need to transform it directly instead of iterating over its properties\n    if (typeof result !== 'object' || result === null) {\n      const transformedResult = deepTransformNode(result, {\n        ...props,\n        children: result,\n        keyPath: [\n          ...props.keyPath,\n          { type: nodeType, key: nodeType } as KeyPath,\n        ],\n      });\n      return {\n        ...node,\n        [nodeType as unknown as keyof TypedNode]: transformedResult,\n      };\n    }\n\n    // For objects and arrays, iterate over their properties\n    for (const key in result) {\n      const childProps = {\n        ...props,\n        children: result[key as unknown as keyof typeof result],\n        keyPath: [...props.keyPath, { type: nodeType, key } as KeyPath],\n      };\n      result[key as unknown as keyof typeof result] = deepTransformNode(\n        result[key as unknown as keyof typeof result],\n        childProps\n      );\n    }\n\n    return { ...node, [nodeType as unknown as keyof TypedNode]: result };\n  },\n};\n\nexport const getReplacedValuesContent = (\n  node: ContentNode,\n  value: string | number | boolean,\n  nodeProps: NodeProps\n) => {\n  const plugins: Plugins[] = [\n    skipTypedNodePlugin,\n    replaceValuesPlugin(value),\n    ...(nodeProps.plugins ?? []),\n  ];\n\n  const JSONNode = JSON.parse(JSON.stringify(node));\n\n  return deepTransformNode(JSONNode, {\n    ...nodeProps,\n    plugins,\n  });\n};\n"],"mappings":";;;AASA,MAAM,uBAAuB,WAA+C;CAC1E,IAAI;CACJ,YAAY,SACV,OAAO,SAAS,YAChB,OAAO,SAAS,YAChB,OAAO,SAAS;CAClB,iBAAiB;CAClB;AAED,MAAM,sBAA+B;CACnC,IAAI;CACJ,YAAY,SACV,OAAO,SAAS,YAAY,OAAO,MAAM,aAAa;CACxD,YAAY,MAAiB,OAAO,sBAAsB;EACxD,MAAM,WAAW,KAAK;EACtB,MAAM,SAAS,gBACb,KAAK,UACN;AAID,MAAI,OAAO,WAAW,YAAY,WAAW,MAAM;GACjD,MAAM,oBAAoB,kBAAkB,QAAQ;IAClD,GAAG;IACH,UAAU;IACV,SAAS,CACP,GAAG,MAAM,SACT;KAAE,MAAM;KAAU,KAAK;KAAU,CAClC;IACF,CAAC;AACF,UAAO;IACL,GAAG;KACF,WAAyC;IAC3C;;AAIH,OAAK,MAAM,OAAO,QAAQ;GACxB,MAAM,aAAa;IACjB,GAAG;IACH,UAAU,OAAO;IACjB,SAAS,CAAC,GAAG,MAAM,SAAS;KAAE,MAAM;KAAU;KAAK,CAAY;IAChE;AACD,UAAO,OAAyC,kBAC9C,OAAO,MACP,WACD;;AAGH,SAAO;GAAE,GAAG;IAAO,WAAyC;GAAQ;;CAEvE;AAED,MAAa,4BACX,MACA,OACA,cACG;CACH,MAAM,UAAqB;EACzB;EACA,oBAAoB,MAAM;EAC1B,GAAI,UAAU,WAAW,EAAE;EAC5B;AAID,QAAO,kBAFU,KAAK,MAAM,KAAK,UAAU,KAAK,CAAC,EAEd;EACjC,GAAG;EACH;EACD,CAAC"}

package/dist/esm/deepTransformPlugins/getSplittedContent.mjs

@@ -1,2 +1,120 @@
-import{NodeType as e}from"@intlayer/types/nodeType";const t=e=>typeof e==`object`&&!!e&&!Array.isArray(e),n=e=>t(e)&&typeof e.nodeType==`string`,r=(e,i)=>{if(e===void 0)return i;if(i===void 0)return e;if(Array.isArray(e)&&Array.isArray(i))return[...e,...i];if(t(e)&&t(i)&&!n(e)&&!n(i)){let t={...e};for(let e of Object.keys(i))t[e]=r(t[e],i[e]);return t}return i},i=(e,t)=>{let n={...e};n.common=r(e.common,t.common);let i=new Set([...Object.keys(e).filter(e=>e!==`common`),...Object.keys(t).filter(e=>e!==`common`)]);for(let a of i)n[a]=r(e[a],t[a]);return n},a=o=>{if(t(o)&&o?.nodeType===e.Translation){let t=o[e.Translation],n={};for(let e of Object.keys(t)){let i=t[e],o=a(i),s=r(o.common,void 0),c;for(let e of Object.keys(o))e!==`common`&&(c=r(c,o[e]));let l=r(s,c);l!==void 0&&(n[e]=l)}return n}if(Array.isArray(o)){let e=[],t={};o.forEach(n=>{let r=a(n);r.common!==void 0&&e.push(r.common);for(let e of Object.keys(r)){if(e===`common`)continue;t[e]||(t[e]=[]);let n=r[e];n!==void 0&&t[e].push(n)}});let n={};e.length>0&&(n.common=e);for(let e of Object.keys(t))n[e]=t[e];return n}if(t(o)&&!n(o)){let e={};for(let t of Object.keys(o)){let n=a(o[t]);n.common!==void 0&&(e=i(e,{common:{[t]:n.common}}));for(let r of Object.keys(n))r!==`common`&&(e=i(e,{[r]:{[t]:n[r]}}))}return e}return{common:o}},o=e=>{let t=a(e),n={};t.common!==void 0&&(n.common=t.common);for(let e of Object.keys(t)){if(e===`common`)continue;let r=t[e];r!==void 0&&(n[e]=r)}return n},s=e=>o(e.content);export{o as getSplittedContent,s as getSplittedDictionaryContent};
+import * as NodeTypes from "@intlayer/types/nodeType";
+
+//#region src/deepTransformPlugins/getSplittedContent.ts
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const hasNodeType = (value) => isObject(value) && typeof value.nodeType === "string";
+const mergeValues = (a, b) => {
+	if (a === void 0) return b;
+	if (b === void 0) return a;
+	if (Array.isArray(a) && Array.isArray(b)) return [...a, ...b];
+	if (isObject(a) && isObject(b) && !hasNodeType(a) && !hasNodeType(b)) {
+		const result = { ...a };
+		for (const key of Object.keys(b)) result[key] = mergeValues(result[key], b[key]);
+		return result;
+	}
+	return b;
+};
+const mergeSplitResults = (base, addition) => {
+	const result = { ...base };
+	result.common = mergeValues(base.common, addition.common);
+	const localeKeys = new Set([...Object.keys(base).filter((k) => k !== "common"), ...Object.keys(addition).filter((k) => k !== "common")]);
+	for (const key of localeKeys) result[key] = mergeValues(base[key], addition[key]);
+	return result;
+};
+const splitNode = (node) => {
+	if (isObject(node) && node?.nodeType === NodeTypes.TRANSLATION) {
+		const translations = node[NodeTypes.TRANSLATION];
+		const result = {};
+		for (const locale of Object.keys(translations)) {
+			const child = translations[locale];
+			const childSplit = splitNode(child);
+			const mergedForLocale = mergeValues(childSplit.common, void 0);
+			let recomposed;
+			for (const key of Object.keys(childSplit)) {
+				if (key === "common") continue;
+				recomposed = mergeValues(recomposed, childSplit[key]);
+			}
+			const finalLocaleNode = mergeValues(mergedForLocale, recomposed);
+			if (finalLocaleNode !== void 0) result[locale] = finalLocaleNode;
+		}
+		return result;
+	}
+	if (Array.isArray(node)) {
+		const commonArray = [];
+		const perLocaleArrays = {};
+		node.forEach((child) => {
+			const childSplit = splitNode(child);
+			if (childSplit.common !== void 0) commonArray.push(childSplit.common);
+			for (const key of Object.keys(childSplit)) {
+				if (key === "common") continue;
+				if (!perLocaleArrays[key]) perLocaleArrays[key] = [];
+				const value = childSplit[key];
+				if (value !== void 0) perLocaleArrays[key].push(value);
+			}
+		});
+		const result = {};
+		if (commonArray.length > 0) result.common = commonArray;
+		for (const key of Object.keys(perLocaleArrays)) result[key] = perLocaleArrays[key];
+		return result;
+	}
+	if (isObject(node) && !hasNodeType(node)) {
+		let accumulated = {};
+		for (const key of Object.keys(node)) {
+			const childSplit = splitNode(node[key]);
+			if (childSplit.common !== void 0) accumulated = mergeSplitResults(accumulated, { common: { [key]: childSplit.common } });
+			for (const locale of Object.keys(childSplit)) {
+				if (locale === "common") continue;
+				accumulated = mergeSplitResults(accumulated, { [locale]: { [key]: childSplit[locale] } });
+			}
+		}
+		return accumulated;
+	}
+	return { common: node };
+};
+const getSplittedContent = (content) => {
+	const split = splitNode(content);
+	const output = {};
+	if (split.common !== void 0) output.common = split.common;
+	for (const key of Object.keys(split)) {
+		if (key === "common") continue;
+		const value = split[key];
+		if (value !== void 0) output[key] = value;
+	}
+	return output;
+};
+/**
+* Splits the `content` field of a Dictionary into "common" and per-locale buckets.
+*
+* Given a dictionary like:
+* ```js
+* {
+*   key: "my-key",
+*   content: {
+*     commonContent: "common content",
+*     multilingualContent: t({
+*       en: "english content",
+*       fr: "french content",
+*       de: "german content",
+*     }),
+*   },
+* }
+* ```
+*
+* It produces:
+* ```js
+* {
+*   common: { commonContent: "common content" },
+*   en: { multilingualContent: "english content" },
+*   fr: { multilingualContent: "french content" },
+*   de: { multilingualContent: "german content" },
+* }
+* ```
+*
+* @param dictionary - The input dictionary object with possible multilingual or common content.
+* @returns An object mapping "common" and each locale to their corresponding content subtrees.
+*/
+const getSplittedDictionaryContent = (dictionary) => getSplittedContent(dictionary.content);
+
+//#endregion
+export { getSplittedContent, getSplittedDictionaryContent };
 //# sourceMappingURL=getSplittedContent.mjs.map

package/dist/esm/deepTransformPlugins/getSplittedContent.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"getSplittedContent.mjs","names":[],"sources":["../../../src/deepTransformPlugins/getSplittedContent.ts"],"sourcesContent":["import type { ContentNode, Dictionary } from '@intlayer/types/dictionary';\nimport type { DeclaredLocales } from '@intlayer/types/module_augmentation';\nimport { NodeType } from '@intlayer/types/nodeType';\n\ntype SplittedContentOutput<T = ContentNode> = Record<DeclaredLocales, T> & {\n  common: T;\n};\n\ntype SplitResult = Record<string, ContentNode | undefined> & {\n  common?: ContentNode;\n};\n\nconst isObject = (value: unknown): value is Record<string, any> =>\n  typeof value === 'object' && value !== null && !Array.isArray(value);\n\nconst hasNodeType = (value: unknown): value is { nodeType: string } =>\n  isObject(value) && typeof (value as any).nodeType === 'string';\n\nconst mergeValues = (\n  a: ContentNode | undefined,\n  b: ContentNode | undefined\n): ContentNode | undefined => {\n  if (a === undefined) return b;\n  if (b === undefined) return a;\n\n  if (Array.isArray(a) && Array.isArray(b)) {\n    // Concatenate arrays when merging sibling results\n    return [...a, ...b] as unknown as ContentNode;\n  }\n\n  if (isObject(a) && isObject(b) && !hasNodeType(a) && !hasNodeType(b)) {\n    const result: Record<string, any> = { ...a };\n    for (const key of Object.keys(b)) {\n      result[key] = mergeValues(\n        result[key] as unknown as ContentNode | undefined,\n        (b as Record<string, any>)[key] as unknown as ContentNode | undefined\n      );\n    }\n    return result as ContentNode;\n  }\n\n  // For primitives or differing structures, prefer b (more recent)\n  return b;\n};\n\nconst mergeSplitResults = (\n  base: SplitResult,\n  addition: SplitResult\n): SplitResult => {\n  const result: SplitResult = { ...base };\n\n  // Merge common\n  result.common = mergeValues(base.common, addition.common);\n\n  // Merge each locale key present in either side\n  const localeKeys = new Set<string>([\n    ...Object.keys(base).filter((k) => k !== 'common'),\n    ...Object.keys(addition).filter((k) => k !== 'common'),\n  ]);\n\n  for (const key of localeKeys) {\n    // @ts-ignore: dynamic keys for locales\n    result[key] = mergeValues(\n      base[key] as ContentNode | undefined,\n      addition[key] as ContentNode | undefined\n    );\n  }\n\n  return result;\n};\n\nconst splitNode = (node: ContentNode): SplitResult => {\n  // Translation node: allocate entirely to per-locale buckets\n  if (isObject(node) && (node as any)?.nodeType === NodeType.Translation) {\n    const translations = (node as any)[NodeType.Translation] as Record<\n      string,\n      ContentNode\n    >;\n\n    const result: SplitResult = {};\n    for (const locale of Object.keys(translations)) {\n      const child = translations[locale];\n      const childSplit = splitNode(child);\n\n      // The content under a translation belongs to the locale, not common\n      // Merge common portion of the child (if any) into the locale as well\n      const mergedForLocale = mergeValues(childSplit.common, undefined);\n\n      // Compose locale content: prefer the fully rebuilt child by resolving deeper translations recursively\n      // which are already split inside childSplit. We need to recompose a single node for this locale.\n      // Recompose by merging all keys in childSplit except 'common' into a single node, then merge child's common.\n      let recomposed: ContentNode | undefined;\n      for (const key of Object.keys(childSplit)) {\n        if (key === 'common') continue;\n        recomposed = mergeValues(\n          recomposed,\n          childSplit[key] as ContentNode | undefined\n        );\n      }\n      const finalLocaleNode = mergeValues(mergedForLocale, recomposed);\n\n      if (finalLocaleNode !== undefined) {\n        // @ts-ignore dynamic locale key\n        result[locale] = finalLocaleNode;\n      }\n    }\n\n    return result;\n  }\n\n  // Arrays: split each element and merge results index-wise\n  if (Array.isArray(node)) {\n    const commonArray: any[] = [];\n    const perLocaleArrays: Record<string, any[]> = {};\n\n    node.forEach((child) => {\n      const childSplit = splitNode(child as ContentNode);\n\n      if (childSplit.common !== undefined) {\n        commonArray.push(childSplit.common);\n      }\n\n      for (const key of Object.keys(childSplit)) {\n        if (key === 'common') continue;\n        if (!perLocaleArrays[key]) perLocaleArrays[key] = [];\n        const value = childSplit[key];\n        if (value !== undefined) perLocaleArrays[key].push(value);\n      }\n    });\n\n    const result: SplitResult = {};\n    if (commonArray.length > 0)\n      result.common = commonArray as unknown as ContentNode;\n    for (const key of Object.keys(perLocaleArrays)) {\n      // @ts-ignore dynamic locale key\n      result[key] = perLocaleArrays[key] as unknown as ContentNode;\n    }\n    return result;\n  }\n\n  // Objects (non-typed): recursively split properties\n  if (isObject(node) && !hasNodeType(node)) {\n    let accumulated: SplitResult = {};\n\n    for (const key of Object.keys(node)) {\n      const childSplit = splitNode((node as any)[key] as ContentNode);\n\n      // Assign property into common\n      if (childSplit.common !== undefined) {\n        accumulated = mergeSplitResults(accumulated, {\n          common: { [key]: childSplit.common } as unknown as ContentNode,\n        });\n      }\n\n      // Assign property into each locale bucket\n      for (const locale of Object.keys(childSplit)) {\n        if (locale === 'common') continue;\n        accumulated = mergeSplitResults(accumulated, {\n          // @ts-ignore dynamic locale key\n          [locale]: { [key]: childSplit[locale] } as unknown as ContentNode,\n        });\n      }\n    }\n\n    return accumulated;\n  }\n\n  // Primitives or typed nodes (non-translation): entirely common\n  return { common: node } as SplitResult;\n};\n\nexport const getSplittedContent = (\n  content: ContentNode\n): SplittedContentOutput => {\n  const split = splitNode(content);\n\n  // Build final output with only defined sections\n  const output: Record<string, ContentNode> = {};\n  if (split.common !== undefined) {\n    output.common = split.common;\n  }\n  for (const key of Object.keys(split)) {\n    if (key === 'common') continue;\n    const value = split[key] as ContentNode | undefined;\n    if (value !== undefined) {\n      output[key] = value;\n    }\n  }\n\n  return output as unknown as SplittedContentOutput;\n};\n\n/**\n * Splits the `content` field of a Dictionary into \"common\" and per-locale buckets.\n *\n * Given a dictionary like:\n * ```js\n * {\n *   key: \"my-key\",\n *   content: {\n *     commonContent: \"common content\",\n *     multilingualContent: t({\n *       en: \"english content\",\n *       fr: \"french content\",\n *       de: \"german content\",\n *     }),\n *   },\n * }\n * ```\n *\n * It produces:\n * ```js\n * {\n *   common: { commonContent: \"common content\" },\n *   en: { multilingualContent: \"english content\" },\n *   fr: { multilingualContent: \"french content\" },\n *   de: { multilingualContent: \"german content\" },\n * }\n * ```\n *\n * @param dictionary - The input dictionary object with possible multilingual or common content.\n * @returns An object mapping \"common\" and each locale to their corresponding content subtrees.\n */\nexport const getSplittedDictionaryContent = (\n  dictionary: Dictionary\n): SplittedContentOutput<Dictionary['content']> =>\n  getSplittedContent(dictionary.content);\n"],"mappings":"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"}
+{"version":3,"file":"getSplittedContent.mjs","names":[],"sources":["../../../src/deepTransformPlugins/getSplittedContent.ts"],"sourcesContent":["import type { ContentNode, Dictionary } from '@intlayer/types/dictionary';\nimport type { DeclaredLocales } from '@intlayer/types/module_augmentation';\nimport * as NodeTypes from '@intlayer/types/nodeType';\n\ntype SplittedContentOutput<T = ContentNode> = Record<DeclaredLocales, T> & {\n  common: T;\n};\n\ntype SplitResult = Record<string, ContentNode | undefined> & {\n  common?: ContentNode;\n};\n\nconst isObject = (value: unknown): value is Record<string, any> =>\n  typeof value === 'object' && value !== null && !Array.isArray(value);\n\nconst hasNodeType = (value: unknown): value is { nodeType: string } =>\n  isObject(value) && typeof (value as any).nodeType === 'string';\n\nconst mergeValues = (\n  a: ContentNode | undefined,\n  b: ContentNode | undefined\n): ContentNode | undefined => {\n  if (a === undefined) return b;\n  if (b === undefined) return a;\n\n  if (Array.isArray(a) && Array.isArray(b)) {\n    // Concatenate arrays when merging sibling results\n    return [...a, ...b] as unknown as ContentNode;\n  }\n\n  if (isObject(a) && isObject(b) && !hasNodeType(a) && !hasNodeType(b)) {\n    const result: Record<string, any> = { ...a };\n    for (const key of Object.keys(b)) {\n      result[key] = mergeValues(\n        result[key] as unknown as ContentNode | undefined,\n        (b as Record<string, any>)[key] as unknown as ContentNode | undefined\n      );\n    }\n    return result as ContentNode;\n  }\n\n  // For primitives or differing structures, prefer b (more recent)\n  return b;\n};\n\nconst mergeSplitResults = (\n  base: SplitResult,\n  addition: SplitResult\n): SplitResult => {\n  const result: SplitResult = { ...base };\n\n  // Merge common\n  result.common = mergeValues(base.common, addition.common);\n\n  // Merge each locale key present in either side\n  const localeKeys = new Set<string>([\n    ...Object.keys(base).filter((k) => k !== 'common'),\n    ...Object.keys(addition).filter((k) => k !== 'common'),\n  ]);\n\n  for (const key of localeKeys) {\n    // @ts-ignore: dynamic keys for locales\n    result[key] = mergeValues(\n      base[key] as ContentNode | undefined,\n      addition[key] as ContentNode | undefined\n    );\n  }\n\n  return result;\n};\n\nconst splitNode = (node: ContentNode): SplitResult => {\n  // Translation node: allocate entirely to per-locale buckets\n  if (isObject(node) && (node as any)?.nodeType === NodeTypes.TRANSLATION) {\n    const translations = (node as any)[NodeTypes.TRANSLATION] as Record<\n      string,\n      ContentNode\n    >;\n\n    const result: SplitResult = {};\n    for (const locale of Object.keys(translations)) {\n      const child = translations[locale];\n      const childSplit = splitNode(child);\n\n      // The content under a translation belongs to the locale, not common\n      // Merge common portion of the child (if any) into the locale as well\n      const mergedForLocale = mergeValues(childSplit.common, undefined);\n\n      // Compose locale content: prefer the fully rebuilt child by resolving deeper translations recursively\n      // which are already split inside childSplit. We need to recompose a single node for this locale.\n      // Recompose by merging all keys in childSplit except 'common' into a single node, then merge child's common.\n      let recomposed: ContentNode | undefined;\n      for (const key of Object.keys(childSplit)) {\n        if (key === 'common') continue;\n        recomposed = mergeValues(\n          recomposed,\n          childSplit[key] as ContentNode | undefined\n        );\n      }\n      const finalLocaleNode = mergeValues(mergedForLocale, recomposed);\n\n      if (finalLocaleNode !== undefined) {\n        // @ts-ignore dynamic locale key\n        result[locale] = finalLocaleNode;\n      }\n    }\n\n    return result;\n  }\n\n  // Arrays: split each element and merge results index-wise\n  if (Array.isArray(node)) {\n    const commonArray: any[] = [];\n    const perLocaleArrays: Record<string, any[]> = {};\n\n    node.forEach((child) => {\n      const childSplit = splitNode(child as ContentNode);\n\n      if (childSplit.common !== undefined) {\n        commonArray.push(childSplit.common);\n      }\n\n      for (const key of Object.keys(childSplit)) {\n        if (key === 'common') continue;\n        if (!perLocaleArrays[key]) perLocaleArrays[key] = [];\n        const value = childSplit[key];\n        if (value !== undefined) perLocaleArrays[key].push(value);\n      }\n    });\n\n    const result: SplitResult = {};\n    if (commonArray.length > 0)\n      result.common = commonArray as unknown as ContentNode;\n    for (const key of Object.keys(perLocaleArrays)) {\n      // @ts-ignore dynamic locale key\n      result[key] = perLocaleArrays[key] as unknown as ContentNode;\n    }\n    return result;\n  }\n\n  // Objects (non-typed): recursively split properties\n  if (isObject(node) && !hasNodeType(node)) {\n    let accumulated: SplitResult = {};\n\n    for (const key of Object.keys(node)) {\n      const childSplit = splitNode((node as any)[key] as ContentNode);\n\n      // Assign property into common\n      if (childSplit.common !== undefined) {\n        accumulated = mergeSplitResults(accumulated, {\n          common: { [key]: childSplit.common } as unknown as ContentNode,\n        });\n      }\n\n      // Assign property into each locale bucket\n      for (const locale of Object.keys(childSplit)) {\n        if (locale === 'common') continue;\n        accumulated = mergeSplitResults(accumulated, {\n          // @ts-ignore dynamic locale key\n          [locale]: { [key]: childSplit[locale] } as unknown as ContentNode,\n        });\n      }\n    }\n\n    return accumulated;\n  }\n\n  // Primitives or typed nodes (non-translation): entirely common\n  return { common: node } as SplitResult;\n};\n\nexport const getSplittedContent = (\n  content: ContentNode\n): SplittedContentOutput => {\n  const split = splitNode(content);\n\n  // Build final output with only defined sections\n  const output: Record<string, ContentNode> = {};\n  if (split.common !== undefined) {\n    output.common = split.common;\n  }\n  for (const key of Object.keys(split)) {\n    if (key === 'common') continue;\n    const value = split[key] as ContentNode | undefined;\n    if (value !== undefined) {\n      output[key] = value;\n    }\n  }\n\n  return output as unknown as SplittedContentOutput;\n};\n\n/**\n * Splits the `content` field of a Dictionary into \"common\" and per-locale buckets.\n *\n * Given a dictionary like:\n * ```js\n * {\n *   key: \"my-key\",\n *   content: {\n *     commonContent: \"common content\",\n *     multilingualContent: t({\n *       en: \"english content\",\n *       fr: \"french content\",\n *       de: \"german content\",\n *     }),\n *   },\n * }\n * ```\n *\n * It produces:\n * ```js\n * {\n *   common: { commonContent: \"common content\" },\n *   en: { multilingualContent: \"english content\" },\n *   fr: { multilingualContent: \"french content\" },\n *   de: { multilingualContent: \"german content\" },\n * }\n * ```\n *\n * @param dictionary - The input dictionary object with possible multilingual or common content.\n * @returns An object mapping \"common\" and each locale to their corresponding content subtrees.\n */\nexport const getSplittedDictionaryContent = (\n  dictionary: Dictionary\n): SplittedContentOutput<Dictionary['content']> =>\n  getSplittedContent(dictionary.content);\n"],"mappings":"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"}

package/dist/esm/deepTransformPlugins/index.mjs

@@ -1 +1,12 @@
-import{getFilteredLocalesContent as e,getFilteredLocalesDictionary as t}from"./getFilteredLocalesContent.mjs";import{filterMissingTranslationsOnlyPlugin as n,getFilterMissingTranslationsContent as r,getFilterMissingTranslationsDictionary as i}from"./getFilterMissingTranslationsContent.mjs";import{filterTranslationsOnlyPlugin as a,getFilterTranslationsOnlyContent as o,getFilterTranslationsOnlyDictionary as s}from"./getFilterTranslationsOnlyContent.mjs";import{getLocalizedContent as c,getPerLocaleDictionary as l}from"./getLocalizedContent.mjs";import{buildMaskPlugin as u,getMaskContent as d}from"./getMaskContent.mjs";import{checkMissingLocalesPlugin as f,getMissingLocalesContent as p,getMissingLocalesContentFromDictionary as m}from"./getMissingLocalesContent.mjs";import{getMultilingualDictionary as h}from"./getMultilingualDictionary.mjs";import{getReplacedValuesContent as g}from"./getReplacedValuesContent.mjs";import{getSplittedContent as _,getSplittedDictionaryContent as v}from"./getSplittedContent.mjs";import{insertContentInDictionary as y}from"./insertContentInDictionary.mjs";export{u as buildMaskPlugin,f as checkMissingLocalesPlugin,n as filterMissingTranslationsOnlyPlugin,a as filterTranslationsOnlyPlugin,r as getFilterMissingTranslationsContent,i as getFilterMissingTranslationsDictionary,o as getFilterTranslationsOnlyContent,s as getFilterTranslationsOnlyDictionary,e as getFilteredLocalesContent,t as getFilteredLocalesDictionary,c as getLocalizedContent,d as getMaskContent,p as getMissingLocalesContent,m as getMissingLocalesContentFromDictionary,h as getMultilingualDictionary,l as getPerLocaleDictionary,g as getReplacedValuesContent,_ as getSplittedContent,v as getSplittedDictionaryContent,y as insertContentInDictionary};
+import { getFilteredLocalesContent, getFilteredLocalesDictionary } from "./getFilteredLocalesContent.mjs";
+import { filterMissingTranslationsOnlyPlugin, getFilterMissingTranslationsContent, getFilterMissingTranslationsDictionary } from "./getFilterMissingTranslationsContent.mjs";
+import { filterTranslationsOnlyPlugin, getFilterTranslationsOnlyContent, getFilterTranslationsOnlyDictionary } from "./getFilterTranslationsOnlyContent.mjs";
+import { getLocalizedContent, getPerLocaleDictionary } from "./getLocalizedContent.mjs";
+import { buildMaskPlugin, getMaskContent } from "./getMaskContent.mjs";
+import { checkMissingLocalesPlugin, getMissingLocalesContent, getMissingLocalesContentFromDictionary } from "./getMissingLocalesContent.mjs";
+import { getMultilingualDictionary } from "./getMultilingualDictionary.mjs";
+import { getReplacedValuesContent } from "./getReplacedValuesContent.mjs";
+import { getSplittedContent, getSplittedDictionaryContent } from "./getSplittedContent.mjs";
+import { insertContentInDictionary } from "./insertContentInDictionary.mjs";
+
+export { buildMaskPlugin, checkMissingLocalesPlugin, filterMissingTranslationsOnlyPlugin, filterTranslationsOnlyPlugin, getFilterMissingTranslationsContent, getFilterMissingTranslationsDictionary, getFilterTranslationsOnlyContent, getFilterTranslationsOnlyDictionary, getFilteredLocalesContent, getFilteredLocalesDictionary, getLocalizedContent, getMaskContent, getMissingLocalesContent, getMissingLocalesContentFromDictionary, getMultilingualDictionary, getPerLocaleDictionary, getReplacedValuesContent, getSplittedContent, getSplittedDictionaryContent, insertContentInDictionary };