@intlayer/editor-react 8.4.4 → 8.4.6

package/dist/esm/EditorProvider.mjs

@@ -1,2 +1,41 @@
-"use client";import{EditorStateProvider as e}from"./EditorStateContext.mjs";import{useEffect as t,useRef as n}from"react";import{jsx as r}from"react/jsx-runtime";import{EditorStateManager as i,defineIntlayerElements as a,setGlobalEditorManager as o}from"@intlayer/editor";const s=({children:s,configuration:c,postMessage:l,allowedOrigins:u})=>{let d=n(null);d.current||=new i({mode:`editor`,messenger:{allowedOrigins:u,postMessageFn:l},configuration:c});let f=d.current;return t(()=>(a(),o(f),f.start(),()=>{f.stop(),o(null)}),[f]),r(e,{manager:f,children:s})};export{s as EditorProvider};
+'use client';
+
+import { EditorStateProvider } from "./EditorStateContext.mjs";
+import { useEffect, useRef } from "react";
+import { jsx } from "react/jsx-runtime";
+import { EditorStateManager, defineIntlayerElements, setGlobalEditorManager } from "@intlayer/editor";
+
+//#region src/EditorProvider.tsx
+/**
+* EditorProvider creates and manages the lifecycle of an EditorStateManager,
+* provides it to all descendants, and registers the Lit web components.
+*/
+const EditorProvider = ({ children, configuration, postMessage, allowedOrigins }) => {
+	const managerRef = useRef(null);
+	if (!managerRef.current) managerRef.current = new EditorStateManager({
+		mode: "editor",
+		messenger: {
+			allowedOrigins,
+			postMessageFn: postMessage
+		},
+		configuration
+	});
+	const manager = managerRef.current;
+	useEffect(() => {
+		defineIntlayerElements();
+		setGlobalEditorManager(manager);
+		manager.start();
+		return () => {
+			manager.stop();
+			setGlobalEditorManager(null);
+		};
+	}, [manager]);
+	return /* @__PURE__ */ jsx(EditorStateProvider, {
+		manager,
+		children
+	});
+};
+
+//#endregion
+export { EditorProvider };
 //# sourceMappingURL=EditorProvider.mjs.map

package/dist/esm/EditorProvider.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"EditorProvider.mjs","names":[],"sources":["../../src/EditorProvider.tsx"],"sourcesContent":["'use client';\n\nimport {\n  defineIntlayerElements,\n  EditorStateManager,\n  type MessengerConfig,\n  setGlobalEditorManager,\n} from '@intlayer/editor';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport { type FC, type PropsWithChildren, useEffect, useRef } from 'react';\nimport { EditorStateProvider } from './EditorStateContext';\n\nexport type EditorProviderProps = {\n  configuration: IntlayerConfig;\n  postMessage: (data: any) => void;\n  allowedOrigins: string[];\n};\n\n/**\n * EditorProvider creates and manages the lifecycle of an EditorStateManager,\n * provides it to all descendants, and registers the Lit web components.\n */\nexport const EditorProvider: FC<PropsWithChildren<EditorProviderProps>> = ({\n  children,\n  configuration,\n  postMessage,\n  allowedOrigins,\n}) => {\n  const managerRef = useRef<EditorStateManager | null>(null);\n\n  if (!managerRef.current) {\n    const messengerConfig: MessengerConfig = {\n      allowedOrigins,\n      postMessageFn: postMessage,\n    };\n\n    managerRef.current = new EditorStateManager({\n      mode: 'editor',\n      messenger: messengerConfig,\n      configuration,\n    });\n  }\n  const manager = managerRef.current;\n\n  useEffect(() => {\n    defineIntlayerElements();\n    setGlobalEditorManager(manager);\n\n    manager.start();\n    return () => {\n      manager.stop();\n      setGlobalEditorManager(null);\n    };\n  }, [manager]);\n\n  return (\n    <EditorStateProvider manager={manager}>{children}</EditorStateProvider>\n  );\n};\n"],"mappings":"gRAsBA,MAAa,GAA8D,CACzE,WACA,gBACA,cACA,oBACI,CACJ,IAAM,EAAa,EAAkC,KAAK,CAE1D,AAME,EAAW,UAAU,IAAI,EAAmB,CAC1C,KAAM,SACN,UAPuC,CACvC,iBACA,cAAe,EAChB,CAKC,gBACD,CAAC,CAEJ,IAAM,EAAU,EAAW,QAa3B,OAXA,OACE,GAAwB,CACxB,EAAuB,EAAQ,CAE/B,EAAQ,OAAO,KACF,CACX,EAAQ,MAAM,CACd,EAAuB,KAAK,GAE7B,CAAC,EAAQ,CAAC,CAGX,EAAC,EAAD,CAA8B,UAAU,WAA+B,CAAA"}
+{"version":3,"file":"EditorProvider.mjs","names":[],"sources":["../../src/EditorProvider.tsx"],"sourcesContent":["'use client';\n\nimport {\n  defineIntlayerElements,\n  EditorStateManager,\n  type MessengerConfig,\n  setGlobalEditorManager,\n} from '@intlayer/editor';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport { type FC, type PropsWithChildren, useEffect, useRef } from 'react';\nimport { EditorStateProvider } from './EditorStateContext';\n\nexport type EditorProviderProps = {\n  configuration: IntlayerConfig;\n  postMessage: (data: any) => void;\n  allowedOrigins: string[];\n};\n\n/**\n * EditorProvider creates and manages the lifecycle of an EditorStateManager,\n * provides it to all descendants, and registers the Lit web components.\n */\nexport const EditorProvider: FC<PropsWithChildren<EditorProviderProps>> = ({\n  children,\n  configuration,\n  postMessage,\n  allowedOrigins,\n}) => {\n  const managerRef = useRef<EditorStateManager | null>(null);\n\n  if (!managerRef.current) {\n    const messengerConfig: MessengerConfig = {\n      allowedOrigins,\n      postMessageFn: postMessage,\n    };\n\n    managerRef.current = new EditorStateManager({\n      mode: 'editor',\n      messenger: messengerConfig,\n      configuration,\n    });\n  }\n  const manager = managerRef.current;\n\n  useEffect(() => {\n    defineIntlayerElements();\n    setGlobalEditorManager(manager);\n\n    manager.start();\n    return () => {\n      manager.stop();\n      setGlobalEditorManager(null);\n    };\n  }, [manager]);\n\n  return (\n    <EditorStateProvider manager={manager}>{children}</EditorStateProvider>\n  );\n};\n"],"mappings":";;;;;;;;;;;;AAsBA,MAAa,kBAA8D,EACzE,UACA,eACA,aACA,qBACI;CACJ,MAAM,aAAa,OAAkC,KAAK;AAE1D,KAAI,CAAC,WAAW,QAMd,YAAW,UAAU,IAAI,mBAAmB;EAC1C,MAAM;EACN,WAPuC;GACvC;GACA,eAAe;GAChB;EAKC;EACD,CAAC;CAEJ,MAAM,UAAU,WAAW;AAE3B,iBAAgB;AACd,0BAAwB;AACxB,yBAAuB,QAAQ;AAE/B,UAAQ,OAAO;AACf,eAAa;AACX,WAAQ,MAAM;AACd,0BAAuB,KAAK;;IAE7B,CAAC,QAAQ,CAAC;AAEb,QACE,oBAAC,qBAAD;EAA8B;EAAU;EAA+B"}

package/dist/esm/EditorStateContext.mjs

