@intlayer/editor-react 7.0.2-canary.0 → 7.0.2

package/dist/cjs/EditedContentContext.cjs

@@ -5,6 +5,7 @@ const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
 const require_useCrossFrameMessageListener = require('./useCrossFrameMessageListener.cjs');
 const require_useCrossFrameState = require('./useCrossFrameState.cjs');
 const require_DictionariesRecordContext = require('./DictionariesRecordContext.cjs');
+const require_useEditorLocale = require('./useEditorLocale.cjs');
 let react = require("react");
 react = require_rolldown_runtime.__toESM(react);
 let react_jsx_runtime = require("react/jsx-runtime");
@@ -13,6 +14,8 @@ let __intlayer_editor = require("@intlayer/editor");
 __intlayer_editor = require_rolldown_runtime.__toESM(__intlayer_editor);
 let __intlayer_core = require("@intlayer/core");
 __intlayer_core = require_rolldown_runtime.__toESM(__intlayer_core);
+let __intlayer_types = require("@intlayer/types");
+__intlayer_types = require_rolldown_runtime.__toESM(__intlayer_types);
 
 //#region src/EditedContentContext.tsx
 const EditedContentStateContext = (0, react.createContext)(void 0);
@@ -22,6 +25,7 @@ const EditedContentActionsContext = (0, react.createContext)(void 0);
 const resolveState = (state, prevState) => typeof state === "function" ? state(prevState) : state;
 const EditedContentProvider = ({ children }) => {
 	const { localeDictionaries } = require_DictionariesRecordContext.useDictionariesRecord();
+	const currentLocale = require_useEditorLocale.useEditorLocale();
 	const [editedContent, setEditedContentState] = require_useCrossFrameState.useCrossFrameState(__intlayer_editor.MessageKey.INTLAYER_EDITED_CONTENT_CHANGED);
 	const setEditedDictionary = (newValue) => {
 		let updatedDictionaries = resolveState(newValue);
@@ -125,10 +129,11 @@ const EditedContentProvider = ({ children }) => {
 	};
 	const getEditedContentValue = (localDictionaryIdOrKey, keyPath) => {
 		if (!editedContent) return void 0;
-		if (localDictionaryIdOrKey.includes(":local:") || localDictionaryIdOrKey.includes(":remote:")) return (0, __intlayer_core.getContentNodeByKeyPath)(editedContent?.[localDictionaryIdOrKey]?.content ?? {}, keyPath);
+		const filteredKeyPath = keyPath.filter((key) => key.type !== __intlayer_types.NodeType.Translation);
+		if (localDictionaryIdOrKey.includes(":local:") || localDictionaryIdOrKey.includes(":remote:")) return (0, __intlayer_core.getContentNodeByKeyPath)(editedContent?.[localDictionaryIdOrKey]?.content ?? {}, filteredKeyPath, currentLocale);
 		const filteredDictionariesLocalId = Object.keys(editedContent).filter((key) => key.startsWith(`${localDictionaryIdOrKey}:`));
 		for (const localDictionaryId of filteredDictionariesLocalId) {
-			const contentNode = (0, __intlayer_core.getContentNodeByKeyPath)(editedContent?.[localDictionaryId]?.content ?? {}, keyPath);
+			const contentNode = (0, __intlayer_core.getContentNodeByKeyPath)(editedContent?.[localDictionaryId]?.content ?? {}, filteredKeyPath, currentLocale);
 			if (contentNode) return contentNode;
 		}
 	};

package/dist/cjs/EditedContentContext.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"EditedContentContext.cjs","names":["useCrossFrameMessageListener","MessageKey","EditedContentProvider: FC<PropsWithChildren>","useDictionariesRecord","useCrossFrameState","setEditedDictionary: Dispatch<SetStateAction<Dictionary>>","updatedDictionaries: Dictionary","lastKeyPath: KeyPath"],"sources":["../../src/EditedContentContext.tsx"],"sourcesContent":["'use client';\n\nimport {\n  editDictionaryByKeyPath,\n  getContentNodeByKeyPath,\n  renameContentNodeByKeyPath,\n} from '@intlayer/core';\nimport { MessageKey } from '@intlayer/editor';\nimport type {\n  ContentNode,\n  Dictionary,\n  KeyPath,\n  LocalDictionaryId,\n} from '@intlayer/types';\nimport {\n  createContext,\n  type Dispatch,\n  type FC,\n  type PropsWithChildren,\n  type SetStateAction,\n  useContext,\n} from 'react';\nimport {\n  type DictionaryContent,\n  useDictionariesRecord,\n} from './DictionariesRecordContext';\nimport { useCrossFrameMessageListener } from './useCrossFrameMessageListener';\nimport { useCrossFrameState } from './useCrossFrameState';\n\ntype EditedContentStateContextType = {\n  editedContent: Record<LocalDictionaryId, Dictionary> | undefined;\n};\n\nconst EditedContentStateContext = createContext<\n  EditedContentStateContextType | undefined\n>(undefined);\n\nexport const usePostEditedContentState = <S,>(\n  onEventTriggered?: (data: S) => void\n) =>\n  useCrossFrameMessageListener(\n    `${MessageKey.INTLAYER_EDITED_CONTENT_CHANGED}/post`,\n    onEventTriggered\n  );\n\nexport const useGetEditedContentState = <S,>(\n  onEventTriggered?: (data: S) => void\n) =>\n  useCrossFrameMessageListener(\n    `${MessageKey.INTLAYER_EDITED_CONTENT_CHANGED}/get`,\n    onEventTriggered\n  );\n\ntype EditedContentActionsContextType = {\n  setEditedContentState: (editedContent: DictionaryContent) => void;\n  setEditedDictionary: Dispatch<SetStateAction<Dictionary>>;\n  setEditedContent: (\n    localDictionaryId: LocalDictionaryId,\n    newValue: Dictionary['content']\n  ) => void;\n  addEditedContent: (\n    localDictionaryId: LocalDictionaryId,\n    newValue: ContentNode<any>,\n    keyPath?: KeyPath[],\n    overwrite?: boolean\n  ) => void;\n  renameEditedContent: (\n    localDictionaryId: LocalDictionaryId,\n    newKey: KeyPath['key'],\n    keyPath?: KeyPath[]\n  ) => void;\n  removeEditedContent: (\n    localDictionaryId: LocalDictionaryId,\n    keyPath: KeyPath[]\n  ) => void;\n  restoreEditedContent: (localDictionaryId: LocalDictionaryId) => void;\n  clearEditedDictionaryContent: (localDictionaryId: LocalDictionaryId) => void;\n  clearEditedContent: () => void;\n  getEditedContentValue: (\n    localDictionaryIdOrKey: LocalDictionaryId | Dictionary['key'] | string,\n    keyPath: KeyPath[]\n  ) => ContentNode | undefined;\n};\n\nconst EditedContentActionsContext = createContext<\n  EditedContentActionsContextType | undefined\n>(undefined);\n\nconst resolveState = <S,>(state?: SetStateAction<S>, prevState?: S): S =>\n  typeof state === 'function'\n    ? (state as (prevState?: S) => S)(prevState)\n    : (state as S);\n\nexport const EditedContentProvider: FC<PropsWithChildren> = ({ children }) => {\n  const { localeDictionaries } = useDictionariesRecord();\n\n  const [editedContent, setEditedContentState] =\n    useCrossFrameState<DictionaryContent>(\n      MessageKey.INTLAYER_EDITED_CONTENT_CHANGED\n    );\n\n  const setEditedDictionary: Dispatch<SetStateAction<Dictionary>> = (\n    newValue\n  ) => {\n    let updatedDictionaries: Dictionary = resolveState(newValue);\n\n    setEditedContentState((prev) => {\n      if (!updatedDictionaries.localId) {\n        console.error('no localId', updatedDictionaries);\n\n        return prev;\n      }\n\n      updatedDictionaries = resolveState(\n        newValue,\n        prev?.[updatedDictionaries.localId]\n      );\n\n      return {\n        ...prev,\n        [updatedDictionaries.localId as LocalDictionaryId]: updatedDictionaries,\n      };\n    });\n\n    return updatedDictionaries;\n  };\n\n  const setEditedContent = (\n    localDictionaryId: LocalDictionaryId,\n    newValue: Dictionary['content']\n  ) => {\n    setEditedContentState((prev) => ({\n      ...prev,\n      [localDictionaryId]: {\n        ...prev?.[localDictionaryId],\n        content: newValue,\n      },\n    }));\n  };\n\n  const addEditedContent = (\n    localDictionaryId: LocalDictionaryId,\n    newValue: ContentNode,\n    keyPath: KeyPath[] = [],\n    overwrite: boolean = true\n  ) => {\n    setEditedContentState((prev) => {\n      // Get the starting content: edited version if available, otherwise a deep copy of the original\n      const originalContent = localeDictionaries[localDictionaryId]?.content;\n      const currentContent = structuredClone(\n        prev?.[localDictionaryId]?.content ?? originalContent\n      );\n\n      let newKeyPath = keyPath;\n      if (!overwrite) {\n        // Find a unique key based on the keyPath provided\n        let index = 0;\n        const otherKeyPath = keyPath.slice(0, -1);\n        const lastKeyPath: KeyPath = keyPath[keyPath.length - 1];\n        let finalKey = lastKeyPath.key;\n\n        // Loop until we find a key that does not exist\n        while (\n          typeof getContentNodeByKeyPath(currentContent, newKeyPath) !==\n          'undefined'\n        ) {\n          index++;\n          finalKey =\n            index === 0 ? lastKeyPath.key : `${lastKeyPath.key} (${index})`;\n          newKeyPath = [\n            ...otherKeyPath,\n            { ...lastKeyPath, key: finalKey } as KeyPath,\n          ];\n        }\n      }\n\n      const updatedContent = editDictionaryByKeyPath(\n        currentContent,\n        newKeyPath,\n        newValue\n      );\n\n      return {\n        ...prev,\n        [localDictionaryId]: {\n          ...prev?.[localDictionaryId],\n          content: updatedContent as Dictionary['content'],\n        },\n      };\n    });\n  };\n\n  const renameEditedContent = (\n    localDictionaryId: LocalDictionaryId,\n    newKey: KeyPath['key'],\n    keyPath: KeyPath[] = []\n  ) => {\n    setEditedContentState((prev) => {\n      // Retrieve the base content: use edited version if available, otherwise deep copy of original\n      const originalContent = localeDictionaries[localDictionaryId]?.content;\n      const currentContent = structuredClone(\n        prev?.[localDictionaryId]?.content ?? originalContent\n      );\n\n      const contentWithNewField = renameContentNodeByKeyPath(\n        currentContent,\n        newKey,\n        keyPath\n      );\n\n      return {\n        ...prev,\n        [localDictionaryId]: {\n          ...prev?.[localDictionaryId],\n          content: contentWithNewField as Dictionary['content'],\n        },\n      };\n    });\n  };\n\n  const removeEditedContent = (\n    localDictionaryId: LocalDictionaryId,\n    keyPath: KeyPath[]\n  ) => {\n    setEditedContentState((prev) => {\n      // Retrieve the original content as reference\n      const originalContent = localeDictionaries[localDictionaryId]?.content;\n      const currentContent = structuredClone(\n        prev?.[localDictionaryId]?.content ?? originalContent\n      );\n\n      // Get the initial value from the original dictionary content\n      const initialContent = getContentNodeByKeyPath(originalContent, keyPath);\n\n      // Restore the value at the given keyPath\n      const restoredContent = editDictionaryByKeyPath(\n        currentContent,\n        keyPath,\n        initialContent\n      );\n\n      return {\n        ...prev,\n        [localDictionaryId]: {\n          ...prev?.[localDictionaryId],\n          content: restoredContent as Dictionary['content'],\n        },\n      };\n    });\n  };\n\n  const restoreEditedContent = (localDictionaryId: LocalDictionaryId) => {\n    setEditedContentState((prev) => {\n      const updated = { ...prev };\n      delete updated[localDictionaryId];\n      return updated;\n    });\n  };\n\n  const clearEditedDictionaryContent = (\n    localDictionaryId: LocalDictionaryId\n  ) => {\n    setEditedContentState((prev) => {\n      const filtered = Object.entries(prev).reduce((acc, [key, value]) => {\n        if (key === localDictionaryId) {\n          return acc;\n        }\n        return { ...acc, [key]: value };\n      }, {} as DictionaryContent);\n      return filtered;\n    });\n  };\n\n  const clearEditedContent = () => {\n    setEditedContentState({});\n  };\n\n  const getEditedContentValue = (\n    localDictionaryIdOrKey: LocalDictionaryId | Dictionary['key'] | string,\n    keyPath: KeyPath[]\n  ): ContentNode | undefined => {\n    if (!editedContent) return undefined;\n\n    const isDictionaryId =\n      localDictionaryIdOrKey.includes(':local:') ||\n      localDictionaryIdOrKey.includes(':remote:');\n\n    if (isDictionaryId) {\n      const currentContent =\n        editedContent?.[localDictionaryIdOrKey as LocalDictionaryId]?.content ??\n        {};\n\n      const contentNode = getContentNodeByKeyPath(currentContent, keyPath);\n\n      return contentNode;\n    }\n\n    const filteredDictionariesLocalId = Object.keys(editedContent).filter(\n      (key) => key.startsWith(`${localDictionaryIdOrKey}:`)\n    );\n\n    for (const localDictionaryId of filteredDictionariesLocalId) {\n      const currentContent =\n        editedContent?.[localDictionaryId as LocalDictionaryId]?.content ?? {};\n      const contentNode = getContentNodeByKeyPath(currentContent, keyPath);\n\n      if (contentNode) return contentNode;\n    }\n\n    return undefined;\n  };\n\n  return (\n    <EditedContentStateContext.Provider\n      value={{\n        editedContent,\n      }}\n    >\n      <EditedContentActionsContext.Provider\n        value={{\n          setEditedContentState,\n          setEditedDictionary,\n          setEditedContent,\n          addEditedContent,\n          renameEditedContent,\n          removeEditedContent,\n          restoreEditedContent,\n          clearEditedDictionaryContent,\n          clearEditedContent,\n          getEditedContentValue,\n        }}\n      >\n        {children}\n      </EditedContentActionsContext.Provider>\n    </EditedContentStateContext.Provider>\n  );\n};\n\nexport const useEditedContentActions = () =>\n  useContext(EditedContentActionsContext);\n\nexport const useEditedContent = () => {\n  const stateContext = useContext(EditedContentStateContext);\n  const actionContext = useEditedContentActions();\n\n  return { ...stateContext, ...actionContext };\n};\n"],"mappings":"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"}
+{"version":3,"file":"EditedContentContext.cjs","names":["useCrossFrameMessageListener","MessageKey","EditedContentProvider: FC<PropsWithChildren>","useDictionariesRecord","useEditorLocale","useCrossFrameState","setEditedDictionary: Dispatch<SetStateAction<Dictionary>>","updatedDictionaries: Dictionary","lastKeyPath: KeyPath","NodeType"],"sources":["../../src/EditedContentContext.tsx"],"sourcesContent":["'use client';\n\nimport {\n  editDictionaryByKeyPath,\n  getContentNodeByKeyPath,\n  renameContentNodeByKeyPath,\n} from '@intlayer/core';\nimport { MessageKey } from '@intlayer/editor';\nimport {\n  type ContentNode,\n  type Dictionary,\n  type KeyPath,\n  type LocalDictionaryId,\n  NodeType,\n} from '@intlayer/types';\nimport {\n  createContext,\n  type Dispatch,\n  type FC,\n  type PropsWithChildren,\n  type SetStateAction,\n  useContext,\n} from 'react';\nimport {\n  type DictionaryContent,\n  useDictionariesRecord,\n} from './DictionariesRecordContext';\nimport { useCrossFrameMessageListener } from './useCrossFrameMessageListener';\nimport { useCrossFrameState } from './useCrossFrameState';\nimport { useEditorLocale } from './useEditorLocale';\n\ntype EditedContentStateContextType = {\n  editedContent: Record<LocalDictionaryId, Dictionary> | undefined;\n};\n\nconst EditedContentStateContext = createContext<\n  EditedContentStateContextType | undefined\n>(undefined);\n\nexport const usePostEditedContentState = <S,>(\n  onEventTriggered?: (data: S) => void\n) =>\n  useCrossFrameMessageListener(\n    `${MessageKey.INTLAYER_EDITED_CONTENT_CHANGED}/post`,\n    onEventTriggered\n  );\n\nexport const useGetEditedContentState = <S,>(\n  onEventTriggered?: (data: S) => void\n) =>\n  useCrossFrameMessageListener(\n    `${MessageKey.INTLAYER_EDITED_CONTENT_CHANGED}/get`,\n    onEventTriggered\n  );\n\ntype EditedContentActionsContextType = {\n  setEditedContentState: (editedContent: DictionaryContent) => void;\n  setEditedDictionary: Dispatch<SetStateAction<Dictionary>>;\n  setEditedContent: (\n    localDictionaryId: LocalDictionaryId,\n    newValue: Dictionary['content']\n  ) => void;\n  addEditedContent: (\n    localDictionaryId: LocalDictionaryId,\n    newValue: ContentNode<any>,\n    keyPath?: KeyPath[],\n    overwrite?: boolean\n  ) => void;\n  renameEditedContent: (\n    localDictionaryId: LocalDictionaryId,\n    newKey: KeyPath['key'],\n    keyPath?: KeyPath[]\n  ) => void;\n  removeEditedContent: (\n    localDictionaryId: LocalDictionaryId,\n    keyPath: KeyPath[]\n  ) => void;\n  restoreEditedContent: (localDictionaryId: LocalDictionaryId) => void;\n  clearEditedDictionaryContent: (localDictionaryId: LocalDictionaryId) => void;\n  clearEditedContent: () => void;\n  getEditedContentValue: (\n    localDictionaryIdOrKey: LocalDictionaryId | Dictionary['key'] | string,\n    keyPath: KeyPath[]\n  ) => ContentNode | undefined;\n};\n\nconst EditedContentActionsContext = createContext<\n  EditedContentActionsContextType | undefined\n>(undefined);\n\nconst resolveState = <S,>(state?: SetStateAction<S>, prevState?: S): S =>\n  typeof state === 'function'\n    ? (state as (prevState?: S) => S)(prevState)\n    : (state as S);\n\nexport const EditedContentProvider: FC<PropsWithChildren> = ({ children }) => {\n  const { localeDictionaries } = useDictionariesRecord();\n  const currentLocale = useEditorLocale();\n\n  const [editedContent, setEditedContentState] =\n    useCrossFrameState<DictionaryContent>(\n      MessageKey.INTLAYER_EDITED_CONTENT_CHANGED\n    );\n\n  const setEditedDictionary: Dispatch<SetStateAction<Dictionary>> = (\n    newValue\n  ) => {\n    let updatedDictionaries: Dictionary = resolveState(newValue);\n\n    setEditedContentState((prev) => {\n      if (!updatedDictionaries.localId) {\n        console.error('no localId', updatedDictionaries);\n\n        return prev;\n      }\n\n      updatedDictionaries = resolveState(\n        newValue,\n        prev?.[updatedDictionaries.localId]\n      );\n\n      return {\n        ...prev,\n        [updatedDictionaries.localId as LocalDictionaryId]: updatedDictionaries,\n      };\n    });\n\n    return updatedDictionaries;\n  };\n\n  const setEditedContent = (\n    localDictionaryId: LocalDictionaryId,\n    newValue: Dictionary['content']\n  ) => {\n    setEditedContentState((prev) => ({\n      ...prev,\n      [localDictionaryId]: {\n        ...prev?.[localDictionaryId],\n        content: newValue,\n      },\n    }));\n  };\n\n  const addEditedContent = (\n    localDictionaryId: LocalDictionaryId,\n    newValue: ContentNode,\n    keyPath: KeyPath[] = [],\n    overwrite: boolean = true\n  ) => {\n    setEditedContentState((prev) => {\n      // Get the starting content: edited version if available, otherwise a deep copy of the original\n      const originalContent = localeDictionaries[localDictionaryId]?.content;\n      const currentContent = structuredClone(\n        prev?.[localDictionaryId]?.content ?? originalContent\n      );\n\n      let newKeyPath = keyPath;\n      if (!overwrite) {\n        // Find a unique key based on the keyPath provided\n        let index = 0;\n\n        const otherKeyPath = keyPath.slice(0, -1);\n        const lastKeyPath: KeyPath = keyPath[keyPath.length - 1];\n\n        let finalKey = lastKeyPath.key;\n\n        // Loop until we find a key that does not exist\n        while (\n          typeof getContentNodeByKeyPath(currentContent, newKeyPath) !==\n          'undefined'\n        ) {\n          index++;\n          finalKey =\n            index === 0 ? lastKeyPath.key : `${lastKeyPath.key} (${index})`;\n          newKeyPath = [\n            ...otherKeyPath,\n            { ...lastKeyPath, key: finalKey } as KeyPath,\n          ];\n        }\n      }\n\n      const updatedContent = editDictionaryByKeyPath(\n        currentContent,\n        newKeyPath,\n        newValue\n      );\n\n      return {\n        ...prev,\n        [localDictionaryId]: {\n          ...prev?.[localDictionaryId],\n          content: updatedContent as Dictionary['content'],\n        },\n      };\n    });\n  };\n\n  const renameEditedContent = (\n    localDictionaryId: LocalDictionaryId,\n    newKey: KeyPath['key'],\n    keyPath: KeyPath[] = []\n  ) => {\n    setEditedContentState((prev) => {\n      // Retrieve the base content: use edited version if available, otherwise deep copy of original\n      const originalContent = localeDictionaries[localDictionaryId]?.content;\n      const currentContent = structuredClone(\n        prev?.[localDictionaryId]?.content ?? originalContent\n      );\n\n      const contentWithNewField = renameContentNodeByKeyPath(\n        currentContent,\n        newKey,\n        keyPath\n      );\n\n      return {\n        ...prev,\n        [localDictionaryId]: {\n          ...prev?.[localDictionaryId],\n          content: contentWithNewField as Dictionary['content'],\n        },\n      };\n    });\n  };\n\n  const removeEditedContent = (\n    localDictionaryId: LocalDictionaryId,\n    keyPath: KeyPath[]\n  ) => {\n    setEditedContentState((prev) => {\n      // Retrieve the original content as reference\n      const originalContent = localeDictionaries[localDictionaryId]?.content;\n      const currentContent = structuredClone(\n        prev?.[localDictionaryId]?.content ?? originalContent\n      );\n\n      // Get the initial value from the original dictionary content\n      const initialContent = getContentNodeByKeyPath(originalContent, keyPath);\n\n      // Restore the value at the given keyPath\n      const restoredContent = editDictionaryByKeyPath(\n        currentContent,\n        keyPath,\n        initialContent\n      );\n\n      return {\n        ...prev,\n        [localDictionaryId]: {\n          ...prev?.[localDictionaryId],\n          content: restoredContent as Dictionary['content'],\n        },\n      };\n    });\n  };\n\n  const restoreEditedContent = (localDictionaryId: LocalDictionaryId) => {\n    setEditedContentState((prev) => {\n      const updated = { ...prev };\n      delete updated[localDictionaryId];\n      return updated;\n    });\n  };\n\n  const clearEditedDictionaryContent = (\n    localDictionaryId: LocalDictionaryId\n  ) => {\n    setEditedContentState((prev) => {\n      const filtered = Object.entries(prev).reduce((acc, [key, value]) => {\n        if (key === localDictionaryId) {\n          return acc;\n        }\n        return { ...acc, [key]: value };\n      }, {} as DictionaryContent);\n      return filtered;\n    });\n  };\n\n  const clearEditedContent = () => {\n    setEditedContentState({});\n  };\n\n  const getEditedContentValue = (\n    localDictionaryIdOrKey: LocalDictionaryId | Dictionary['key'] | string,\n    keyPath: KeyPath[]\n  ): ContentNode | undefined => {\n    if (!editedContent) return undefined;\n\n    const filteredKeyPath = keyPath.filter(\n      (key) => key.type !== NodeType.Translation\n    );\n\n    const isDictionaryId =\n      localDictionaryIdOrKey.includes(':local:') ||\n      localDictionaryIdOrKey.includes(':remote:');\n\n    if (isDictionaryId) {\n      const currentContent =\n        editedContent?.[localDictionaryIdOrKey as LocalDictionaryId]?.content ??\n        {};\n\n      const contentNode = getContentNodeByKeyPath(\n        currentContent,\n        filteredKeyPath,\n        currentLocale\n      );\n\n      return contentNode;\n    }\n\n    const filteredDictionariesLocalId = Object.keys(editedContent).filter(\n      (key) => key.startsWith(`${localDictionaryIdOrKey}:`)\n    );\n\n    for (const localDictionaryId of filteredDictionariesLocalId) {\n      const currentContent =\n        editedContent?.[localDictionaryId as LocalDictionaryId]?.content ?? {};\n      const contentNode = getContentNodeByKeyPath(\n        currentContent,\n        filteredKeyPath,\n        currentLocale\n      );\n\n      if (contentNode) return contentNode;\n    }\n\n    return undefined;\n  };\n\n  return (\n    <EditedContentStateContext.Provider\n      value={{\n        editedContent,\n      }}\n    >\n      <EditedContentActionsContext.Provider\n        value={{\n          setEditedContentState,\n          setEditedDictionary,\n          setEditedContent,\n          addEditedContent,\n          renameEditedContent,\n          removeEditedContent,\n          restoreEditedContent,\n          clearEditedDictionaryContent,\n          clearEditedContent,\n          getEditedContentValue,\n        }}\n      >\n        {children}\n      </EditedContentActionsContext.Provider>\n    </EditedContentStateContext.Provider>\n  );\n};\n\nexport const useEditedContentActions = () =>\n  useContext(EditedContentActionsContext);\n\nexport const useEditedContent = () => {\n  const stateContext = useContext(EditedContentStateContext);\n  const actionContext = useEditedContentActions();\n\n  return { ...stateContext, ...actionContext };\n};\n"],"mappings":"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"}

package/dist/cjs/FocusDictionaryContext copy.cjs

@@ -0,0 +1,57 @@
+'use client';
+
+
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_useCrossFrameState = require('./useCrossFrameState.cjs');
+let react = require("react");
+react = require_rolldown_runtime.__toESM(react);
+let react_jsx_runtime = require("react/jsx-runtime");
+react_jsx_runtime = require_rolldown_runtime.__toESM(react_jsx_runtime);
+let __intlayer_editor = require("@intlayer/editor");
+__intlayer_editor = require_rolldown_runtime.__toESM(__intlayer_editor);
+
+//#region src/FocusDictionaryContext copy.tsx
+const FocusDictionaryStateContext = (0, react.createContext)(void 0);
+const FocusDictionaryActionsContext = (0, react.createContext)(void 0);
+const FocusDictionaryProvider = ({ children }) => {
+	const [focusedContent, setFocusedContent] = require_useCrossFrameState.useCrossFrameState(__intlayer_editor.MessageKey.INTLAYER_FOCUSED_CONTENT_CHANGED, null);
+	const setFocusedContentKeyPath = (keyPath) => {
+		setFocusedContent((prev) => {
+			if (!prev) return prev;
+			return {
+				...prev,
+				keyPath
+			};
+		});
+	};
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(FocusDictionaryStateContext.Provider, {
+		value: { focusedContent },
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(FocusDictionaryActionsContext.Provider, {
+			value: {
+				setFocusedContent,
+				setFocusedContentKeyPath
+			},
+			children
+		})
+	});
+};
+const useFocusDictionaryActions = () => {
+	const context = (0, react.useContext)(FocusDictionaryActionsContext);
+	if (context === void 0) throw new Error("useFocusDictionaryActions must be used within a FocusDictionaryProvider");
+	return context;
+};
+const useFocusDictionary = () => {
+	const actionContext = useFocusDictionaryActions();
+	const stateContext = (0, react.useContext)(FocusDictionaryStateContext);
+	if (stateContext === void 0) throw new Error("useFocusDictionaryState must be used within a FocusDictionaryProvider");
+	return {
+		...stateContext,
+		...actionContext
+	};
+};
+
+//#endregion
+exports.FocusDictionaryProvider = FocusDictionaryProvider;
+exports.useFocusDictionary = useFocusDictionary;
+exports.useFocusDictionaryActions = useFocusDictionaryActions;
+//# sourceMappingURL=FocusDictionaryContext copy.cjs.map

package/dist/cjs/FocusDictionaryContext copy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"FocusDictionaryContext copy.cjs","names":["FocusDictionaryProvider: FC<PropsWithChildren>","useCrossFrameState","MessageKey"],"sources":["../../src/FocusDictionaryContext copy.tsx"],"sourcesContent":["'use client';\n\nimport { MessageKey } from '@intlayer/editor';\nimport type { KeyPath } from '@intlayer/types';\nimport {\n  createContext,\n  type Dispatch,\n  type FC,\n  type PropsWithChildren,\n  type SetStateAction,\n  useContext,\n} from 'react';\nimport { useCrossFrameState } from './useCrossFrameState';\n\nexport type FileContent = {\n  dictionaryKey: string;\n  dictionaryLocalId?: string;\n  keyPath?: KeyPath[];\n};\n\ntype FocusDictionaryState = {\n  focusedContent: FileContent | null;\n};\n\ntype FocusDictionaryActions = {\n  setFocusedContent: Dispatch<SetStateAction<FileContent | null>>;\n  setFocusedContentKeyPath: (keyPath: KeyPath[]) => void;\n};\n\nconst FocusDictionaryStateContext = createContext<\n  FocusDictionaryState | undefined\n>(undefined);\nconst FocusDictionaryActionsContext = createContext<\n  FocusDictionaryActions | undefined\n>(undefined);\n\nexport const FocusDictionaryProvider: FC<PropsWithChildren> = ({\n  children,\n}) => {\n  const [focusedContent, setFocusedContent] =\n    useCrossFrameState<FileContent | null>(\n      MessageKey.INTLAYER_FOCUSED_CONTENT_CHANGED,\n      null\n    );\n\n  const setFocusedContentKeyPath = (keyPath: KeyPath[]) => {\n    setFocusedContent((prev) => {\n      if (!prev) {\n        return prev; // nothing to update if there's no focused content\n      }\n      return { ...prev, keyPath };\n    });\n  };\n\n  return (\n    <FocusDictionaryStateContext.Provider value={{ focusedContent }}>\n      <FocusDictionaryActionsContext.Provider\n        value={{ setFocusedContent, setFocusedContentKeyPath }}\n      >\n        {children}\n      </FocusDictionaryActionsContext.Provider>\n    </FocusDictionaryStateContext.Provider>\n  );\n};\n\nexport const useFocusDictionaryActions = () => {\n  const context = useContext(FocusDictionaryActionsContext);\n  if (context === undefined) {\n    throw new Error(\n      'useFocusDictionaryActions must be used within a FocusDictionaryProvider'\n    );\n  }\n  return context;\n};\n\nexport const useFocusDictionary = () => {\n  const actionContext = useFocusDictionaryActions();\n  const stateContext = useContext(FocusDictionaryStateContext);\n\n  if (stateContext === undefined) {\n    throw new Error(\n      'useFocusDictionaryState must be used within a FocusDictionaryProvider'\n    );\n  }\n\n  return { ...stateContext, ...actionContext };\n};\n"],"mappings":";;;;;;;;;;;;;AA6BA,MAAM,uDAEJ,OAAU;AACZ,MAAM,yDAEJ,OAAU;AAEZ,MAAaA,2BAAkD,EAC7D,eACI;CACJ,MAAM,CAAC,gBAAgB,qBACrBC,8CACEC,6BAAW,kCACX,KACD;CAEH,MAAM,4BAA4B,YAAuB;AACvD,qBAAmB,SAAS;AAC1B,OAAI,CAAC,KACH,QAAO;AAET,UAAO;IAAE,GAAG;IAAM;IAAS;IAC3B;;AAGJ,QACE,2CAAC,4BAA4B;EAAS,OAAO,EAAE,gBAAgB;YAC7D,2CAAC,8BAA8B;GAC7B,OAAO;IAAE;IAAmB;IAA0B;GAErD;IACsC;GACJ;;AAI3C,MAAa,kCAAkC;CAC7C,MAAM,gCAAqB,8BAA8B;AACzD,KAAI,YAAY,OACd,OAAM,IAAI,MACR,0EACD;AAEH,QAAO;;AAGT,MAAa,2BAA2B;CACtC,MAAM,gBAAgB,2BAA2B;CACjD,MAAM,qCAA0B,4BAA4B;AAE5D,KAAI,iBAAiB,OACnB,OAAM,IAAI,MACR,wEACD;AAGH,QAAO;EAAE,GAAG;EAAc,GAAG;EAAe"}