@@ -1,2 +1,16 @@
-"use client";import{createContext as e,useContext as t}from"react";import{jsx as n}from"react/jsx-runtime";const r=e(null),i=({children:e,manager:t})=>n(r.Provider,{value:t,children:e}),a=()=>t(r);export{i as EditorStateProvider,a as useEditorStateManager};
+'use client';
+
+import { createContext, useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/EditorStateContext.tsx
+const EditorStateContext = createContext(null);
+const EditorStateProvider = ({ children, manager }) => /* @__PURE__ */ jsx(EditorStateContext.Provider, {
+	value: manager,
+	children
+});
+const useEditorStateManager = () => useContext(EditorStateContext);
+
+//#endregion
+export { EditorStateProvider, useEditorStateManager };
 //# sourceMappingURL=EditorStateContext.mjs.map

package/dist/esm/EditorStateContext.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"EditorStateContext.mjs","names":[],"sources":["../../src/EditorStateContext.tsx"],"sourcesContent":["'use client';\n\nimport type { EditorStateManager } from '@intlayer/editor';\nimport {\n  createContext,\n  type FC,\n  type PropsWithChildren,\n  useContext,\n} from 'react';\n\nconst EditorStateContext = createContext<EditorStateManager | null>(null);\n\nexport const EditorStateProvider: FC<\n  PropsWithChildren<{ manager: EditorStateManager }>\n> = ({ children, manager }) => (\n  <EditorStateContext.Provider value={manager}>\n    {children}\n  </EditorStateContext.Provider>\n);\n\nexport const useEditorStateManager = (): EditorStateManager | null =>\n  useContext(EditorStateContext);\n"],"mappings":"2GAUA,MAAM,EAAqB,EAAyC,KAAK,CAE5D,GAER,CAAE,WAAU,aACf,EAAC,EAAmB,SAApB,CAA6B,MAAO,EACjC,WAC2B,CAAA,CAGnB,MACX,EAAW,EAAmB"}
+{"version":3,"file":"EditorStateContext.mjs","names":[],"sources":["../../src/EditorStateContext.tsx"],"sourcesContent":["'use client';\n\nimport type { EditorStateManager } from '@intlayer/editor';\nimport {\n  createContext,\n  type FC,\n  type PropsWithChildren,\n  useContext,\n} from 'react';\n\nconst EditorStateContext = createContext<EditorStateManager | null>(null);\n\nexport const EditorStateProvider: FC<\n  PropsWithChildren<{ manager: EditorStateManager }>\n> = ({ children, manager }) => (\n  <EditorStateContext.Provider value={manager}>\n    {children}\n  </EditorStateContext.Provider>\n);\n\nexport const useEditorStateManager = (): EditorStateManager | null =>\n  useContext(EditorStateContext);\n"],"mappings":";;;;;;AAUA,MAAM,qBAAqB,cAAyC,KAAK;AAEzE,MAAa,uBAER,EAAE,UAAU,cACf,oBAAC,mBAAmB,UAApB;CAA6B,OAAO;CACjC;CAC2B;AAGhC,MAAa,8BACX,WAAW,mBAAmB"}

package/dist/esm/FocusDictionaryContext.mjs

@@ -1,2 +1,35 @@
-"use client";import{useEditorStateManager as e}from"./EditorStateContext.mjs";import{useEffect as t,useState as n}from"react";const r=()=>{let r=e(),[i,a]=n(r?.focusedContent.value??null);return t(()=>{if(!r)return;let e=e=>a(e.detail);return r.focusedContent.addEventListener(`change`,e),()=>r.focusedContent.removeEventListener(`change`,e)},[r]),{focusedContent:i,setFocusedContent:e=>r?.focusedContent.set(e),setFocusedContentKeyPath:e=>r?.setFocusedContentKeyPath(e)}},i=()=>{let{setFocusedContent:e,setFocusedContentKeyPath:t}=r();return{setFocusedContent:e,setFocusedContentKeyPath:t}};export{r as useFocusDictionary,i as useFocusDictionaryActions};
+'use client';
+
+import { useEditorStateManager } from "./EditorStateContext.mjs";
+import { useEffect, useState } from "react";
+
+//#region src/FocusDictionaryContext.tsx
+/**
+* Returns the focused-content state and setters, backed by EditorStateManager.
+*/
+const useFocusDictionary = () => {
+	const manager = useEditorStateManager();
+	const [focusedContent, setFocusedContentState] = useState(manager?.focusedContent.value ?? null);
+	useEffect(() => {
+		if (!manager) return;
+		const handler = (e) => setFocusedContentState(e.detail);
+		manager.focusedContent.addEventListener("change", handler);
+		return () => manager.focusedContent.removeEventListener("change", handler);
+	}, [manager]);
+	return {
+		focusedContent,
+		setFocusedContent: (value) => manager?.focusedContent.set(value),
+		setFocusedContentKeyPath: (keyPath) => manager?.setFocusedContentKeyPath(keyPath)
+	};
+};
+const useFocusDictionaryActions = () => {
+	const { setFocusedContent, setFocusedContentKeyPath } = useFocusDictionary();
+	return {
+		setFocusedContent,
+		setFocusedContentKeyPath
+	};
+};
+
+//#endregion
+export { useFocusDictionary, useFocusDictionaryActions };
 //# sourceMappingURL=FocusDictionaryContext.mjs.map

package/dist/esm/FocusDictionaryContext.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"FocusDictionaryContext.mjs","names":[],"sources":["../../src/FocusDictionaryContext.tsx"],"sourcesContent":["'use client';\n\nimport type { FileContent } from '@intlayer/editor';\nimport type { KeyPath } from '@intlayer/types/keyPath';\nimport { useEffect, useState } from 'react';\nimport { useEditorStateManager } from './EditorStateContext';\n\nexport type { FileContent } from '@intlayer/editor';\n\nexport type FocusDictionaryState = {\n  focusedContent: FileContent | null;\n};\n\nexport type FocusDictionaryActions = {\n  setFocusedContent: (value: FileContent | null) => void;\n  setFocusedContentKeyPath: (keyPath: KeyPath[]) => void;\n};\n\n/**\n * Returns the focused-content state and setters, backed by EditorStateManager.\n */\nexport const useFocusDictionary = (): FocusDictionaryState &\n  FocusDictionaryActions => {\n  const manager = useEditorStateManager();\n  const [focusedContent, setFocusedContentState] = useState<FileContent | null>(\n    manager?.focusedContent.value ?? null\n  );\n\n  useEffect(() => {\n    if (!manager) return;\n    const handler = (e: Event) =>\n      setFocusedContentState((e as CustomEvent<FileContent | null>).detail);\n    manager.focusedContent.addEventListener('change', handler);\n    return () => manager.focusedContent.removeEventListener('change', handler);\n  }, [manager]);\n\n  return {\n    focusedContent,\n    setFocusedContent: (value: FileContent | null) =>\n      manager?.focusedContent.set(value),\n    setFocusedContentKeyPath: (keyPath: KeyPath[]) =>\n      manager?.setFocusedContentKeyPath(keyPath),\n  };\n};\n\nexport const useFocusDictionaryActions = (): FocusDictionaryActions => {\n  const { setFocusedContent, setFocusedContentKeyPath } = useFocusDictionary();\n  return { setFocusedContent, setFocusedContentKeyPath };\n};\n"],"mappings":"8HAqBA,MAAa,MACe,CAC1B,IAAM,EAAU,GAAuB,CACjC,CAAC,EAAgB,GAA0B,EAC/C,GAAS,eAAe,OAAS,KAClC,CAUD,OARA,MAAgB,CACd,GAAI,CAAC,EAAS,OACd,IAAM,EAAW,GACf,EAAwB,EAAsC,OAAO,CAEvE,OADA,EAAQ,eAAe,iBAAiB,SAAU,EAAQ,KAC7C,EAAQ,eAAe,oBAAoB,SAAU,EAAQ,EACzE,CAAC,EAAQ,CAAC,CAEN,CACL,iBACA,kBAAoB,GAClB,GAAS,eAAe,IAAI,EAAM,CACpC,yBAA2B,GACzB,GAAS,yBAAyB,EAAQ,CAC7C,EAGU,MAA0D,CACrE,GAAM,CAAE,oBAAmB,4BAA6B,GAAoB,CAC5E,MAAO,CAAE,oBAAmB,2BAA0B"}
+{"version":3,"file":"FocusDictionaryContext.mjs","names":[],"sources":["../../src/FocusDictionaryContext.tsx"],"sourcesContent":["'use client';\n\nimport type { FileContent } from '@intlayer/editor';\nimport type { KeyPath } from '@intlayer/types/keyPath';\nimport { useEffect, useState } from 'react';\nimport { useEditorStateManager } from './EditorStateContext';\n\nexport type { FileContent } from '@intlayer/editor';\n\nexport type FocusDictionaryState = {\n  focusedContent: FileContent | null;\n};\n\nexport type FocusDictionaryActions = {\n  setFocusedContent: (value: FileContent | null) => void;\n  setFocusedContentKeyPath: (keyPath: KeyPath[]) => void;\n};\n\n/**\n * Returns the focused-content state and setters, backed by EditorStateManager.\n */\nexport const useFocusDictionary = (): FocusDictionaryState &\n  FocusDictionaryActions => {\n  const manager = useEditorStateManager();\n  const [focusedContent, setFocusedContentState] = useState<FileContent | null>(\n    manager?.focusedContent.value ?? null\n  );\n\n  useEffect(() => {\n    if (!manager) return;\n    const handler = (e: Event) =>\n      setFocusedContentState((e as CustomEvent<FileContent | null>).detail);\n    manager.focusedContent.addEventListener('change', handler);\n\n    return () => manager.focusedContent.removeEventListener('change', handler);\n  }, [manager]);\n\n  return {\n    focusedContent,\n    setFocusedContent: (value: FileContent | null) =>\n      manager?.focusedContent.set(value),\n    setFocusedContentKeyPath: (keyPath: KeyPath[]) =>\n      manager?.setFocusedContentKeyPath(keyPath),\n  };\n};\n\nexport const useFocusDictionaryActions = (): FocusDictionaryActions => {\n  const { setFocusedContent, setFocusedContentKeyPath } = useFocusDictionary();\n  return { setFocusedContent, setFocusedContentKeyPath };\n};\n"],"mappings":";;;;;;;;;AAqBA,MAAa,2BACe;CAC1B,MAAM,UAAU,uBAAuB;CACvC,MAAM,CAAC,gBAAgB,0BAA0B,SAC/C,SAAS,eAAe,SAAS,KAClC;AAED,iBAAgB;AACd,MAAI,CAAC,QAAS;EACd,MAAM,WAAW,MACf,uBAAwB,EAAsC,OAAO;AACvE,UAAQ,eAAe,iBAAiB,UAAU,QAAQ;AAE1D,eAAa,QAAQ,eAAe,oBAAoB,UAAU,QAAQ;IACzE,CAAC,QAAQ,CAAC;AAEb,QAAO;EACL;EACA,oBAAoB,UAClB,SAAS,eAAe,IAAI,MAAM;EACpC,2BAA2B,YACzB,SAAS,yBAAyB,QAAQ;EAC7C;;AAGH,MAAa,kCAA0D;CACrE,MAAM,EAAE,mBAAmB,6BAA6B,oBAAoB;AAC5E,QAAO;EAAE;EAAmB;EAA0B"}

package/dist/esm/index.mjs

@@ -1 +1,17 @@
-import{EditorStateProvider as e,useEditorStateManager as t}from"./EditorStateContext.mjs";import{useFocusDictionary as n,useFocusDictionaryActions as r}from"./FocusDictionaryContext.mjs";import{useCrossFrameState as i}from"./useCrossFrameState.mjs";import{useCrossURLPathSetter as a,useCrossURLPathState as o}from"./useCrossURLPathState.mjs";import{useDictionariesRecord as s,useDictionariesRecordActions as c}from"./DictionariesRecordContext.mjs";import{useEditorLocale as l,useSetEditorLocale as u}from"./useEditorLocale.mjs";import{useFocusUnmergedDictionary as d}from"./useFocusUnmergedDictionary.mjs";import{EditorProvider as f}from"./EditorProvider.mjs";import{useCommunicator as p}from"./CommunicatorContext.mjs";import{ConfigurationProvider as m,useConfiguration as h,useConfigurationState as g}from"./ConfigurationContext.mjs";import{useEditedContent as _,useEditedContentActions as v,useGetEditedContentState as y,usePostEditedContentState as b}from"./EditedContentContext.mjs";import{useEditorEnabled as x,useEditorEnabledState as S,useEditorPingClient as C,useGetEditorEnabledState as w,usePostEditorEnabledState as T}from"./EditorEnabledContext.mjs";import{useCrossFrameMessageListener as E}from"./useCrossFrameMessageListener.mjs";import{useIframeClickInterceptor as D,useIframeClickMerger as O}from"./useIframeClickInterceptor.mjs";import{MessageKey as k}from"@intlayer/editor";export{m as ConfigurationProvider,f as EditorProvider,e as EditorStateProvider,k as MessageKey,p as useCommunicator,h as useConfiguration,g as useConfigurationState,E as useCrossFrameMessageListener,i as useCrossFrameState,a as useCrossURLPathSetter,o as useCrossURLPathState,s as useDictionariesRecord,c as useDictionariesRecordActions,_ as useEditedContent,v as useEditedContentActions,x as useEditorEnabled,S as useEditorEnabledState,l as useEditorLocale,C as useEditorPingClient,t as useEditorStateManager,n as useFocusDictionary,r as useFocusDictionaryActions,d as useFocusUnmergedDictionary,y as useGetEditedContentState,w as useGetEditorEnabledState,D as useIframeClickInterceptor,O as useIframeClickMerger,b as usePostEditedContentState,T as usePostEditorEnabledState,u as useSetEditorLocale};
+import { EditorStateProvider, useEditorStateManager } from "./EditorStateContext.mjs";
+import { useFocusDictionary, useFocusDictionaryActions } from "./FocusDictionaryContext.mjs";
+import { useCrossFrameState } from "./useCrossFrameState.mjs";
+import { useCrossURLPathSetter, useCrossURLPathState } from "./useCrossURLPathState.mjs";
+import { useDictionariesRecord, useDictionariesRecordActions } from "./DictionariesRecordContext.mjs";
+import { useEditorLocale, useSetEditorLocale } from "./useEditorLocale.mjs";
+import { useFocusUnmergedDictionary } from "./useFocusUnmergedDictionary.mjs";
+import { EditorProvider } from "./EditorProvider.mjs";
+import { useCommunicator } from "./CommunicatorContext.mjs";
+import { ConfigurationProvider, useConfiguration, useConfigurationState } from "./ConfigurationContext.mjs";
+import { useEditedContent, useEditedContentActions, useGetEditedContentState, usePostEditedContentState } from "./EditedContentContext.mjs";
+import { useEditorEnabled, useEditorEnabledState, useEditorPingClient, useGetEditorEnabledState, usePostEditorEnabledState } from "./EditorEnabledContext.mjs";
+import { useCrossFrameMessageListener } from "./useCrossFrameMessageListener.mjs";
+import { useIframeClickInterceptor, useIframeClickMerger } from "./useIframeClickInterceptor.mjs";
+import { MessageKey } from "@intlayer/editor";
+
+export { ConfigurationProvider, EditorProvider, EditorStateProvider, MessageKey, useCommunicator, useConfiguration, useConfigurationState, useCrossFrameMessageListener, useCrossFrameState, useCrossURLPathSetter, useCrossURLPathState, useDictionariesRecord, useDictionariesRecordActions, useEditedContent, useEditedContentActions, useEditorEnabled, useEditorEnabledState, useEditorLocale, useEditorPingClient, useEditorStateManager, useFocusDictionary, useFocusDictionaryActions, useFocusUnmergedDictionary, useGetEditedContentState, useGetEditorEnabledState, useIframeClickInterceptor, useIframeClickMerger, usePostEditedContentState, usePostEditorEnabledState, useSetEditorLocale };