package/dist/cjs/FocusDictionaryContext.cjs

@@ -9,6 +9,8 @@ let react_jsx_runtime = require("react/jsx-runtime");
 react_jsx_runtime = require_rolldown_runtime.__toESM(react_jsx_runtime);
 let __intlayer_editor = require("@intlayer/editor");
 __intlayer_editor = require_rolldown_runtime.__toESM(__intlayer_editor);
+let __intlayer_types = require("@intlayer/types");
+__intlayer_types = require_rolldown_runtime.__toESM(__intlayer_types);
 
 //#region src/FocusDictionaryContext.tsx
 const FocusDictionaryStateContext = (0, react.createContext)(void 0);
@@ -18,9 +20,10 @@ const FocusDictionaryProvider = ({ children }) => {
 	const setFocusedContentKeyPath = (keyPath) => {
 		setFocusedContent((prev) => {
 			if (!prev) return prev;
+			const filteredKeyPath = keyPath.filter((key) => key.type !== __intlayer_types.NodeType.Translation);
 			return {
 				...prev,
-				keyPath
+				keyPath: filteredKeyPath
 			};
 		});
 	};

package/dist/cjs/FocusDictionaryContext.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"FocusDictionaryContext.cjs","names":["FocusDictionaryProvider: FC<PropsWithChildren>","useCrossFrameState","MessageKey"],"sources":["../../src/FocusDictionaryContext.tsx"],"sourcesContent":["'use client';\n\nimport { MessageKey } from '@intlayer/editor';\nimport type { KeyPath } from '@intlayer/types';\nimport {\n  createContext,\n  type Dispatch,\n  type FC,\n  type PropsWithChildren,\n  type SetStateAction,\n  useContext,\n} from 'react';\nimport { useCrossFrameState } from './useCrossFrameState';\n\nexport type FileContent = {\n  dictionaryKey: string;\n  dictionaryLocalId?: string;\n  keyPath?: KeyPath[];\n};\n\ntype FocusDictionaryState = {\n  focusedContent: FileContent | null;\n};\n\ntype FocusDictionaryActions = {\n  setFocusedContent: Dispatch<SetStateAction<FileContent | null>>;\n  setFocusedContentKeyPath: (keyPath: KeyPath[]) => void;\n};\n\nconst FocusDictionaryStateContext = createContext<\n  FocusDictionaryState | undefined\n>(undefined);\nconst FocusDictionaryActionsContext = createContext<\n  FocusDictionaryActions | undefined\n>(undefined);\n\nexport const FocusDictionaryProvider: FC<PropsWithChildren> = ({\n  children,\n}) => {\n  const [focusedContent, setFocusedContent] =\n    useCrossFrameState<FileContent | null>(\n      MessageKey.INTLAYER_FOCUSED_CONTENT_CHANGED,\n      null\n    );\n\n  const setFocusedContentKeyPath = (keyPath: KeyPath[]) => {\n    setFocusedContent((prev) => {\n      if (!prev) {\n        return prev; // nothing to update if there's no focused content\n      }\n      return { ...prev, keyPath };\n    });\n  };\n\n  return (\n    <FocusDictionaryStateContext.Provider value={{ focusedContent }}>\n      <FocusDictionaryActionsContext.Provider\n        value={{ setFocusedContent, setFocusedContentKeyPath }}\n      >\n        {children}\n      </FocusDictionaryActionsContext.Provider>\n    </FocusDictionaryStateContext.Provider>\n  );\n};\n\nexport const useFocusDictionaryActions = () => {\n  const context = useContext(FocusDictionaryActionsContext);\n  if (context === undefined) {\n    throw new Error(\n      'useFocusDictionaryActions must be used within a FocusDictionaryProvider'\n    );\n  }\n  return context;\n};\n\nexport const useFocusDictionary = () => {\n  const actionContext = useFocusDictionaryActions();\n  const stateContext = useContext(FocusDictionaryStateContext);\n\n  if (stateContext === undefined) {\n    throw new Error(\n      'useFocusDictionaryState must be used within a FocusDictionaryProvider'\n    );\n  }\n\n  return { ...stateContext, ...actionContext };\n};\n"],"mappings":";;;;;;;;;;;;;AA6BA,MAAM,uDAEJ,OAAU;AACZ,MAAM,yDAEJ,OAAU;AAEZ,MAAaA,2BAAkD,EAC7D,eACI;CACJ,MAAM,CAAC,gBAAgB,qBACrBC,8CACEC,6BAAW,kCACX,KACD;CAEH,MAAM,4BAA4B,YAAuB;AACvD,qBAAmB,SAAS;AAC1B,OAAI,CAAC,KACH,QAAO;AAET,UAAO;IAAE,GAAG;IAAM;IAAS;IAC3B;;AAGJ,QACE,2CAAC,4BAA4B;EAAS,OAAO,EAAE,gBAAgB;YAC7D,2CAAC,8BAA8B;GAC7B,OAAO;IAAE;IAAmB;IAA0B;GAErD;IACsC;GACJ;;AAI3C,MAAa,kCAAkC;CAC7C,MAAM,gCAAqB,8BAA8B;AACzD,KAAI,YAAY,OACd,OAAM,IAAI,MACR,0EACD;AAEH,QAAO;;AAGT,MAAa,2BAA2B;CACtC,MAAM,gBAAgB,2BAA2B;CACjD,MAAM,qCAA0B,4BAA4B;AAE5D,KAAI,iBAAiB,OACnB,OAAM,IAAI,MACR,wEACD;AAGH,QAAO;EAAE,GAAG;EAAc,GAAG;EAAe"}
+{"version":3,"file":"FocusDictionaryContext.cjs","names":["FocusDictionaryProvider: FC<PropsWithChildren>","useCrossFrameState","MessageKey","NodeType"],"sources":["../../src/FocusDictionaryContext.tsx"],"sourcesContent":["'use client';\n\nimport { MessageKey } from '@intlayer/editor';\nimport {\n  type KeyPath,\n  type LocalDictionaryId,\n  NodeType,\n} from '@intlayer/types';\nimport {\n  createContext,\n  type Dispatch,\n  type FC,\n  type PropsWithChildren,\n  type SetStateAction,\n  useContext,\n} from 'react';\nimport { useCrossFrameState } from './useCrossFrameState';\n\nexport type FileContent = {\n  dictionaryKey: string;\n  dictionaryLocalId?: LocalDictionaryId;\n  keyPath?: KeyPath[];\n};\n\nexport type FocusDictionaryState = {\n  focusedContent: FileContent | null;\n};\n\nexport type FocusDictionaryActions = {\n  setFocusedContent: Dispatch<SetStateAction<FileContent | null>>;\n  setFocusedContentKeyPath: (keyPath: KeyPath[]) => void;\n};\n\nconst FocusDictionaryStateContext = createContext<\n  FocusDictionaryState | undefined\n>(undefined);\nconst FocusDictionaryActionsContext = createContext<\n  FocusDictionaryActions | undefined\n>(undefined);\n\nexport const FocusDictionaryProvider: FC<PropsWithChildren> = ({\n  children,\n}) => {\n  const [focusedContent, setFocusedContent] =\n    useCrossFrameState<FileContent | null>(\n      MessageKey.INTLAYER_FOCUSED_CONTENT_CHANGED,\n      null\n    );\n\n  const setFocusedContentKeyPath = (keyPath: KeyPath[]) => {\n    setFocusedContent((prev) => {\n      if (!prev) {\n        return prev; // nothing to update if there's no focused content\n      }\n\n      // Remove translation key path if it exists to make it more flexible with optimization client / editor\n      const filteredKeyPath = keyPath.filter(\n        (key) => key.type !== NodeType.Translation\n      );\n\n      return {\n        ...prev,\n        keyPath: filteredKeyPath,\n      };\n    });\n  };\n\n  return (\n    <FocusDictionaryStateContext.Provider value={{ focusedContent }}>\n      <FocusDictionaryActionsContext.Provider\n        value={{ setFocusedContent, setFocusedContentKeyPath }}\n      >\n        {children}\n      </FocusDictionaryActionsContext.Provider>\n    </FocusDictionaryStateContext.Provider>\n  );\n};\n\nexport const useFocusDictionaryActions = () => {\n  const context = useContext(FocusDictionaryActionsContext);\n  if (context === undefined) {\n    throw new Error(\n      'useFocusDictionaryActions must be used within a FocusDictionaryProvider'\n    );\n  }\n  return context;\n};\n\nexport const useFocusDictionary = () => {\n  const actionContext = useFocusDictionaryActions();\n  const stateContext = useContext(FocusDictionaryStateContext);\n\n  if (stateContext === undefined) {\n    throw new Error(\n      'useFocusDictionaryState must be used within a FocusDictionaryProvider'\n    );\n  }\n\n  return { ...stateContext, ...actionContext };\n};\n"],"mappings":";;;;;;;;;;;;;;;AAiCA,MAAM,uDAEJ,OAAU;AACZ,MAAM,yDAEJ,OAAU;AAEZ,MAAaA,2BAAkD,EAC7D,eACI;CACJ,MAAM,CAAC,gBAAgB,qBACrBC,8CACEC,6BAAW,kCACX,KACD;CAEH,MAAM,4BAA4B,YAAuB;AACvD,qBAAmB,SAAS;AAC1B,OAAI,CAAC,KACH,QAAO;GAIT,MAAM,kBAAkB,QAAQ,QAC7B,QAAQ,IAAI,SAASC,0BAAS,YAChC;AAED,UAAO;IACL,GAAG;IACH,SAAS;IACV;IACD;;AAGJ,QACE,2CAAC,4BAA4B;EAAS,OAAO,EAAE,gBAAgB;YAC7D,2CAAC,8BAA8B;GAC7B,OAAO;IAAE;IAAmB;IAA0B;GAErD;IACsC;GACJ;;AAI3C,MAAa,kCAAkC;CAC7C,MAAM,gCAAqB,8BAA8B;AACzD,KAAI,YAAY,OACd,OAAM,IAAI,MACR,0EACD;AAEH,QAAO;;AAGT,MAAa,2BAA2B;CACtC,MAAM,gBAAgB,2BAA2B;CACjD,MAAM,qCAA0B,4BAA4B;AAE5D,KAAI,iBAAiB,OACnB,OAAM,IAAI,MACR,wEACD;AAGH,QAAO;EAAE,GAAG;EAAc,GAAG;EAAe"}

package/dist/cjs/FocusDictionaryServerContext.cjs

@@ -0,0 +1,24 @@
+'use client';
+
+
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_FocusDictionaryContext = require('./FocusDictionaryContext.cjs');
+let react = require("react");
+react = require_rolldown_runtime.__toESM(react);
+let __intlayer_types = require("@intlayer/types");
+__intlayer_types = require_rolldown_runtime.__toESM(__intlayer_types);
+
+//#region src/FocusDictionaryServerContext.tsx
+const unmergedKeyPathToMergedKeyPath = (keyPath) => {
+	if (!keyPath.find((key) => key.type === __intlayer_types.NodeType.Translation)) return keyPath;
+	return [keyPath.find((key) => key.type === __intlayer_types.NodeType.Translation), ...keyPath.filter((key) => key.type !== __intlayer_types.NodeType.Translation)];
+};
+const useFocusUnmergedDictionary = () => {
+	const [focusedKeyPath, setFocusedKeyPath] = (0, react.useState)([]);
+	const { setFocusedContent: setMergedFocusedContent, setFocusedContentKeyPath: setMergedFocusedContentKeyPath, focusedContent: mergedFocusedContent } = require_FocusDictionaryContext.useFocusDictionary();
+	return { focusedContent: unmergedKeyPathToMergedKeyPath(focusedKeyPath) };
+};
+
+//#endregion
+exports.useFocusUnmergedDictionary = useFocusUnmergedDictionary;
+//# sourceMappingURL=FocusDictionaryServerContext.cjs.map