package/dist/esm/useCrossFrameMessageListener.mjs

@@ -1,2 +1,30 @@
-"use client";import{useEditorStateManager as e}from"./EditorStateContext.mjs";import{useEffect as t}from"react";const n=(n,r,i)=>{let a=e();return t(()=>{if(r)return a?.messenger.subscribe(n,r)},[a,n,i]),e=>{a?.messenger.send(n,e)}};export{n as useCrossFrameMessageListener};
+'use client';
+
+import { useEditorStateManager } from "./EditorStateContext.mjs";
+import { useEffect } from "react";
+
+//#region src/useCrossFrameMessageListener.tsx
+/**
+* Listens for cross-frame messages of the specified type and calls the callback.
+* Returns a function to manually send a message of the same type.
+*
+* Backed by CrossFrameMessenger from EditorStateManager.
+*/
+const useCrossFrameMessageListener = (key, onEventTriggered, revalidator) => {
+	const manager = useEditorStateManager();
+	useEffect(() => {
+		if (!onEventTriggered) return;
+		return manager?.messenger.subscribe(key, onEventTriggered);
+	}, [
+		manager,
+		key,
+		revalidator
+	]);
+	return (data) => {
+		manager?.messenger.send(key, data);
+	};
+};
+
+//#endregion
+export { useCrossFrameMessageListener };
 //# sourceMappingURL=useCrossFrameMessageListener.mjs.map

package/dist/esm/useCrossFrameMessageListener.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"useCrossFrameMessageListener.mjs","names":[],"sources":["../../src/useCrossFrameMessageListener.tsx"],"sourcesContent":["'use client';\n\nimport type { MessageKey } from '@intlayer/editor';\nimport { useEffect } from 'react';\nimport { useEditorStateManager } from './EditorStateContext';\n\n/**\n * Listens for cross-frame messages of the specified type and calls the callback.\n * Returns a function to manually send a message of the same type.\n *\n * Backed by CrossFrameMessenger from EditorStateManager.\n */\nexport const useCrossFrameMessageListener = <S,>(\n  key: `${MessageKey}` | `${MessageKey}/post` | `${MessageKey}/get`,\n  onEventTriggered?: (data: S) => void,\n  revalidator?: any\n) => {\n  const manager = useEditorStateManager();\n\n  useEffect(() => {\n    if (!onEventTriggered) return;\n    return manager?.messenger.subscribe<S>(key, onEventTriggered);\n  }, [manager, key, revalidator]);\n\n  return (data?: S) => {\n    manager?.messenger.send(key, data);\n  };\n};\n"],"mappings":"gHAYA,MAAa,GACX,EACA,EACA,IACG,CACH,IAAM,EAAU,GAAuB,CAOvC,OALA,MAAgB,CACT,KACL,OAAO,GAAS,UAAU,UAAa,EAAK,EAAiB,EAC5D,CAAC,EAAS,EAAK,EAAY,CAAC,CAEvB,GAAa,CACnB,GAAS,UAAU,KAAK,EAAK,EAAK"}
+{"version":3,"file":"useCrossFrameMessageListener.mjs","names":[],"sources":["../../src/useCrossFrameMessageListener.tsx"],"sourcesContent":["'use client';\n\nimport type { MessageKey } from '@intlayer/editor';\nimport { useEffect } from 'react';\nimport { useEditorStateManager } from './EditorStateContext';\n\n/**\n * Listens for cross-frame messages of the specified type and calls the callback.\n * Returns a function to manually send a message of the same type.\n *\n * Backed by CrossFrameMessenger from EditorStateManager.\n */\nexport const useCrossFrameMessageListener = <S,>(\n  key: `${MessageKey}` | `${MessageKey}/post` | `${MessageKey}/get`,\n  onEventTriggered?: (data: S) => void,\n  revalidator?: any\n) => {\n  const manager = useEditorStateManager();\n\n  useEffect(() => {\n    if (!onEventTriggered) return;\n    return manager?.messenger.subscribe<S>(key, onEventTriggered);\n  }, [manager, key, revalidator]);\n\n  return (data?: S) => {\n    manager?.messenger.send(key, data);\n  };\n};\n"],"mappings":";;;;;;;;;;;;AAYA,MAAa,gCACX,KACA,kBACA,gBACG;CACH,MAAM,UAAU,uBAAuB;AAEvC,iBAAgB;AACd,MAAI,CAAC,iBAAkB;AACvB,SAAO,SAAS,UAAU,UAAa,KAAK,iBAAiB;IAC5D;EAAC;EAAS;EAAK;EAAY,CAAC;AAE/B,SAAQ,SAAa;AACnB,WAAS,UAAU,KAAK,KAAK,KAAK"}

package/dist/esm/useCrossFrameState.mjs

@@ -1,2 +1,63 @@
-"use client";import{useEditorStateManager as e}from"./EditorStateContext.mjs";import{useEffect as t,useRef as n,useState as r}from"react";import{CrossFrameStateManager as i}from"@intlayer/editor";const a=(a,o,s)=>{let c=e(),l=typeof o==`function`?o():o,[u,d]=r(l),f=n(l),p=n(null);return t(()=>{let{emit:e=!0,receive:t=!0}=s??{},n=new i(a,c?.messenger,{emit:e,receive:t,initialValue:l});p.current=n;let r=e=>{let t=e.detail;f.current=t,d(t)};return n.addEventListener(`change`,r),n.start(),()=>{n.removeEventListener(`change`,r),n.stop(),p.current=null}},[a,c?.messenger,s?.emit,s?.receive]),[u,e=>{d(t=>{let n=typeof e==`function`?e(t):e;return f.current=n,p.current?.set(n),n})},()=>{p.current?.postCurrentValue()}]};export{a as useCrossFrameState};
+'use client';
+
+import { useEditorStateManager } from "./EditorStateContext.mjs";
+import { useEffect, useRef, useState } from "react";
+import { CrossFrameStateManager } from "@intlayer/editor";
+
+//#region src/useCrossFrameState.tsx
+/**
+* Synchronizes a React state value across frames using CrossFrameStateManager.
+*/
+const useCrossFrameState = (key, initialState, options) => {
+	const manager = useEditorStateManager();
+	const resolvedInitial = typeof initialState === "function" ? initialState() : initialState;
+	const [value, setValueState] = useState(resolvedInitial);
+	const valueRef = useRef(resolvedInitial);
+	const stateManagerRef = useRef(null);
+	useEffect(() => {
+		const { emit = true, receive = true } = options ?? {};
+		const stateManager = new CrossFrameStateManager(key, manager?.messenger, {
+			emit,
+			receive,
+			initialValue: resolvedInitial
+		});
+		stateManagerRef.current = stateManager;
+		const handler = (e) => {
+			const newValue = e.detail;
+			valueRef.current = newValue;
+			setValueState(newValue);
+		};
+		stateManager.addEventListener("change", handler);
+		stateManager.start();
+		return () => {
+			stateManager.removeEventListener("change", handler);
+			stateManager.stop();
+			stateManagerRef.current = null;
+		};
+	}, [
+		key,
+		manager?.messenger,
+		options?.emit,
+		options?.receive
+	]);
+	const setValue = (valueOrUpdater) => {
+		setValueState((prev) => {
+			const newValue = typeof valueOrUpdater === "function" ? valueOrUpdater(prev) : valueOrUpdater;
+			valueRef.current = newValue;
+			stateManagerRef.current?.set(newValue);
+			return newValue;
+		});
+	};
+	const postState = () => {
+		stateManagerRef.current?.postCurrentValue();
+	};
+	return [
+		value,
+		setValue,
+		postState
+	];
+};
+
+//#endregion
+export { useCrossFrameState };
 //# sourceMappingURL=useCrossFrameState.mjs.map