package/dist/cjs/FocusDictionaryServerContext.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"FocusDictionaryServerContext.cjs","names":["NodeType","useFocusDictionary"],"sources":["../../src/FocusDictionaryServerContext.tsx"],"sourcesContent":["'use client';\n\nimport { type Dictionary, type KeyPath, NodeType } from '@intlayer/types';\nimport { useState } from 'react';\nimport { useFocusDictionary } from './FocusDictionaryContext';\n\nconst unmergedKeyPathToMergedKeyPath = (keyPath: KeyPath[]): KeyPath[] => {\n  if (!keyPath.find((key) => key.type === NodeType.Translation)) return keyPath;\n\n  const translationKeyPath = keyPath.find(\n    (key) => key.type === NodeType.Translation\n  )!;\n  const otherKeyPath = keyPath.filter(\n    (key) => key.type !== NodeType.Translation\n  );\n\n  return [translationKeyPath, ...otherKeyPath];\n};\n\nconst mergedKeyPathToUnmergedKeyPath = (\n  keyPath: KeyPath[],\n  dictionary: Dictionary\n): KeyPath[] => {\n  if (!keyPath.find((key) => key.type === NodeType.Translation)) return keyPath;\n\n  const translationKeyPath = keyPath.find(\n    (key) => key.type === NodeType.Translation\n  )!;\n  const otherKeyPath = keyPath.filter(\n    (key) => key.type !== NodeType.Translation\n  );\n\n  // it should insert the translation key path at the end and then end -1, end -2, etc.\n  const candidates = Object(otherKeyPath.length).map((_, index) =>\n    otherKeyPath.slice(0, index + 1)\n  );\n\n  for (const candidate of candidates) {\n    const result = getContentNodeByKeyPath(dictionary.content, candidate);\n\n    if (result) {\n      return candidate;\n    }\n  }\n\n  return null;\n};\n\nexport const useFocusUnmergedDictionary = () => {\n  const [focusedKeyPath, setFocusedKeyPath] = useState<KeyPath[]>([]);\n\n  const {\n    setFocusedContent: setMergedFocusedContent,\n    setFocusedContentKeyPath: setMergedFocusedContentKeyPath,\n    focusedContent: mergedFocusedContent,\n  } = useFocusDictionary();\n\n  const focusedContent = unmergedKeyPathToMergedKeyPath(focusedKeyPath);\n\n  return { focusedContent };\n};\n"],"mappings":";;;;;;;;;;;AAMA,MAAM,kCAAkC,YAAkC;AACxE,KAAI,CAAC,QAAQ,MAAM,QAAQ,IAAI,SAASA,0BAAS,YAAY,CAAE,QAAO;AAStE,QAAO,CAPoB,QAAQ,MAChC,QAAQ,IAAI,SAASA,0BAAS,YAChC,EAK2B,GAJP,QAAQ,QAC1B,QAAQ,IAAI,SAASA,0BAAS,YAChC,CAE2C;;AAgC9C,MAAa,mCAAmC;CAC9C,MAAM,CAAC,gBAAgB,yCAAyC,EAAE,CAAC;CAEnE,MAAM,EACJ,mBAAmB,yBACnB,0BAA0B,gCAC1B,gBAAgB,yBACdC,mDAAoB;AAIxB,QAAO,EAAE,gBAFc,+BAA+B,eAAe,EAE5C"}