package/dist/esm/useCrossFrameState.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"useCrossFrameState.mjs","names":[],"sources":["../../src/useCrossFrameState.tsx"],"sourcesContent":["'use client';\n\nimport type { MessageKey } from '@intlayer/editor';\nimport { CrossFrameStateManager } from '@intlayer/editor';\nimport {\n  type Dispatch,\n  type SetStateAction,\n  useEffect,\n  useRef,\n  useState,\n} from 'react';\nimport { useEditorStateManager } from './EditorStateContext';\n\nexport type CrossFrameStateOptions = {\n  emit?: boolean;\n  receive?: boolean;\n};\n\n/**\n * Synchronizes a React state value across frames using CrossFrameStateManager.\n */\nexport const useCrossFrameState = <S,>(\n  key: `${MessageKey}`,\n  initialState?: S | (() => S),\n  options?: CrossFrameStateOptions\n): [S, Dispatch<SetStateAction<S>>, () => void] => {\n  const manager = useEditorStateManager();\n\n  const resolvedInitial =\n    typeof initialState === 'function'\n      ? (initialState as () => S)()\n      : initialState;\n\n  const [value, setValueState] = useState<S>(resolvedInitial as S);\n  const valueRef = useRef<S>(resolvedInitial as S);\n\n  const stateManagerRef = useRef<CrossFrameStateManager<S> | null>(null);\n\n  useEffect(() => {\n    const { emit = true, receive = true } = options ?? {};\n    const stateManager = new CrossFrameStateManager<S>(\n      key,\n      manager?.messenger,\n      {\n        emit,\n        receive,\n        initialValue: resolvedInitial,\n      }\n    );\n    stateManagerRef.current = stateManager;\n\n    const handler = (e: Event) => {\n      const newValue = (e as CustomEvent<S>).detail;\n      valueRef.current = newValue;\n      setValueState(newValue);\n    };\n    stateManager.addEventListener('change', handler);\n    stateManager.start();\n\n    return () => {\n      stateManager.removeEventListener('change', handler);\n      stateManager.stop();\n      stateManagerRef.current = null;\n    };\n  }, [key, manager?.messenger, options?.emit, options?.receive]);\n\n  const setValue: Dispatch<SetStateAction<S>> = (valueOrUpdater) => {\n    setValueState((prev) => {\n      const newValue =\n        typeof valueOrUpdater === 'function'\n          ? (valueOrUpdater as (prev: S) => S)(prev)\n          : valueOrUpdater;\n      valueRef.current = newValue;\n      stateManagerRef.current?.set(newValue);\n      return newValue;\n    });\n  };\n\n  const postState = () => {\n    stateManagerRef.current?.postCurrentValue();\n  };\n\n  return [value, setValue, postState];\n};\n"],"mappings":"oMAqBA,MAAa,GACX,EACA,EACA,IACiD,CACjD,IAAM,EAAU,GAAuB,CAEjC,EACJ,OAAO,GAAiB,WACnB,GAA0B,CAC3B,EAEA,CAAC,EAAO,GAAiB,EAAY,EAAqB,CAC1D,EAAW,EAAU,EAAqB,CAE1C,EAAkB,EAAyC,KAAK,CA8CtE,OA5CA,MAAgB,CACd,GAAM,CAAE,OAAO,GAAM,UAAU,IAAS,GAAW,EAAE,CAC/C,EAAe,IAAI,EACvB,EACA,GAAS,UACT,CACE,OACA,UACA,aAAc,EACf,CACF,CACD,EAAgB,QAAU,EAE1B,IAAM,EAAW,GAAa,CAC5B,IAAM,EAAY,EAAqB,OACvC,EAAS,QAAU,EACnB,EAAc,EAAS,EAKzB,OAHA,EAAa,iBAAiB,SAAU,EAAQ,CAChD,EAAa,OAAO,KAEP,CACX,EAAa,oBAAoB,SAAU,EAAQ,CACnD,EAAa,MAAM,CACnB,EAAgB,QAAU,OAE3B,CAAC,EAAK,GAAS,UAAW,GAAS,KAAM,GAAS,QAAQ,CAAC,CAkBvD,CAAC,EAhBuC,GAAmB,CAChE,EAAe,GAAS,CACtB,IAAM,EACJ,OAAO,GAAmB,WACrB,EAAkC,EAAK,CACxC,EAGN,MAFA,GAAS,QAAU,EACnB,EAAgB,SAAS,IAAI,EAAS,CAC/B,GACP,MAGoB,CACtB,EAAgB,SAAS,kBAAkB,EAGV"}
+{"version":3,"file":"useCrossFrameState.mjs","names":[],"sources":["../../src/useCrossFrameState.tsx"],"sourcesContent":["'use client';\n\nimport type { MessageKey } from '@intlayer/editor';\nimport { CrossFrameStateManager } from '@intlayer/editor';\nimport {\n  type Dispatch,\n  type SetStateAction,\n  useEffect,\n  useRef,\n  useState,\n} from 'react';\nimport { useEditorStateManager } from './EditorStateContext';\n\nexport type CrossFrameStateOptions = {\n  emit?: boolean;\n  receive?: boolean;\n};\n\n/**\n * Synchronizes a React state value across frames using CrossFrameStateManager.\n */\nexport const useCrossFrameState = <S,>(\n  key: `${MessageKey}`,\n  initialState?: S | (() => S),\n  options?: CrossFrameStateOptions\n): [S, Dispatch<SetStateAction<S>>, () => void] => {\n  const manager = useEditorStateManager();\n\n  const resolvedInitial =\n    typeof initialState === 'function'\n      ? (initialState as () => S)()\n      : initialState;\n\n  const [value, setValueState] = useState<S>(resolvedInitial as S);\n  const valueRef = useRef<S>(resolvedInitial as S);\n\n  const stateManagerRef = useRef<CrossFrameStateManager<S> | null>(null);\n\n  useEffect(() => {\n    const { emit = true, receive = true } = options ?? {};\n    const stateManager = new CrossFrameStateManager<S>(\n      key,\n      manager?.messenger,\n      {\n        emit,\n        receive,\n        initialValue: resolvedInitial,\n      }\n    );\n    stateManagerRef.current = stateManager;\n\n    const handler = (e: Event) => {\n      const newValue = (e as CustomEvent<S>).detail;\n      valueRef.current = newValue;\n      setValueState(newValue);\n    };\n    stateManager.addEventListener('change', handler);\n    stateManager.start();\n\n    return () => {\n      stateManager.removeEventListener('change', handler);\n      stateManager.stop();\n      stateManagerRef.current = null;\n    };\n  }, [key, manager?.messenger, options?.emit, options?.receive]);\n\n  const setValue: Dispatch<SetStateAction<S>> = (valueOrUpdater) => {\n    setValueState((prev) => {\n      const newValue =\n        typeof valueOrUpdater === 'function'\n          ? (valueOrUpdater as (prev: S) => S)(prev)\n          : valueOrUpdater;\n      valueRef.current = newValue;\n      stateManagerRef.current?.set(newValue);\n      return newValue;\n    });\n  };\n\n  const postState = () => {\n    stateManagerRef.current?.postCurrentValue();\n  };\n\n  return [value, setValue, postState];\n};\n"],"mappings":";;;;;;;;;;AAqBA,MAAa,sBACX,KACA,cACA,YACiD;CACjD,MAAM,UAAU,uBAAuB;CAEvC,MAAM,kBACJ,OAAO,iBAAiB,aACnB,cAA0B,GAC3B;CAEN,MAAM,CAAC,OAAO,iBAAiB,SAAY,gBAAqB;CAChE,MAAM,WAAW,OAAU,gBAAqB;CAEhD,MAAM,kBAAkB,OAAyC,KAAK;AAEtE,iBAAgB;EACd,MAAM,EAAE,OAAO,MAAM,UAAU,SAAS,WAAW,EAAE;EACrD,MAAM,eAAe,IAAI,uBACvB,KACA,SAAS,WACT;GACE;GACA;GACA,cAAc;GACf,CACF;AACD,kBAAgB,UAAU;EAE1B,MAAM,WAAW,MAAa;GAC5B,MAAM,WAAY,EAAqB;AACvC,YAAS,UAAU;AACnB,iBAAc,SAAS;;AAEzB,eAAa,iBAAiB,UAAU,QAAQ;AAChD,eAAa,OAAO;AAEpB,eAAa;AACX,gBAAa,oBAAoB,UAAU,QAAQ;AACnD,gBAAa,MAAM;AACnB,mBAAgB,UAAU;;IAE3B;EAAC;EAAK,SAAS;EAAW,SAAS;EAAM,SAAS;EAAQ,CAAC;CAE9D,MAAM,YAAyC,mBAAmB;AAChE,iBAAe,SAAS;GACtB,MAAM,WACJ,OAAO,mBAAmB,aACrB,eAAkC,KAAK,GACxC;AACN,YAAS,UAAU;AACnB,mBAAgB,SAAS,IAAI,SAAS;AACtC,UAAO;IACP;;CAGJ,MAAM,kBAAkB;AACtB,kBAAgB,SAAS,kBAAkB;;AAG7C,QAAO;EAAC;EAAO;EAAU;EAAU"}

package/dist/esm/useCrossURLPathState.mjs

@@ -1,2 +1,17 @@
-"use client";import{useCrossFrameState as e}from"./useCrossFrameState.mjs";import{MessageKey as t}from"@intlayer/editor";const n=(n,r)=>e(t.INTLAYER_URL_CHANGE,n,r),r=e=>n(e,{emit:!0,receive:!1});export{r as useCrossURLPathSetter,n as useCrossURLPathState};
+'use client';
+
+import { useCrossFrameState } from "./useCrossFrameState.mjs";
+import { MessageKey } from "@intlayer/editor";
+
+//#region src/useCrossURLPathState.tsx
+const useCrossURLPathState = (initialState, options) => useCrossFrameState(MessageKey.INTLAYER_URL_CHANGE, initialState, options);
+const useCrossURLPathSetter = (initialState) => {
+	return useCrossURLPathState(initialState, {
+		emit: true,
+		receive: false
+	});
+};
+
+//#endregion
+export { useCrossURLPathSetter, useCrossURLPathState };
 //# sourceMappingURL=useCrossURLPathState.mjs.map

package/dist/esm/useCrossURLPathState.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"useCrossURLPathState.mjs","names":[],"sources":["../../src/useCrossURLPathState.tsx"],"sourcesContent":["'use client';\n\nimport { MessageKey } from '@intlayer/editor';\nimport {\n  type CrossFrameStateOptions,\n  useCrossFrameState,\n} from './useCrossFrameState';\n\nexport const useCrossURLPathState = (\n  initialState?: string,\n  options?: CrossFrameStateOptions\n) => useCrossFrameState(MessageKey.INTLAYER_URL_CHANGE, initialState, options);\n\nexport const useCrossURLPathSetter = (initialState?: string) => {\n  // The EditorStateManager already handles URL tracking in client mode via\n  // UrlStateManager.start(). This hook remains for explicit use cases.\n  return useCrossURLPathState(initialState, { emit: true, receive: false });\n};\n"],"mappings":"yHAQA,MAAa,GACX,EACA,IACG,EAAmB,EAAW,oBAAqB,EAAc,EAAQ,CAEjE,EAAyB,GAG7B,EAAqB,EAAc,CAAE,KAAM,GAAM,QAAS,GAAO,CAAC"}
+{"version":3,"file":"useCrossURLPathState.mjs","names":[],"sources":["../../src/useCrossURLPathState.tsx"],"sourcesContent":["'use client';\n\nimport { MessageKey } from '@intlayer/editor';\nimport {\n  type CrossFrameStateOptions,\n  useCrossFrameState,\n} from './useCrossFrameState';\n\nexport const useCrossURLPathState = (\n  initialState?: string,\n  options?: CrossFrameStateOptions\n) => useCrossFrameState(MessageKey.INTLAYER_URL_CHANGE, initialState, options);\n\nexport const useCrossURLPathSetter = (initialState?: string) => {\n  // The EditorStateManager already handles URL tracking in client mode via\n  // UrlStateManager.start(). This hook remains for explicit use cases.\n  return useCrossURLPathState(initialState, { emit: true, receive: false });\n};\n"],"mappings":";;;;;;AAQA,MAAa,wBACX,cACA,YACG,mBAAmB,WAAW,qBAAqB,cAAc,QAAQ;AAE9E,MAAa,yBAAyB,iBAA0B;AAG9D,QAAO,qBAAqB,cAAc;EAAE,MAAM;EAAM,SAAS;EAAO,CAAC"}

package/dist/esm/useEditorLocale.mjs

@@ -1,2 +1,25 @@
-"use client";import{useEditorStateManager as e}from"./EditorStateContext.mjs";import{useEffect as t,useState as n}from"react";const r=()=>{let r=e(),[i,a]=n(r?.currentLocale.value);return t(()=>{if(!r)return;let e=e=>a(e.detail);return r.currentLocale.addEventListener(`change`,e),()=>r.currentLocale.removeEventListener(`change`,e)},[r]),i},i=()=>{let t=e();return e=>t?.currentLocale.set(e)};export{r as useEditorLocale,i as useSetEditorLocale};
+'use client';
+
+import { useEditorStateManager } from "./EditorStateContext.mjs";
+import { useEffect, useState } from "react";
+
+//#region src/useEditorLocale.tsx
+const useEditorLocale = () => {
+	const manager = useEditorStateManager();
+	const [locale, setLocale] = useState(manager?.currentLocale.value);
+	useEffect(() => {
+		if (!manager) return;
+		const handler = (e) => setLocale(e.detail);
+		manager.currentLocale.addEventListener("change", handler);
+		return () => manager.currentLocale.removeEventListener("change", handler);
+	}, [manager]);
+	return locale;
+};
+const useSetEditorLocale = () => {
+	const manager = useEditorStateManager();
+	return (locale) => manager?.currentLocale.set(locale);
+};
+
+//#endregion
+export { useEditorLocale, useSetEditorLocale };
 //# sourceMappingURL=useEditorLocale.mjs.map