package/dist/cjs/FocusDictionaryUnmergedContext.cjs

@@ -0,0 +1,102 @@
+'use client';
+
+
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_FocusDictionaryContext = require('./FocusDictionaryContext.cjs');
+let react = require("react");
+react = require_rolldown_runtime.__toESM(react);
+let react_jsx_runtime = require("react/jsx-runtime");
+react_jsx_runtime = require_rolldown_runtime.__toESM(react_jsx_runtime);
+let __intlayer_core = require("@intlayer/core");
+__intlayer_core = require_rolldown_runtime.__toESM(__intlayer_core);
+let __intlayer_types = require("@intlayer/types");
+__intlayer_types = require_rolldown_runtime.__toESM(__intlayer_types);
+
+//#region src/FocusDictionaryUnmergedContext.tsx
+/**
+* Transforms a keypath from unmerged dictionary format to merged dictionary format.
+* In merged format, translation keys come first.
+*
+* Example:
+* Unmerged: [{ type: 'object', key: 'title' }, { type: 'translation', key: 'fr' }]
+* Merged: [{ type: 'translation', key: 'fr' }, { type: 'object', key: 'title' }]
+*/
+const unmergedKeyPathToMergedKeyPath = (keyPath) => {
+	if (!keyPath || keyPath.length === 0) return keyPath;
+	const translationKeyPath = keyPath.find((key) => key.type === __intlayer_types.NodeType.Translation);
+	if (!translationKeyPath) return keyPath;
+	return [translationKeyPath, ...keyPath.filter((key) => key.type !== __intlayer_types.NodeType.Translation)];
+};
+/**
+* Transforms a keypath from merged dictionary format to unmerged dictionary format.
+* In unmerged format, translation keys are placed at the appropriate nesting level.
+*
+* Example:
+* Merged: [{ type: 'translation', key: 'fr' }, { type: 'object', key: 'title' }]
+* Unmerged: [{ type: 'object', key: 'title' }, { type: 'translation', key: 'fr' }]
+*/
+const mergedKeyPathToUnmergedKeyPath = (keyPath, dictionary) => {
+	if (!keyPath || keyPath.length === 0) return keyPath;
+	const translationKeyPath = keyPath.find((key) => key.type === __intlayer_types.NodeType.Translation);
+	if (!translationKeyPath) return keyPath;
+	const otherKeyPaths = keyPath.filter((key) => key.type !== __intlayer_types.NodeType.Translation);
+	if (dictionary?.content) for (let i = otherKeyPaths.length; i >= 0; i--) {
+		const candidateKeyPath = [
+			...otherKeyPaths.slice(0, i),
+			translationKeyPath,
+			...otherKeyPaths.slice(i)
+		];
+		try {
+			if ((0, __intlayer_core.getContentNodeByKeyPath)(dictionary.content, candidateKeyPath)) return candidateKeyPath;
+		} catch {}
+	}
+	return [...otherKeyPaths, translationKeyPath];
+};
+const FocusDictionaryUnmergedStateContext = (0, react.createContext)(void 0);
+const FocusDictionaryUnmergedActionsContext = (0, react.createContext)(void 0);
+const FocusDictionaryUnmergedProvider = ({ children }) => {
+	const { focusedContent, setFocusedContent } = require_FocusDictionaryContext.useFocusDictionary();
+	const { setFocusedContentKeyPath: setMergedKeyPath } = require_FocusDictionaryContext.useFocusDictionaryActions();
+	const focusedUnmergedKeyPath = (0, react.useMemo)(() => {
+		if (!focusedContent?.keyPath) return void 0;
+		return focusedContent.keyPath;
+	}, [focusedContent?.keyPath]);
+	const setFocusedUnmergedKeyPath = (keyPath) => {
+		setMergedKeyPath(unmergedKeyPathToMergedKeyPath(keyPath));
+	};
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(FocusDictionaryUnmergedStateContext.Provider, {
+		value: {
+			focusedContent,
+			focusedUnmergedKeyPath
+		},
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(FocusDictionaryUnmergedActionsContext.Provider, {
+			value: {
+				setFocusedContent,
+				setFocusedUnmergedKeyPath
+			},
+			children
+		})
+	});
+};
+const useFocusDictionaryUnmergedActions = () => {
+	const context = (0, react.useContext)(FocusDictionaryUnmergedActionsContext);
+	if (context === void 0) throw new Error("useFocusDictionaryUnmergedActions must be used within a FocusDictionaryUnmergedProvider");
+	return context;
+};
+const useFocusDictionaryUnmerged = () => {
+	const actionContext = useFocusDictionaryUnmergedActions();
+	const stateContext = (0, react.useContext)(FocusDictionaryUnmergedStateContext);
+	if (stateContext === void 0) throw new Error("useFocusDictionaryUnmerged must be used within a FocusDictionaryUnmergedProvider");
+	return {
+		...stateContext,
+		...actionContext
+	};
+};
+
+//#endregion
+exports.FocusDictionaryUnmergedProvider = FocusDictionaryUnmergedProvider;
+exports.mergedKeyPathToUnmergedKeyPath = mergedKeyPathToUnmergedKeyPath;
+exports.unmergedKeyPathToMergedKeyPath = unmergedKeyPathToMergedKeyPath;
+exports.useFocusDictionaryUnmerged = useFocusDictionaryUnmerged;
+exports.useFocusDictionaryUnmergedActions = useFocusDictionaryUnmergedActions;
+//# sourceMappingURL=FocusDictionaryUnmergedContext.cjs.map