package/dist/esm/useEditorLocale.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"useEditorLocale.mjs","names":[],"sources":["../../src/useEditorLocale.tsx"],"sourcesContent":["'use client';\n\nimport type { Locale } from '@intlayer/types/allLocales';\nimport { useEffect, useState } from 'react';\nimport { useEditorStateManager } from './EditorStateContext';\n\nexport const useEditorLocale = (): Locale | undefined => {\n  const manager = useEditorStateManager();\n  const [locale, setLocale] = useState<Locale | undefined>(\n    manager?.currentLocale.value\n  );\n\n  useEffect(() => {\n    if (!manager) return;\n\n    const handler = (e: Event) => setLocale((e as CustomEvent<Locale>).detail);\n    manager.currentLocale.addEventListener('change', handler);\n\n    return () => manager.currentLocale.removeEventListener('change', handler);\n  }, [manager]);\n\n  return locale;\n};\n\nexport const useSetEditorLocale = () => {\n  const manager = useEditorStateManager();\n  return (locale: Locale) => manager?.currentLocale.set(locale);\n};\n"],"mappings":"8HAMA,MAAa,MAA4C,CACvD,IAAM,EAAU,GAAuB,CACjC,CAAC,EAAQ,GAAa,EAC1B,GAAS,cAAc,MACxB,CAWD,OATA,MAAgB,CACd,GAAI,CAAC,EAAS,OAEd,IAAM,EAAW,GAAa,EAAW,EAA0B,OAAO,CAG1E,OAFA,EAAQ,cAAc,iBAAiB,SAAU,EAAQ,KAE5C,EAAQ,cAAc,oBAAoB,SAAU,EAAQ,EACxE,CAAC,EAAQ,CAAC,CAEN,GAGI,MAA2B,CACtC,IAAM,EAAU,GAAuB,CACvC,MAAQ,IAAmB,GAAS,cAAc,IAAI,EAAO"}
+{"version":3,"file":"useEditorLocale.mjs","names":[],"sources":["../../src/useEditorLocale.tsx"],"sourcesContent":["'use client';\n\nimport type { Locale } from '@intlayer/types/allLocales';\nimport { useEffect, useState } from 'react';\nimport { useEditorStateManager } from './EditorStateContext';\n\nexport const useEditorLocale = (): Locale | undefined => {\n  const manager = useEditorStateManager();\n  const [locale, setLocale] = useState<Locale | undefined>(\n    manager?.currentLocale.value\n  );\n\n  useEffect(() => {\n    if (!manager) return;\n\n    const handler = (e: Event) => setLocale((e as CustomEvent<Locale>).detail);\n    manager.currentLocale.addEventListener('change', handler);\n\n    return () => manager.currentLocale.removeEventListener('change', handler);\n  }, [manager]);\n\n  return locale;\n};\n\nexport const useSetEditorLocale = () => {\n  const manager = useEditorStateManager();\n  return (locale: Locale) => manager?.currentLocale.set(locale);\n};\n"],"mappings":";;;;;;AAMA,MAAa,wBAA4C;CACvD,MAAM,UAAU,uBAAuB;CACvC,MAAM,CAAC,QAAQ,aAAa,SAC1B,SAAS,cAAc,MACxB;AAED,iBAAgB;AACd,MAAI,CAAC,QAAS;EAEd,MAAM,WAAW,MAAa,UAAW,EAA0B,OAAO;AAC1E,UAAQ,cAAc,iBAAiB,UAAU,QAAQ;AAEzD,eAAa,QAAQ,cAAc,oBAAoB,UAAU,QAAQ;IACxE,CAAC,QAAQ,CAAC;AAEb,QAAO;;AAGT,MAAa,2BAA2B;CACtC,MAAM,UAAU,uBAAuB;AACvC,SAAQ,WAAmB,SAAS,cAAc,IAAI,OAAO"}

package/dist/esm/useFocusUnmergedDictionary.mjs