package/dist/cjs/FocusDictionaryUnmergedContext.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"FocusDictionaryUnmergedContext.cjs","names":["NodeType","FocusDictionaryUnmergedProvider: FC<PropsWithChildren>","useFocusDictionary","useFocusDictionaryActions"],"sources":["../../src/FocusDictionaryUnmergedContext.tsx"],"sourcesContent":["'use client';\n\nimport { getContentNodeByKeyPath } from '@intlayer/core';\nimport type { Dictionary, KeyPath } from '@intlayer/types';\nimport { NodeType } from '@intlayer/types';\nimport {\n  createContext,\n  type Dispatch,\n  type FC,\n  type PropsWithChildren,\n  type SetStateAction,\n  useContext,\n  useMemo,\n} from 'react';\nimport {\n  type FileContent,\n  useFocusDictionary,\n  useFocusDictionaryActions,\n} from './FocusDictionaryContext';\n\n/**\n * Transforms a keypath from unmerged dictionary format to merged dictionary format.\n * In merged format, translation keys come first.\n *\n * Example:\n * Unmerged: [{ type: 'object', key: 'title' }, { type: 'translation', key: 'fr' }]\n * Merged: [{ type: 'translation', key: 'fr' }, { type: 'object', key: 'title' }]\n */\nconst unmergedKeyPathToMergedKeyPath = (keyPath: KeyPath[]): KeyPath[] => {\n  if (!keyPath || keyPath.length === 0) return keyPath;\n\n  const translationKeyPath = keyPath.find(\n    (key) => key.type === NodeType.Translation\n  );\n\n  // If no translation key, return as is\n  if (!translationKeyPath) return keyPath;\n\n  const otherKeyPaths = keyPath.filter(\n    (key) => key.type !== NodeType.Translation\n  );\n\n  // Translation key comes first in merged format\n  return [translationKeyPath, ...otherKeyPaths];\n};\n\n/**\n * Transforms a keypath from merged dictionary format to unmerged dictionary format.\n * In unmerged format, translation keys are placed at the appropriate nesting level.\n *\n * Example:\n * Merged: [{ type: 'translation', key: 'fr' }, { type: 'object', key: 'title' }]\n * Unmerged: [{ type: 'object', key: 'title' }, { type: 'translation', key: 'fr' }]\n */\nconst mergedKeyPathToUnmergedKeyPath = (\n  keyPath: KeyPath[],\n  dictionary?: Dictionary\n): KeyPath[] => {\n  if (!keyPath || keyPath.length === 0) return keyPath;\n\n  const translationKeyPath = keyPath.find(\n    (key) => key.type === NodeType.Translation\n  );\n\n  // If no translation key, return as is\n  if (!translationKeyPath) return keyPath;\n\n  const otherKeyPaths = keyPath.filter(\n    (key) => key.type !== NodeType.Translation\n  );\n\n  // If we have a dictionary, try to find the correct position for the translation key\n  if (dictionary?.content) {\n    // Try inserting the translation key at different positions from end to start\n    // to find where it should be placed in the unmerged structure\n    for (let i = otherKeyPaths.length; i >= 0; i--) {\n      const candidateKeyPath = [\n        ...otherKeyPaths.slice(0, i),\n        translationKeyPath,\n        ...otherKeyPaths.slice(i),\n      ];\n\n      try {\n        const result = getContentNodeByKeyPath(\n          dictionary.content,\n          candidateKeyPath\n        );\n        if (result) {\n          return candidateKeyPath;\n        }\n      } catch {\n        // Continue trying other positions\n      }\n    }\n  }\n\n  // Default: translation key at the end (most common unmerged format)\n  return [...otherKeyPaths, translationKeyPath];\n};\n\nexport type FocusDictionaryUnmergedState = {\n  focusedContent: FileContent | null;\n  focusedUnmergedKeyPath: KeyPath[] | undefined;\n};\n\nexport type FocusDictionaryUnmergedActions = {\n  setFocusedContent: Dispatch<SetStateAction<FileContent | null>>;\n  setFocusedUnmergedKeyPath: (keyPath: KeyPath[]) => void;\n};\n\nconst FocusDictionaryUnmergedStateContext = createContext<\n  FocusDictionaryUnmergedState | undefined\n>(undefined);\n\nconst FocusDictionaryUnmergedActionsContext = createContext<\n  FocusDictionaryUnmergedActions | undefined\n>(undefined);\n\nexport const FocusDictionaryUnmergedProvider: FC<PropsWithChildren> = ({\n  children,\n}) => {\n  const { focusedContent, setFocusedContent } = useFocusDictionary();\n  const { setFocusedContentKeyPath: setMergedKeyPath } =\n    useFocusDictionaryActions();\n\n  const focusedUnmergedKeyPath = useMemo(() => {\n    if (!focusedContent?.keyPath) return undefined;\n    // The focusedContent.keyPath from FocusDictionaryContext is in merged format\n    // We don't transform it here because we don't have the dictionary\n    // The consumer should use setFocusedUnmergedKeyPath with a dictionary\n    return focusedContent.keyPath;\n  }, [focusedContent?.keyPath]);\n\n  const setFocusedUnmergedKeyPath = (keyPath: KeyPath[]) => {\n    // Transform unmerged keypath to merged keypath before setting it\n    const mergedKeyPath = unmergedKeyPathToMergedKeyPath(keyPath);\n    setMergedKeyPath(mergedKeyPath);\n  };\n\n  return (\n    <FocusDictionaryUnmergedStateContext.Provider\n      value={{ focusedContent, focusedUnmergedKeyPath }}\n    >\n      <FocusDictionaryUnmergedActionsContext.Provider\n        value={{ setFocusedContent, setFocusedUnmergedKeyPath }}\n      >\n        {children}\n      </FocusDictionaryUnmergedActionsContext.Provider>\n    </FocusDictionaryUnmergedStateContext.Provider>\n  );\n};\n\nexport const useFocusDictionaryUnmergedActions = () => {\n  const context = useContext(FocusDictionaryUnmergedActionsContext);\n  if (context === undefined) {\n    throw new Error(\n      'useFocusDictionaryUnmergedActions must be used within a FocusDictionaryUnmergedProvider'\n    );\n  }\n  return context;\n};\n\nexport const useFocusDictionaryUnmerged = () => {\n  const actionContext = useFocusDictionaryUnmergedActions();\n  const stateContext = useContext(FocusDictionaryUnmergedStateContext);\n\n  if (stateContext === undefined) {\n    throw new Error(\n      'useFocusDictionaryUnmerged must be used within a FocusDictionaryUnmergedProvider'\n    );\n  }\n\n  return { ...stateContext, ...actionContext };\n};\n\n// Export the mapper functions for use elsewhere\nexport { unmergedKeyPathToMergedKeyPath, mergedKeyPathToUnmergedKeyPath };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA4BA,MAAM,kCAAkC,YAAkC;AACxE,KAAI,CAAC,WAAW,QAAQ,WAAW,EAAG,QAAO;CAE7C,MAAM,qBAAqB,QAAQ,MAChC,QAAQ,IAAI,SAASA,0BAAS,YAChC;AAGD,KAAI,CAAC,mBAAoB,QAAO;AAOhC,QAAO,CAAC,oBAAoB,GALN,QAAQ,QAC3B,QAAQ,IAAI,SAASA,0BAAS,YAChC,CAG4C;;;;;;;;;;AAW/C,MAAM,kCACJ,SACA,eACc;AACd,KAAI,CAAC,WAAW,QAAQ,WAAW,EAAG,QAAO;CAE7C,MAAM,qBAAqB,QAAQ,MAChC,QAAQ,IAAI,SAASA,0BAAS,YAChC;AAGD,KAAI,CAAC,mBAAoB,QAAO;CAEhC,MAAM,gBAAgB,QAAQ,QAC3B,QAAQ,IAAI,SAASA,0BAAS,YAChC;AAGD,KAAI,YAAY,QAGd,MAAK,IAAI,IAAI,cAAc,QAAQ,KAAK,GAAG,KAAK;EAC9C,MAAM,mBAAmB;GACvB,GAAG,cAAc,MAAM,GAAG,EAAE;GAC5B;GACA,GAAG,cAAc,MAAM,EAAE;GAC1B;AAED,MAAI;AAKF,oDAHE,WAAW,SACX,iBACD,CAEC,QAAO;UAEH;;AAOZ,QAAO,CAAC,GAAG,eAAe,mBAAmB;;AAa/C,MAAM,+DAEJ,OAAU;AAEZ,MAAM,iEAEJ,OAAU;AAEZ,MAAaC,mCAA0D,EACrE,eACI;CACJ,MAAM,EAAE,gBAAgB,sBAAsBC,mDAAoB;CAClE,MAAM,EAAE,0BAA0B,qBAChCC,0DAA2B;CAE7B,MAAM,kDAAuC;AAC3C,MAAI,CAAC,gBAAgB,QAAS,QAAO;AAIrC,SAAO,eAAe;IACrB,CAAC,gBAAgB,QAAQ,CAAC;CAE7B,MAAM,6BAA6B,YAAuB;AAGxD,mBADsB,+BAA+B,QAAQ,CAC9B;;AAGjC,QACE,2CAAC,oCAAoC;EACnC,OAAO;GAAE;GAAgB;GAAwB;YAEjD,2CAAC,sCAAsC;GACrC,OAAO;IAAE;IAAmB;IAA2B;GAEtD;IAC8C;GACJ;;AAInD,MAAa,0CAA0C;CACrD,MAAM,gCAAqB,sCAAsC;AACjE,KAAI,YAAY,OACd,OAAM,IAAI,MACR,0FACD;AAEH,QAAO;;AAGT,MAAa,mCAAmC;CAC9C,MAAM,gBAAgB,mCAAmC;CACzD,MAAM,qCAA0B,oCAAoC;AAEpE,KAAI,iBAAiB,OACnB,OAAM,IAAI,MACR,mFACD;AAGH,QAAO;EAAE,GAAG;EAAc,GAAG;EAAe"}

package/dist/cjs/index.cjs