@@ -1,2 +1,50 @@
-"use client";import{useFocusDictionary as e}from"./FocusDictionaryContext.mjs";import{useDictionariesRecord as t}from"./DictionariesRecordContext.mjs";import{useEditorLocale as n}from"./useEditorLocale.mjs";import{useMemo as r}from"react";import{getContentNodeByKeyPath as i}from"@intlayer/core/dictionaryManipulator";const a=(e,t,n)=>{for(let r of t)try{if(i(r.content,e??[],n))return{keyPath:e,dictionaryLocalId:r.localId}}catch{}},o=()=>{let{localeDictionaries:i}=t(),o=n(),{setFocusedContent:s,setFocusedContentKeyPath:c,focusedContent:l}=e();return{focusedContent:r(()=>{if(!l||!i||l.dictionaryLocalId)return l;let e=Object.values(i).filter(e=>e.key===l.dictionaryKey),t=a(l.keyPath??[],e,o);return{...l,...t}},[l,i,o]),setFocusedContent:s,setFocusedContentKeyPath:c}};export{o as useFocusUnmergedDictionary};
+'use client';
+
+import { useFocusDictionary } from "./FocusDictionaryContext.mjs";
+import { useDictionariesRecord } from "./DictionariesRecordContext.mjs";
+import { useEditorLocale } from "./useEditorLocale.mjs";
+import { useMemo } from "react";
+import { getContentNodeByKeyPath } from "@intlayer/core/dictionaryManipulator";
+
+//#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) => {
+	for (const dictionary of dictionaries) try {
+		if (getContentNodeByKeyPath(dictionary.content, keyPath ?? [], locale)) return {
+			keyPath,
+			dictionaryLocalId: dictionary.localId
+		};
+	} catch {}
+};
+const useFocusUnmergedDictionary = () => {
+	const { localeDictionaries } = useDictionariesRecord();
+	const currentLocale = useEditorLocale();
+	const { setFocusedContent, setFocusedContentKeyPath, focusedContent: mergedFocusedContent } = useFocusDictionary();
+	return {
+		focusedContent: 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
+export { useFocusUnmergedDictionary };
 //# sourceMappingURL=useFocusUnmergedDictionary.mjs.map

package/dist/esm/useFocusUnmergedDictionary.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"useFocusUnmergedDictionary.mjs","names":[],"sources":["../../src/useFocusUnmergedDictionary.tsx"],"sourcesContent":["'use client';\n\nimport { getContentNodeByKeyPath } from '@intlayer/core/dictionaryManipulator';\nimport type { Locale } from '@intlayer/types/allLocales';\nimport type { Dictionary, LocalDictionaryId } from '@intlayer/types/dictionary';\nimport type { KeyPath } from '@intlayer/types/keyPath';\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  // 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    try {\n      const result = getContentNodeByKeyPath(\n        dictionary.content,\n        keyPath ?? [],\n        locale\n      );\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":"8TAqBA,MAAM,GACJ,EACA,EACA,IACgC,CAIhC,IAAK,IAAM,KAAc,EACvB,GAAI,CAOF,GANe,EACb,EAAW,QACX,GAAW,EAAE,CACb,EACD,CAGC,MAAO,CAAE,UAAS,kBAAmB,EAAW,QAAS,MAErD,IAMC,MAAmC,CAC9C,GAAM,CAAE,sBAAuB,GAAuB,CAChD,EAAgB,GAAiB,CACjC,CACJ,oBACA,2BACA,eAAgB,GACd,GAAoB,CAuBxB,MAAO,CACL,eAtBqB,MAAkC,CAGvD,GAFI,CAAC,GACD,CAAC,GACD,EAAqB,kBAAmB,OAAO,EAEnD,IAAM,EAAe,OAAO,OAAO,EAAmB,CAAC,OACpD,GAAe,EAAW,MAAQ,EAAqB,cACzD,CAEK,EAAkB,EACtB,EAAqB,SAAW,EAAE,CAClC,EACA,EACD,CAED,MAAO,CACL,GAAG,EACH,GAAG,EACJ,EACA,CAAC,EAAsB,EAAoB,EAAc,CAAC,CAI3D,oBACA,2BACD"}
+{"version":3,"file":"useFocusUnmergedDictionary.mjs","names":[],"sources":["../../src/useFocusUnmergedDictionary.tsx"],"sourcesContent":["'use client';\n\nimport { getContentNodeByKeyPath } from '@intlayer/core/dictionaryManipulator';\nimport type { Locale } from '@intlayer/types/allLocales';\nimport type { Dictionary, LocalDictionaryId } from '@intlayer/types/dictionary';\nimport type { KeyPath } from '@intlayer/types/keyPath';\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  // 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    try {\n      const result = getContentNodeByKeyPath(\n        dictionary.content,\n        keyPath ?? [],\n        locale\n      );\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":";;;;;;;;;;;;;;AAqBA,MAAM,kCACJ,SACA,cACA,WACgC;AAIhC,MAAK,MAAM,cAAc,aACvB,KAAI;AAOF,MANe,wBACb,WAAW,SACX,WAAW,EAAE,EACb,OACD,CAGC,QAAO;GAAE;GAAS,mBAAmB,WAAW;GAAS;SAErD;;AAMZ,MAAa,mCAAmC;CAC9C,MAAM,EAAE,uBAAuB,uBAAuB;CACtD,MAAM,gBAAgB,iBAAiB;CACvC,MAAM,EACJ,mBACA,0BACA,gBAAgB,yBACd,oBAAoB;AAuBxB,QAAO;EACL,gBAtBqB,cAAkC;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/useIframeClickInterceptor.mjs

@@ -1,2 +1,26 @@
-"use client";import{useCrossFrameMessageListener as e}from"./useCrossFrameMessageListener.mjs";import{MessageKey as t,mergeIframeClick as n}from"@intlayer/editor";const r=()=>{e(t.INTLAYER_IFRAME_CLICKED)},i=()=>{e(t.INTLAYER_IFRAME_CLICKED,n)};export{r as useIframeClickInterceptor,i as useIframeClickMerger};
+'use client';
+
+import { useCrossFrameMessageListener } from "./useCrossFrameMessageListener.mjs";
+import { MessageKey, mergeIframeClick } from "@intlayer/editor";
+
+//#region src/useIframeClickInterceptor.tsx
+/**
+* Broadcasts mousedown events from within an iframe to the parent frame.
+* Called in the client application (inside the iframe).
+* Note: EditorStateManager.start() already sets this up in client mode.
+* This hook exists for explicit / standalone use cases.
+*/
+const useIframeClickInterceptor = () => {
+	useCrossFrameMessageListener(MessageKey.INTLAYER_IFRAME_CLICKED);
+};
+/**
+* Merges received iframe click events into the parent's DOM event stream.
+* Called in the editor (parent frame).
+*/
+const useIframeClickMerger = () => {
+	useCrossFrameMessageListener(MessageKey.INTLAYER_IFRAME_CLICKED, mergeIframeClick);
+};
+
+//#endregion
+export { useIframeClickInterceptor, useIframeClickMerger };
 //# sourceMappingURL=useIframeClickInterceptor.mjs.map

package/dist/esm/useIframeClickInterceptor.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"useIframeClickInterceptor.mjs","names":[],"sources":["../../src/useIframeClickInterceptor.tsx"],"sourcesContent":["'use client';\n\nimport { MessageKey, mergeIframeClick } from '@intlayer/editor';\nimport { useCrossFrameMessageListener } from './useCrossFrameMessageListener';\n\n/**\n * Broadcasts mousedown events from within an iframe to the parent frame.\n * Called in the client application (inside the iframe).\n * Note: EditorStateManager.start() already sets this up in client mode.\n * This hook exists for explicit / standalone use cases.\n */\nexport const useIframeClickInterceptor = () => {\n  useCrossFrameMessageListener<undefined>(MessageKey.INTLAYER_IFRAME_CLICKED);\n};\n\n/**\n * Merges received iframe click events into the parent's DOM event stream.\n * Called in the editor (parent frame).\n */\nexport const useIframeClickMerger = () => {\n  useCrossFrameMessageListener<MessageEvent>(\n    MessageKey.INTLAYER_IFRAME_CLICKED,\n    mergeIframeClick\n  );\n};\n"],"mappings":"mKAWA,MAAa,MAAkC,CAC7C,EAAwC,EAAW,wBAAwB,EAOhE,MAA6B,CACxC,EACE,EAAW,wBACX,EACD"}
+{"version":3,"file":"useIframeClickInterceptor.mjs","names":[],"sources":["../../src/useIframeClickInterceptor.tsx"],"sourcesContent":["'use client';\n\nimport { MessageKey, mergeIframeClick } from '@intlayer/editor';\nimport { useCrossFrameMessageListener } from './useCrossFrameMessageListener';\n\n/**\n * Broadcasts mousedown events from within an iframe to the parent frame.\n * Called in the client application (inside the iframe).\n * Note: EditorStateManager.start() already sets this up in client mode.\n * This hook exists for explicit / standalone use cases.\n */\nexport const useIframeClickInterceptor = () => {\n  useCrossFrameMessageListener<undefined>(MessageKey.INTLAYER_IFRAME_CLICKED);\n};\n\n/**\n * Merges received iframe click events into the parent's DOM event stream.\n * Called in the editor (parent frame).\n */\nexport const useIframeClickMerger = () => {\n  useCrossFrameMessageListener<MessageEvent>(\n    MessageKey.INTLAYER_IFRAME_CLICKED,\n    mergeIframeClick\n  );\n};\n"],"mappings":";;;;;;;;;;;;AAWA,MAAa,kCAAkC;AAC7C,8BAAwC,WAAW,wBAAwB;;;;;;AAO7E,MAAa,6BAA6B;AACxC,8BACE,WAAW,yBACX,iBACD"}

package/dist/types/FocusDictionaryContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FocusDictionaryContext.d.ts","names":[],"sources":["../../src/FocusDictionaryContext.tsx"],"mappings":";;;;KASY,oBAAA;EACV,cAAA,EAAgB,aAAA;AAAA;AAAA,KAGN,sBAAA;EACV,iBAAA,GAAoB,KAAA,EAAO,aAAA;EAC3B,wBAAA,GAA2B,OAAA,EAAS,OAAA;AAAA;;;;cAMzB,kBAAA,QAAyB,oBAAA,GACpC,sBAAA;AAAA,cAuBW,yBAAA,QAAgC,sBAAA"}
+{"version":3,"file":"FocusDictionaryContext.d.ts","names":[],"sources":["../../src/FocusDictionaryContext.tsx"],"mappings":";;;;KASY,oBAAA;EACV,cAAA,EAAgB,aAAA;AAAA;AAAA,KAGN,sBAAA;EACV,iBAAA,GAAoB,KAAA,EAAO,aAAA;EAC3B,wBAAA,GAA2B,OAAA,EAAS,OAAA;AAAA;;;;cAMzB,kBAAA,QAAyB,oBAAA,GACpC,sBAAA;AAAA,cAwBW,yBAAA,QAAgC,sBAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intlayer/editor-react",
-  "version": "8.4.4",
+  "version": "8.4.6",
   "private": false,
   "description": "Provides the states, contexts, hooks and components to interact with the Intlayer editor for a React application",
   "keywords": [
@@ -70,11 +70,11 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/config": "8.4.4",
-    "@intlayer/core": "8.4.4",
-    "@intlayer/editor": "8.4.4",
-    "@intlayer/types": "8.4.4",
-    "@intlayer/unmerged-dictionaries-entry": "8.4.4"
+    "@intlayer/config": "8.4.6",
+    "@intlayer/core": "8.4.6",
+    "@intlayer/editor": "8.4.6",
+    "@intlayer/types": "8.4.6",
+    "@intlayer/unmerged-dictionaries-entry": "8.4.6"
   },
   "devDependencies": {
     "@types/node": "25.5.0",