@@ -3,11 +3,13 @@ const require_useCrossFrameMessageListener = require('./useCrossFrameMessageList
 const require_useCrossFrameState = require('./useCrossFrameState.cjs');
 const require_ConfigurationContext = require('./ConfigurationContext.cjs');
 const require_DictionariesRecordContext = require('./DictionariesRecordContext.cjs');
+const require_useEditorLocale = require('./useEditorLocale.cjs');
 const require_EditedContentContext = require('./EditedContentContext.cjs');
 const require_EditorEnabledContext = require('./EditorEnabledContext.cjs');
 const require_FocusDictionaryContext = require('./FocusDictionaryContext.cjs');
 const require_EditorProvider = require('./EditorProvider.cjs');
 const require_useCrossURLPathState = require('./useCrossURLPathState.cjs');
+const require_useFocusUnmergedDictionary = require('./useFocusUnmergedDictionary.cjs');
 const require_useIframeClickInterceptor = require('./useIframeClickInterceptor.cjs');
 
 exports.CommunicatorProvider = require_CommunicatorContext.CommunicatorProvider;
@@ -30,14 +32,17 @@ exports.useEditedContent = require_EditedContentContext.useEditedContent;
 exports.useEditedContentActions = require_EditedContentContext.useEditedContentActions;
 exports.useEditorEnabled = require_EditorEnabledContext.useEditorEnabled;
 exports.useEditorEnabledState = require_EditorEnabledContext.useEditorEnabledState;
+exports.useEditorLocale = require_useEditorLocale.useEditorLocale;
 exports.useFocusDictionary = require_FocusDictionaryContext.useFocusDictionary;
 exports.useFocusDictionaryActions = require_FocusDictionaryContext.useFocusDictionaryActions;
+exports.useFocusUnmergedDictionary = require_useFocusUnmergedDictionary.useFocusUnmergedDictionary;
 exports.useGetEditedContentState = require_EditedContentContext.useGetEditedContentState;
 exports.useGetEditorEnabledState = require_EditorEnabledContext.useGetEditorEnabledState;
 exports.useIframeClickInterceptor = require_useIframeClickInterceptor.useIframeClickInterceptor;
 exports.useIframeClickMerger = require_useIframeClickInterceptor.useIframeClickMerger;
 exports.usePostEditedContentState = require_EditedContentContext.usePostEditedContentState;
 exports.usePostEditorEnabledState = require_EditorEnabledContext.usePostEditorEnabledState;
+exports.useSetEditorLocale = require_useEditorLocale.useSetEditorLocale;
 var __intlayer_editor = require("@intlayer/editor");
 Object.keys(__intlayer_editor).forEach(function (k) {
   if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {

package/dist/cjs/useCrossFrameMessageListener.cjs

@@ -41,7 +41,12 @@ const useCrossFrameMessageListener = (key, onEventTriggered, revalidator) => {
 				const { type, data, senderId: msgSenderId } = event.data;
 				if (type !== key) return;
 				if (msgSenderId === senderId) return;
-				if (typeof allowedOrigins === "undefined" || allowedOrigins?.some((url) => (0, __intlayer_editor.compareUrls)(url, event.origin)) || allowedOrigins?.includes("*")) onEventTriggered(data);
+				if (typeof allowedOrigins === "undefined" || allowedOrigins?.filter((url) => ![
+					null,
+					void 0,
+					"",
+					"*"
+				].includes(url)).some((url) => (0, __intlayer_editor.compareUrls)(url, event.origin)) || allowedOrigins?.includes("*")) onEventTriggered(data);
 			};
 			window.addEventListener("message", handleMessage);
 			return () => window.removeEventListener("message", handleMessage);

package/dist/cjs/useCrossFrameMessageListener.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useCrossFrameMessageListener.cjs","names":["useCommunicator","postMessageWrapper: (data?: S) => void"],"sources":["../../src/useCrossFrameMessageListener.tsx"],"sourcesContent":["'use client';\n\nimport { compareUrls, type MessageKey } from '@intlayer/editor';\nimport { useEffect } from 'react';\nimport { useCommunicator } from './CommunicatorContext';\n\n/**\n * useCrossFrameMessageListener\n *\n * This React hook listens for messages sent via the `postMessage` API and triggers a callback\n * whenever a message of the specified type (`key`) is received. It is useful for synchronizing\n * state or events across different windows, iframes, or contexts.\n *\n * @template S - The type of the data payload in the message.\n * @param key - A unique identifier for the message type to listen for.\n * @param [onEventTriggered] - A callback function triggered when a message\n * @param [revalidator] - A function that re-suscribes the listener. Could be usefull if onEventTriggered depend of some state\n * with the specified key is received. The callback receives the message data as its argument.\n *\n * @returns {{ postMessage: (data: S) => void }} An object containing a `postMessage` function\n * that allows broadcasting messages with the specified key and data.\n */\nexport const useCrossFrameMessageListener = <S,>(\n  key: `${MessageKey}` | `${MessageKey}/post` | `${MessageKey}/get`,\n  onEventTriggered?: (data: S) => void,\n  revalidator?: any\n) => {\n  const { allowedOrigins, postMessage, senderId } = useCommunicator();\n\n  useEffect(() => {\n    if (onEventTriggered) {\n      /**\n       * Message handler to process incoming messages.\n       *\n       * - **Message Filtering:** Ensures only messages with the specified `key` are processed.\n       * - **Origin Validation:** Checks that the origin of the message is within the allowed origins.\n       *\n       * @param {MessageEvent<{ type: string; data: S }>} event - The incoming message event object.\n       */\n      const handleMessage = (\n        event: MessageEvent<{ type: string; data: S; senderId: string }>\n      ) => {\n        const { type, data, senderId: msgSenderId } = event.data;\n\n        // Ignore messages that do not match the current key\n        if (type !== key) return;\n\n        // Ignore messages from myself\n        if (msgSenderId === senderId) return;\n\n        // Check if the message origin is allowed\n        if (\n          typeof allowedOrigins === 'undefined' ||\n          allowedOrigins?.some((url) => compareUrls(url, event.origin)) ||\n          allowedOrigins?.includes('*')\n        ) {\n          // Update the local state with the received data\n          onEventTriggered(data);\n        }\n      };\n\n      window.addEventListener('message', handleMessage);\n\n      // Clean up the event listener on unmount\n      return () => window.removeEventListener('message', handleMessage);\n    }\n  }, [allowedOrigins, postMessage, senderId, revalidator]);\n\n  /**\n   * A wrapper function around the `postMessage` function to broadcast messages efficiently.\n   *\n   * - **Encapsulation:** Ensures the `postMessage` function is scoped to the provided key.\n   * - **Ease of Use:** Simplifies broadcasting messages with consistent type and format.\n   *\n   * @param {S} data - The data payload to include in the message.\n   * @returns {void}\n   */\n  const postMessageWrapper: (data?: S) => void = (data) => {\n    postMessage({ type: key, data, senderId });\n  };\n\n  return postMessageWrapper;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAsBA,MAAa,gCACX,KACA,kBACA,gBACG;CACH,MAAM,EAAE,gBAAgB,aAAa,aAAaA,6CAAiB;AAEnE,4BAAgB;AACd,MAAI,kBAAkB;;;;;;;;;GASpB,MAAM,iBACJ,UACG;IACH,MAAM,EAAE,MAAM,MAAM,UAAU,gBAAgB,MAAM;AAGpD,QAAI,SAAS,IAAK;AAGlB,QAAI,gBAAgB,SAAU;AAG9B,QACE,OAAO,mBAAmB,eAC1B,gBAAgB,MAAM,2CAAoB,KAAK,MAAM,OAAO,CAAC,IAC7D,gBAAgB,SAAS,IAAI,CAG7B,kBAAiB,KAAK;;AAI1B,UAAO,iBAAiB,WAAW,cAAc;AAGjD,gBAAa,OAAO,oBAAoB,WAAW,cAAc;;IAElE;EAAC;EAAgB;EAAa;EAAU;EAAY,CAAC;;;;;;;;;;CAWxD,MAAMC,sBAA0C,SAAS;AACvD,cAAY;GAAE,MAAM;GAAK;GAAM;GAAU,CAAC;;AAG5C,QAAO"}
+{"version":3,"file":"useCrossFrameMessageListener.cjs","names":["useCommunicator","postMessageWrapper: (data?: S) => void"],"sources":["../../src/useCrossFrameMessageListener.tsx"],"sourcesContent":["'use client';\n\nimport { compareUrls, type MessageKey } from '@intlayer/editor';\nimport { useEffect } from 'react';\nimport { useCommunicator } from './CommunicatorContext';\n\n/**\n * useCrossFrameMessageListener\n *\n * This React hook listens for messages sent via the `postMessage` API and triggers a callback\n * whenever a message of the specified type (`key`) is received. It is useful for synchronizing\n * state or events across different windows, iframes, or contexts.\n *\n * @template S - The type of the data payload in the message.\n * @param key - A unique identifier for the message type to listen for.\n * @param [onEventTriggered] - A callback function triggered when a message\n * @param [revalidator] - A function that re-suscribes the listener. Could be usefull if onEventTriggered depend of some state\n * with the specified key is received. The callback receives the message data as its argument.\n *\n * @returns {{ postMessage: (data: S) => void }} An object containing a `postMessage` function\n * that allows broadcasting messages with the specified key and data.\n */\nexport const useCrossFrameMessageListener = <S,>(\n  key: `${MessageKey}` | `${MessageKey}/post` | `${MessageKey}/get`,\n  onEventTriggered?: (data: S) => void,\n  revalidator?: any\n) => {\n  const { allowedOrigins, postMessage, senderId } = useCommunicator();\n\n  useEffect(() => {\n    if (onEventTriggered) {\n      /**\n       * Message handler to process incoming messages.\n       *\n       * - **Message Filtering:** Ensures only messages with the specified `key` are processed.\n       * - **Origin Validation:** Checks that the origin of the message is within the allowed origins.\n       *\n       * @param {MessageEvent<{ type: string; data: S }>} event - The incoming message event object.\n       */\n      const handleMessage = (\n        event: MessageEvent<{ type: string; data: S; senderId: string }>\n      ) => {\n        const { type, data, senderId: msgSenderId } = event.data;\n\n        // Ignore messages that do not match the current key\n        if (type !== key) return;\n\n        // Ignore messages from myself\n        if (msgSenderId === senderId) return;\n\n        // Check if the message origin is allowed\n        if (\n          typeof allowedOrigins === 'undefined' ||\n          allowedOrigins\n            ?.filter((url) => ![null, undefined, '', '*'].includes(url))\n            .some((url) => compareUrls(url, event.origin)) ||\n          allowedOrigins?.includes('*')\n        ) {\n          // Update the local state with the received data\n          onEventTriggered(data);\n        }\n      };\n\n      window.addEventListener('message', handleMessage);\n\n      // Clean up the event listener on unmount\n      return () => window.removeEventListener('message', handleMessage);\n    }\n  }, [allowedOrigins, postMessage, senderId, revalidator]);\n\n  /**\n   * A wrapper function around the `postMessage` function to broadcast messages efficiently.\n   *\n   * - **Encapsulation:** Ensures the `postMessage` function is scoped to the provided key.\n   * - **Ease of Use:** Simplifies broadcasting messages with consistent type and format.\n   *\n   * @param {S} data - The data payload to include in the message.\n   * @returns {void}\n   */\n  const postMessageWrapper: (data?: S) => void = (data) => {\n    postMessage({ type: key, data, senderId });\n  };\n\n  return postMessageWrapper;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAsBA,MAAa,gCACX,KACA,kBACA,gBACG;CACH,MAAM,EAAE,gBAAgB,aAAa,aAAaA,6CAAiB;AAEnE,4BAAgB;AACd,MAAI,kBAAkB;;;;;;;;;GASpB,MAAM,iBACJ,UACG;IACH,MAAM,EAAE,MAAM,MAAM,UAAU,gBAAgB,MAAM;AAGpD,QAAI,SAAS,IAAK;AAGlB,QAAI,gBAAgB,SAAU;AAG9B,QACE,OAAO,mBAAmB,eAC1B,gBACI,QAAQ,QAAQ,CAAC;KAAC;KAAM;KAAW;KAAI;KAAI,CAAC,SAAS,IAAI,CAAC,CAC3D,MAAM,2CAAoB,KAAK,MAAM,OAAO,CAAC,IAChD,gBAAgB,SAAS,IAAI,CAG7B,kBAAiB,KAAK;;AAI1B,UAAO,iBAAiB,WAAW,cAAc;AAGjD,gBAAa,OAAO,oBAAoB,WAAW,cAAc;;IAElE;EAAC;EAAgB;EAAa;EAAU;EAAY,CAAC;;;;;;;;;;CAWxD,MAAMC,sBAA0C,SAAS;AACvD,cAAY;GAAE,MAAM;GAAK;GAAM;GAAU,CAAC;;AAG5C,QAAO"}

package/dist/cjs/useEditorLocale.cjs

@@ -0,0 +1,24 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_useCrossFrameState = require('./useCrossFrameState.cjs');
+let __intlayer_editor = require("@intlayer/editor");
+__intlayer_editor = require_rolldown_runtime.__toESM(__intlayer_editor);
+
+//#region src/useEditorLocale.tsx
+const useEditorLocale = () => {
+	const [currentLocale] = require_useCrossFrameState.useCrossFrameState(__intlayer_editor.MessageKey.INTLAYER_CURRENT_LOCALE, void 0, {
+		receive: true,
+		emit: false
+	});
+	return currentLocale;
+};
+const useSetEditorLocale = () => {
+	return require_useCrossFrameState.useCrossFrameState(__intlayer_editor.MessageKey.INTLAYER_CURRENT_LOCALE, void 0, {
+		receive: true,
+		emit: false
+	});
+};
+
+//#endregion
+exports.useEditorLocale = useEditorLocale;
+exports.useSetEditorLocale = useSetEditorLocale;
+//# sourceMappingURL=useEditorLocale.cjs.map

package/dist/cjs/useEditorLocale.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEditorLocale.cjs","names":["useCrossFrameState","MessageKey"],"sources":["../../src/useEditorLocale.tsx"],"sourcesContent":["import { MessageKey } from '@intlayer/editor';\nimport type { Locale } from '@intlayer/types';\nimport { useCrossFrameState } from './useCrossFrameState';\n\nexport const useEditorLocale = () => {\n  const [currentLocale] = useCrossFrameState<Locale>(\n    MessageKey.INTLAYER_CURRENT_LOCALE,\n    undefined,\n    {\n      receive: true,\n      emit: false,\n    }\n  );\n\n  return currentLocale;\n};\n\nexport const useSetEditorLocale = () => {\n  const setCurrentLocale = useCrossFrameState<Locale>(\n    MessageKey.INTLAYER_CURRENT_LOCALE,\n    undefined,\n    {\n      receive: true,\n      emit: false,\n    }\n  );\n\n  return setCurrentLocale;\n};\n"],"mappings":";;;;;;AAIA,MAAa,wBAAwB;CACnC,MAAM,CAAC,iBAAiBA,8CACtBC,6BAAW,yBACX,QACA;EACE,SAAS;EACT,MAAM;EACP,CACF;AAED,QAAO;;AAGT,MAAa,2BAA2B;AAUtC,QATyBD,8CACvBC,6BAAW,yBACX,QACA;EACE,SAAS;EACT,MAAM;EACP,CACF"}

package/dist/cjs/useFocusUnmergedDictionary.cjs

@@ -0,0 +1,64 @@
+'use client';
+
+
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_DictionariesRecordContext = require('./DictionariesRecordContext.cjs');
+const require_useEditorLocale = require('./useEditorLocale.cjs');
+const require_FocusDictionaryContext = require('./FocusDictionaryContext.cjs');
+let react = require("react");
+react = require_rolldown_runtime.__toESM(react);
+let __intlayer_core = require("@intlayer/core");
+__intlayer_core = require_rolldown_runtime.__toESM(__intlayer_core);
+
+//#region src/useFocusUnmergedDictionary.tsx
+/**
+* Converts merged keypath format to unmerged format.
+* Merged: [{type: "translation", key: "fr"}, {type: "object", key: "title"}]
+* Unmerged: [{type: "object", key: "title"}, {type: "translation", key: "fr"}]
+*/
+const mergedKeyPathToUnmergedKeyPath = (keyPath, dictionaries, locale) => {
+	console.log("test2", {
+		keyPath,
+		dictionaries,
+		locale
+	});
+	for (const dictionary of dictionaries) {
+		console.log("test2", { dictionary });
+		try {
+			const result = (0, __intlayer_core.getContentNodeByKeyPath)(dictionary.content, keyPath ?? [], locale);
+			console.log("test2", { result });
+			if (result) return {
+				keyPath,
+				dictionaryLocalId: dictionary.localId
+			};
+		} catch {}
+	}
+};
+const useFocusUnmergedDictionary = () => {
+	const { localeDictionaries } = require_DictionariesRecordContext.useDictionariesRecord();
+	const currentLocale = require_useEditorLocale.useEditorLocale();
+	const { setFocusedContent, setFocusedContentKeyPath, focusedContent: mergedFocusedContent } = require_FocusDictionaryContext.useFocusDictionary();
+	return {
+		focusedContent: (0, react.useMemo)(() => {
+			if (!mergedFocusedContent) return mergedFocusedContent;
+			if (!localeDictionaries) return mergedFocusedContent;
+			if (mergedFocusedContent.dictionaryLocalId) return mergedFocusedContent;
+			const dictionaries = Object.values(localeDictionaries).filter((dictionary) => dictionary.key === mergedFocusedContent.dictionaryKey);
+			const unmergedKeyPath = mergedKeyPathToUnmergedKeyPath(mergedFocusedContent.keyPath ?? [], dictionaries, currentLocale);
+			return {
+				...mergedFocusedContent,
+				...unmergedKeyPath
+			};
+		}, [
+			mergedFocusedContent,
+			localeDictionaries,
+			currentLocale
+		]),
+		setFocusedContent,
+		setFocusedContentKeyPath
+	};
+};
+
+//#endregion
+exports.useFocusUnmergedDictionary = useFocusUnmergedDictionary;
+//# sourceMappingURL=useFocusUnmergedDictionary.cjs.map

package/dist/cjs/useFocusUnmergedDictionary.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFocusUnmergedDictionary.cjs","names":["useDictionariesRecord","useEditorLocale","useFocusDictionary"],"sources":["../../src/useFocusUnmergedDictionary.tsx"],"sourcesContent":["'use client';\n\nimport { getContentNodeByKeyPath } from '@intlayer/core';\nimport type {\n  Dictionary,\n  KeyPath,\n  LocalDictionaryId,\n  Locale,\n} from '@intlayer/types';\nimport { useMemo } from 'react';\nimport { useDictionariesRecord } from './DictionariesRecordContext';\nimport { type FileContent, useFocusDictionary } from './FocusDictionaryContext';\nimport { useEditorLocale } from './useEditorLocale';\n\ntype UnmergedKeyPath = {\n  keyPath: KeyPath[];\n  dictionaryLocalId?: LocalDictionaryId;\n};\n\n/**\n * Converts merged keypath format to unmerged format.\n * Merged: [{type: \"translation\", key: \"fr\"}, {type: \"object\", key: \"title\"}]\n * Unmerged: [{type: \"object\", key: \"title\"}, {type: \"translation\", key: \"fr\"}]\n */\nconst mergedKeyPathToUnmergedKeyPath = (\n  keyPath: KeyPath[],\n  dictionaries: Dictionary[],\n  locale: Locale\n): UnmergedKeyPath | undefined => {\n  console.log('test2', { keyPath, dictionaries, locale });\n\n  // If we have a dictionary, verify the path exists\n  // Try to find the correct position for the translation key\n  // by checking which path actually exists in the dictionary\n  for (const dictionary of dictionaries) {\n    console.log('test2', { dictionary });\n    try {\n      const result = getContentNodeByKeyPath(\n        dictionary.content,\n        keyPath ?? [],\n        locale\n      );\n\n      console.log('test2', { result });\n\n      if (result) {\n        return { keyPath, dictionaryLocalId: dictionary.localId };\n      }\n    } catch {\n      // Continue to next candidate\n    }\n  }\n};\n\nexport const useFocusUnmergedDictionary = () => {\n  const { localeDictionaries } = useDictionariesRecord();\n  const currentLocale = useEditorLocale();\n  const {\n    setFocusedContent,\n    setFocusedContentKeyPath,\n    focusedContent: mergedFocusedContent,\n  } = useFocusDictionary();\n\n  const focusedContent = useMemo<FileContent | null>(() => {\n    if (!mergedFocusedContent) return mergedFocusedContent;\n    if (!localeDictionaries) return mergedFocusedContent;\n    if (mergedFocusedContent.dictionaryLocalId) return mergedFocusedContent;\n\n    const dictionaries = Object.values(localeDictionaries).filter(\n      (dictionary) => dictionary.key === mergedFocusedContent.dictionaryKey\n    );\n\n    const unmergedKeyPath = mergedKeyPathToUnmergedKeyPath(\n      mergedFocusedContent.keyPath ?? [],\n      dictionaries,\n      currentLocale\n    );\n\n    return {\n      ...mergedFocusedContent,\n      ...unmergedKeyPath,\n    };\n  }, [mergedFocusedContent, localeDictionaries, currentLocale]);\n\n  return {\n    focusedContent,\n    setFocusedContent,\n    setFocusedContentKeyPath,\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAwBA,MAAM,kCACJ,SACA,cACA,WACgC;AAChC,SAAQ,IAAI,SAAS;EAAE;EAAS;EAAc;EAAQ,CAAC;AAKvD,MAAK,MAAM,cAAc,cAAc;AACrC,UAAQ,IAAI,SAAS,EAAE,YAAY,CAAC;AACpC,MAAI;GACF,MAAM,sDACJ,WAAW,SACX,WAAW,EAAE,EACb,OACD;AAED,WAAQ,IAAI,SAAS,EAAE,QAAQ,CAAC;AAEhC,OAAI,OACF,QAAO;IAAE;IAAS,mBAAmB,WAAW;IAAS;UAErD;;;AAMZ,MAAa,mCAAmC;CAC9C,MAAM,EAAE,uBAAuBA,yDAAuB;CACtD,MAAM,gBAAgBC,yCAAiB;CACvC,MAAM,EACJ,mBACA,0BACA,gBAAgB,yBACdC,mDAAoB;AAuBxB,QAAO;EACL,yCAtBuD;AACvD,OAAI,CAAC,qBAAsB,QAAO;AAClC,OAAI,CAAC,mBAAoB,QAAO;AAChC,OAAI,qBAAqB,kBAAmB,QAAO;GAEnD,MAAM,eAAe,OAAO,OAAO,mBAAmB,CAAC,QACpD,eAAe,WAAW,QAAQ,qBAAqB,cACzD;GAED,MAAM,kBAAkB,+BACtB,qBAAqB,WAAW,EAAE,EAClC,cACA,cACD;AAED,UAAO;IACL,GAAG;IACH,GAAG;IACJ;KACA;GAAC;GAAsB;GAAoB;GAAc,CAAC;EAI3D;EACA;EACD"}

package/dist/esm/EditedContentContext.mjs

@@ -4,10 +4,12 @@
 import { useCrossFrameMessageListener } from "./useCrossFrameMessageListener.mjs";
 import { useCrossFrameState } from "./useCrossFrameState.mjs";
 import { useDictionariesRecord } from "./DictionariesRecordContext.mjs";
+import { useEditorLocale } from "./useEditorLocale.mjs";
 import { createContext, useContext } from "react";
 import { jsx } from "react/jsx-runtime";
 import { MessageKey } from "@intlayer/editor";
 import { editDictionaryByKeyPath, getContentNodeByKeyPath, renameContentNodeByKeyPath } from "@intlayer/core";
+import { NodeType } from "@intlayer/types";
 
 //#region src/EditedContentContext.tsx
 const EditedContentStateContext = createContext(void 0);
@@ -17,6 +19,7 @@ const EditedContentActionsContext = createContext(void 0);
 const resolveState = (state, prevState) => typeof state === "function" ? state(prevState) : state;
 const EditedContentProvider = ({ children }) => {
 	const { localeDictionaries } = useDictionariesRecord();
+	const currentLocale = useEditorLocale();
 	const [editedContent, setEditedContentState] = useCrossFrameState(MessageKey.INTLAYER_EDITED_CONTENT_CHANGED);
 	const setEditedDictionary = (newValue) => {
 		let updatedDictionaries = resolveState(newValue);
@@ -120,10 +123,11 @@ const EditedContentProvider = ({ children }) => {
 	};
 	const getEditedContentValue = (localDictionaryIdOrKey, keyPath) => {
 		if (!editedContent) return void 0;
-		if (localDictionaryIdOrKey.includes(":local:") || localDictionaryIdOrKey.includes(":remote:")) return getContentNodeByKeyPath(editedContent?.[localDictionaryIdOrKey]?.content ?? {}, keyPath);
+		const filteredKeyPath = keyPath.filter((key) => key.type !== NodeType.Translation);
+		if (localDictionaryIdOrKey.includes(":local:") || localDictionaryIdOrKey.includes(":remote:")) return getContentNodeByKeyPath(editedContent?.[localDictionaryIdOrKey]?.content ?? {}, filteredKeyPath, currentLocale);
 		const filteredDictionariesLocalId = Object.keys(editedContent).filter((key) => key.startsWith(`${localDictionaryIdOrKey}:`));
 		for (const localDictionaryId of filteredDictionariesLocalId) {
-			const contentNode = getContentNodeByKeyPath(editedContent?.[localDictionaryId]?.content ?? {}, keyPath);
+			const contentNode = getContentNodeByKeyPath(editedContent?.[localDictionaryId]?.content ?? {}, filteredKeyPath, currentLocale);
 			if (contentNode) return contentNode;
 		}
 	};