@intlayer/editor-react 9.5.11 → 9.6.0

package/dist/esm/ConfigurationContext.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"ConfigurationContext.mjs","names":[],"sources":["../../src/ConfigurationContext.tsx"],"sourcesContent":["'use client';\n\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport {\n  createContext,\n  type FC,\n  type PropsWithChildren,\n  useContext,\n  useEffect,\n  useState,\n} from 'react';\nimport { useEditorStateManager } from './EditorStateContext';\n\n// 1. Create a native React context\nconst ConfigurationReactContext = createContext<IntlayerConfig | undefined>(\n  undefined\n);\n\nexport type ConfigurationProviderProps = PropsWithChildren<{\n  configuration?: IntlayerConfig;\n}>;\n\nexport const ConfigurationProvider: FC<ConfigurationProviderProps> = ({\n  configuration,\n  children,\n}) => {\n  const manager = useEditorStateManager();\n\n  useEffect(() => {\n    if (!manager || !configuration) return;\n\n    manager.configuration.set(configuration);\n  }, [manager, configuration]);\n\n  // 2. Wrap children in the native provider\n  return (\n    <ConfigurationReactContext.Provider value={configuration}>\n      {children}\n    </ConfigurationReactContext.Provider>\n  );\n};\n\nexport const useConfiguration = (): IntlayerConfig | undefined => {\n  const manager = useEditorStateManager();\n  const reactConfig = useContext(ConfigurationReactContext); // 3. Consume native context\n\n  const [config, setConfig] = useState<IntlayerConfig | undefined>(\n    (manager?.configuration.value as IntlayerConfig | undefined) ?? reactConfig\n  );\n\n  useEffect(() => {\n    if (!manager) {\n      setConfig(reactConfig);\n      return;\n    }\n\n    const handler = (e: Event) => {\n      const detail = (e as CustomEvent<IntlayerConfig>).detail;\n      setConfig(detail ?? reactConfig);\n    };\n\n    manager.configuration.addEventListener('change', handler);\n    return () => manager.configuration.removeEventListener('change', handler);\n  }, [manager, reactConfig]);\n\n  // Prefer event-driven config, fallback to React context config\n  return config ?? reactConfig;\n};\n\nexport const useConfigurationState = () => {\n  const manager = useEditorStateManager();\n  const reactConfig = useContext(ConfigurationReactContext);\n\n  const [config, setConfig] = useState<IntlayerConfig | undefined>(\n    (manager?.configuration.value as IntlayerConfig | undefined) ?? reactConfig\n  );\n\n  return [\n    config ?? reactConfig,\n    setConfig,\n    () => manager?.configuration.postCurrentValue(),\n  ] as const;\n};\n"],"mappings":";;;;;;;AAcA,MAAM,4BAA4B,cAChC,MACF;AAMA,MAAa,yBAAyD,EACpE,eACA,eACI;CACJ,MAAM,UAAU,sBAAsB;CAEtC,gBAAgB;EACd,IAAI,CAAC,WAAW,CAAC,eAAe;EAEhC,QAAQ,cAAc,IAAI,aAAa;CACzC,GAAG,CAAC,SAAS,aAAa,CAAC;CAG3B,OACE,oBAAC,0BAA0B,UAA3B;EAAoC,OAAO;EACxC;CACiC;AAExC;AAEA,MAAa,yBAAqD;CAChE,MAAM,UAAU,sBAAsB;CACtC,MAAM,cAAc,WAAW,yBAAyB;CAExD,MAAM,CAAC,QAAQ,aAAa,SACzB,SAAS,cAAc,SAAwC,WAClE;CAEA,gBAAgB;EACd,IAAI,CAAC,SAAS;GACZ,UAAU,WAAW;GACrB;EACF;EAEA,MAAM,WAAW,MAAa;GAC5B,MAAM,SAAU,EAAkC;GAClD,UAAU,UAAU,WAAW;EACjC;EAEA,QAAQ,cAAc,iBAAiB,UAAU,OAAO;EACxD,aAAa,QAAQ,cAAc,oBAAoB,UAAU,OAAO;CAC1E,GAAG,CAAC,SAAS,WAAW,CAAC;CAGzB,OAAO,UAAU;AACnB;AAEA,MAAa,8BAA8B;CACzC,MAAM,UAAU,sBAAsB;CACtC,MAAM,cAAc,WAAW,yBAAyB;CAExD,MAAM,CAAC,QAAQ,aAAa,SACzB,SAAS,cAAc,SAAwC,WAClE;CAEA,OAAO;EACL,UAAU;EACV;QACM,SAAS,cAAc,iBAAiB;CAChD;AACF"}
+{"version":3,"file":"ConfigurationContext.mjs","names":[],"sources":["../../src/ConfigurationContext.tsx"],"sourcesContent":["'use client';\n\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport { useEffect, useState } from 'react';\nimport { useEditorStateManager } from './EditorStateContext';\n\n/**\n * Returns the Intlayer configuration held by the editor state manager.\n */\nexport const useConfiguration = (): IntlayerConfig | undefined => {\n  const manager = useEditorStateManager();\n  const [configuration, setConfiguration] = useState<\n    IntlayerConfig | undefined\n  >(manager?.configuration.value as IntlayerConfig | undefined);\n\n  useEffect(() => {\n    if (!manager) return;\n\n    const handleChange = (event: Event) =>\n      setConfiguration((event as CustomEvent<IntlayerConfig>).detail);\n\n    manager.configuration.addEventListener('change', handleChange);\n\n    return () =>\n      manager.configuration.removeEventListener('change', handleChange);\n  }, [manager]);\n\n  return configuration;\n};\n"],"mappings":";;;;;;;;;AASA,MAAa,yBAAqD;CAChE,MAAM,UAAU,sBAAsB;CACtC,MAAM,CAAC,eAAe,oBAAoB,SAExC,SAAS,cAAc,KAAmC;CAE5D,gBAAgB;EACd,IAAI,CAAC,SAAS;EAEd,MAAM,gBAAgB,UACpB,iBAAkB,MAAsC,MAAM;EAEhE,QAAQ,cAAc,iBAAiB,UAAU,YAAY;EAE7D,aACE,QAAQ,cAAc,oBAAoB,UAAU,YAAY;CACpE,GAAG,CAAC,OAAO,CAAC;CAEZ,OAAO;AACT"}

package/dist/esm/EditedContentContext.mjs

@@ -14,8 +14,6 @@ const useEditedContentActions = () => {
 		renameEditedContent: (localId, newKey, keyPath) => manager?.renameContent(localId, newKey, keyPath),
 		removeEditedContent: (localId, keyPath) => manager?.removeContent(localId, keyPath),
 		restoreEditedContent: (localId) => manager?.restoreContent(localId),
-		clearEditedDictionaryContent: (localId) => manager?.clearContent(localId),
-		clearEditedContent: () => manager?.clearAllContent(),
 		getEditedContentValue: (localIdOrKey, keyPath) => manager?.getContentValue(localIdOrKey, keyPath)
 	};
 };
@@ -33,20 +31,7 @@ const useEditedContent = () => {
 		...useEditedContentActions()
 	};
 };
-const usePostEditedContentState = (onEventTriggered) => {
-	const manager = useEditorStateManager();
-	useEffect(() => {
-		if (!onEventTriggered || !manager) return;
-		return manager.messenger.subscribe(`INTLAYER_EDITED_CONTENT_CHANGED/post`, onEventTriggered);
-	}, [manager, onEventTriggered]);
-};
-const useGetEditedContentState = () => {
-	const manager = useEditorStateManager();
-	return () => {
-		manager?.messenger.send("INTLAYER_EDITED_CONTENT_CHANGED/get");
-	};
-};
 
 //#endregion
-export { useEditedContent, useEditedContentActions, useGetEditedContentState, usePostEditedContentState };
+export { useEditedContent, useEditedContentActions };
 //# sourceMappingURL=EditedContentContext.mjs.map

package/dist/esm/EditedContentContext.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"EditedContentContext.mjs","names":[],"sources":["../../src/EditedContentContext.tsx"],"sourcesContent":["'use client';\n\nimport type { DictionaryContent } from '@intlayer/editor';\nimport type {\n  ContentNode,\n  Dictionary,\n  LocalDictionaryId,\n} from '@intlayer/types/dictionary';\nimport type { KeyPath } from '@intlayer/types/keyPath';\nimport { useEffect, useState } from 'react';\nimport { useEditorStateManager } from './EditorStateContext';\n\nexport type { DictionaryContent } from '@intlayer/editor';\n\ntype EditedContentActionsContextType = {\n  setEditedContentState: (editedContent: DictionaryContent) => void;\n  setEditedDictionary: (dict: Dictionary) => void;\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\nexport const useEditedContentActions = (): EditedContentActionsContextType => {\n  const manager = useEditorStateManager();\n\n  return {\n    setEditedContentState: (value: DictionaryContent) =>\n      manager?.editedContent.set(value),\n    setEditedDictionary: (dict: Dictionary) =>\n      manager?.setEditedDictionary(dict),\n    setEditedContent: (\n      localId: LocalDictionaryId,\n      value: Dictionary['content']\n    ) => manager?.setEditedContent(localId, value),\n    addEditedContent: (localId, value, keyPath, overwrite) =>\n      manager?.addContent(localId, value, keyPath, overwrite),\n    renameEditedContent: (localId, newKey, keyPath) =>\n      manager?.renameContent(localId, newKey, keyPath),\n    removeEditedContent: (localId, keyPath) =>\n      manager?.removeContent(localId, keyPath),\n    restoreEditedContent: (localId) => manager?.restoreContent(localId),\n    clearEditedDictionaryContent: (localId) => manager?.clearContent(localId),\n    clearEditedContent: () => manager?.clearAllContent(),\n    getEditedContentValue: (localIdOrKey, keyPath) =>\n      manager?.getContentValue(localIdOrKey, keyPath),\n  };\n};\n\nexport const useEditedContent = () => {\n  const manager = useEditorStateManager();\n  const [editedContent, setEditedContentState] = useState<\n    DictionaryContent | undefined\n  >(manager?.editedContent.value);\n\n  useEffect(() => {\n    if (!manager) return;\n    const handler = (e: Event) =>\n      setEditedContentState((e as CustomEvent<DictionaryContent>).detail);\n    manager.editedContent.addEventListener('change', handler);\n    return () => manager.editedContent.removeEventListener('change', handler);\n  }, [manager]);\n\n  const actions = useEditedContentActions();\n  return { editedContent, ...actions };\n};\n\nexport const usePostEditedContentState = <S,>(\n  onEventTriggered?: (data: S) => void\n) => {\n  const manager = useEditorStateManager();\n  useEffect(() => {\n    if (!onEventTriggered || !manager) return;\n    return manager.messenger.subscribe(\n      `INTLAYER_EDITED_CONTENT_CHANGED/post`,\n      onEventTriggered as (data: unknown) => void\n    );\n  }, [manager, onEventTriggered]);\n};\n\nexport const useGetEditedContentState = () => {\n  const manager = useEditorStateManager();\n  return () => {\n    manager?.messenger.send('INTLAYER_EDITED_CONTENT_CHANGED/get');\n  };\n};\n"],"mappings":";;;;;;AA6CA,MAAa,gCAAiE;CAC5E,MAAM,UAAU,sBAAsB;CAEtC,OAAO;EACL,wBAAwB,UACtB,SAAS,cAAc,IAAI,KAAK;EAClC,sBAAsB,SACpB,SAAS,oBAAoB,IAAI;EACnC,mBACE,SACA,UACG,SAAS,iBAAiB,SAAS,KAAK;EAC7C,mBAAmB,SAAS,OAAO,SAAS,cAC1C,SAAS,WAAW,SAAS,OAAO,SAAS,SAAS;EACxD,sBAAsB,SAAS,QAAQ,YACrC,SAAS,cAAc,SAAS,QAAQ,OAAO;EACjD,sBAAsB,SAAS,YAC7B,SAAS,cAAc,SAAS,OAAO;EACzC,uBAAuB,YAAY,SAAS,eAAe,OAAO;EAClE,+BAA+B,YAAY,SAAS,aAAa,OAAO;EACxE,0BAA0B,SAAS,gBAAgB;EACnD,wBAAwB,cAAc,YACpC,SAAS,gBAAgB,cAAc,OAAO;CAClD;AACF;AAEA,MAAa,yBAAyB;CACpC,MAAM,UAAU,sBAAsB;CACtC,MAAM,CAAC,eAAe,yBAAyB,SAE7C,SAAS,cAAc,KAAK;CAE9B,gBAAgB;EACd,IAAI,CAAC,SAAS;EACd,MAAM,WAAW,MACf,sBAAuB,EAAqC,MAAM;EACpE,QAAQ,cAAc,iBAAiB,UAAU,OAAO;EACxD,aAAa,QAAQ,cAAc,oBAAoB,UAAU,OAAO;CAC1E,GAAG,CAAC,OAAO,CAAC;CAGZ,OAAO;EAAE;EAAe,GADR,wBACiB;CAAE;AACrC;AAEA,MAAa,6BACX,qBACG;CACH,MAAM,UAAU,sBAAsB;CACtC,gBAAgB;EACd,IAAI,CAAC,oBAAoB,CAAC,SAAS;EACnC,OAAO,QAAQ,UAAU,UACvB,wCACA,gBACF;CACF,GAAG,CAAC,SAAS,gBAAgB,CAAC;AAChC;AAEA,MAAa,iCAAiC;CAC5C,MAAM,UAAU,sBAAsB;CACtC,aAAa;EACX,SAAS,UAAU,KAAK,qCAAqC;CAC/D;AACF"}
+{"version":3,"file":"EditedContentContext.mjs","names":[],"sources":["../../src/EditedContentContext.tsx"],"sourcesContent":["'use client';\n\nimport type { DictionaryContent } from '@intlayer/editor';\nimport type {\n  ContentNode,\n  Dictionary,\n  LocalDictionaryId,\n} from '@intlayer/types/dictionary';\nimport type { KeyPath } from '@intlayer/types/keyPath';\nimport { useEffect, useState } from 'react';\nimport { useEditorStateManager } from './EditorStateContext';\n\nexport type { DictionaryContent } from '@intlayer/editor';\n\ntype EditedContentActionsContextType = {\n  setEditedContentState: (editedContent: DictionaryContent) => void;\n  setEditedDictionary: (dict: Dictionary) => void;\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  getEditedContentValue: (\n    localDictionaryIdOrKey: LocalDictionaryId | Dictionary['key'] | string,\n    keyPath: KeyPath[]\n  ) => ContentNode | undefined;\n};\n\nexport const useEditedContentActions = (): EditedContentActionsContextType => {\n  const manager = useEditorStateManager();\n\n  return {\n    setEditedContentState: (value: DictionaryContent) =>\n      manager?.editedContent.set(value),\n    setEditedDictionary: (dict: Dictionary) =>\n      manager?.setEditedDictionary(dict),\n    setEditedContent: (\n      localId: LocalDictionaryId,\n      value: Dictionary['content']\n    ) => manager?.setEditedContent(localId, value),\n    addEditedContent: (localId, value, keyPath, overwrite) =>\n      manager?.addContent(localId, value, keyPath, overwrite),\n    renameEditedContent: (localId, newKey, keyPath) =>\n      manager?.renameContent(localId, newKey, keyPath),\n    removeEditedContent: (localId, keyPath) =>\n      manager?.removeContent(localId, keyPath),\n    restoreEditedContent: (localId) => manager?.restoreContent(localId),\n    getEditedContentValue: (localIdOrKey, keyPath) =>\n      manager?.getContentValue(localIdOrKey, keyPath),\n  };\n};\n\nexport const useEditedContent = () => {\n  const manager = useEditorStateManager();\n  const [editedContent, setEditedContentState] = useState<\n    DictionaryContent | undefined\n  >(manager?.editedContent.value);\n\n  useEffect(() => {\n    if (!manager) return;\n    const handler = (e: Event) =>\n      setEditedContentState((e as CustomEvent<DictionaryContent>).detail);\n    manager.editedContent.addEventListener('change', handler);\n    return () => manager.editedContent.removeEventListener('change', handler);\n  }, [manager]);\n\n  const actions = useEditedContentActions();\n  return { editedContent, ...actions };\n};\n"],"mappings":";;;;;;AA2CA,MAAa,gCAAiE;CAC5E,MAAM,UAAU,sBAAsB;CAEtC,OAAO;EACL,wBAAwB,UACtB,SAAS,cAAc,IAAI,KAAK;EAClC,sBAAsB,SACpB,SAAS,oBAAoB,IAAI;EACnC,mBACE,SACA,UACG,SAAS,iBAAiB,SAAS,KAAK;EAC7C,mBAAmB,SAAS,OAAO,SAAS,cAC1C,SAAS,WAAW,SAAS,OAAO,SAAS,SAAS;EACxD,sBAAsB,SAAS,QAAQ,YACrC,SAAS,cAAc,SAAS,QAAQ,OAAO;EACjD,sBAAsB,SAAS,YAC7B,SAAS,cAAc,SAAS,OAAO;EACzC,uBAAuB,YAAY,SAAS,eAAe,OAAO;EAClE,wBAAwB,cAAc,YACpC,SAAS,gBAAgB,cAAc,OAAO;CAClD;AACF;AAEA,MAAa,yBAAyB;CACpC,MAAM,UAAU,sBAAsB;CACtC,MAAM,CAAC,eAAe,yBAAyB,SAE7C,SAAS,cAAc,KAAK;CAE9B,gBAAgB;EACd,IAAI,CAAC,SAAS;EACd,MAAM,WAAW,MACf,sBAAuB,EAAqC,MAAM;EACpE,QAAQ,cAAc,iBAAiB,UAAU,OAAO;EACxD,aAAa,QAAQ,cAAc,oBAAoB,UAAU,OAAO;CAC1E,GAAG,CAAC,OAAO,CAAC;CAGZ,OAAO;EAAE;EAAe,GADR,wBACiB;CAAE;AACrC"}

package/dist/esm/EditorEnabledContext.mjs

@@ -2,7 +2,6 @@
 
 import { useEditorStateManager } from "./EditorStateContext.mjs";
 import { useEffect, useState } from "react";
-import { MessageKey } from "@intlayer/editor";
 
 //#region src/EditorEnabledContext.tsx
 /**
@@ -21,34 +20,6 @@ const useEditorEnabled = () => {
 	return { enabled };
 };
 /**
-* Subscribes to incoming "get" requests for editor-enabled state and calls
-* the provided callback so the caller can respond.
-* Used by the editor side to respond when the client asks for the current state.
-*/
-const useGetEditorEnabledState = (onRequest) => {
-	const manager = useEditorStateManager();
-	useEffect(() => {
-		if (!onRequest) return;
-		return manager?.messenger.subscribe(`${MessageKey.INTLAYER_EDITOR_ENABLED}/get`, onRequest);
-	}, [manager, onRequest]);
-};
-/**
-* Returns a function that sets the editor-enabled state and broadcasts it.
-*/
-const usePostEditorEnabledState = () => {
-	const manager = useEditorStateManager();
-	return (value) => {
-		manager?.editorEnabled.set(value);
-		manager?.editorEnabled.postCurrentValue();
-	};
-};
-const useEditorEnabledState = () => {
-	const { enabled } = useEditorEnabled();
-	const manager = useEditorStateManager();
-	const setter = (value) => manager?.editorEnabled.set(value);
-	return [enabled, setter];
-};
-/**
 * Returns a function that re-pings the client via ARE_YOU_THERE.
 * Use this as the onClick for an "Enable Editor" / reconnect button.
 */
@@ -58,5 +29,5 @@ const useEditorPingClient = () => {
 };
 
 //#endregion
-export { useEditorEnabled, useEditorEnabledState, useEditorPingClient, useGetEditorEnabledState, usePostEditorEnabledState };
+export { useEditorEnabled, useEditorPingClient };
 //# sourceMappingURL=EditorEnabledContext.mjs.map

package/dist/esm/EditorEnabledContext.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"EditorEnabledContext.mjs","names":[],"sources":["../../src/EditorEnabledContext.tsx"],"sourcesContent":["'use client';\n\nimport { MessageKey } from '@intlayer/editor';\nimport { useEffect, useState } from 'react';\nimport { useEditorStateManager } from './EditorStateContext';\n\nexport type EditorEnabledStateProps = {\n  enabled: boolean;\n};\n\n/**\n * Returns the current editor-enabled state, kept in sync with the shared\n * EditorStateManager. Replaces the old EditorEnabledContext + EditorEnabledProvider.\n */\nexport const useEditorEnabled = (): EditorEnabledStateProps => {\n  const manager = useEditorStateManager();\n  const [enabled, setEnabled] = useState<boolean>(\n    manager?.editorEnabled.value ?? false\n  );\n\n  useEffect(() => {\n    if (!manager) return;\n\n    const handler = (e: Event) =>\n      setEnabled((e as CustomEvent<boolean>).detail);\n    manager.editorEnabled.addEventListener('change', handler);\n    return () => manager.editorEnabled.removeEventListener('change', handler);\n  }, [manager]);\n\n  return { enabled };\n};\n\n/**\n * Subscribes to incoming \"get\" requests for editor-enabled state and calls\n * the provided callback so the caller can respond.\n * Used by the editor side to respond when the client asks for the current state.\n */\nexport const useGetEditorEnabledState = (onRequest?: () => void) => {\n  const manager = useEditorStateManager();\n\n  useEffect(() => {\n    if (!onRequest) return;\n\n    return manager?.messenger.subscribe(\n      `${MessageKey.INTLAYER_EDITOR_ENABLED}/get`,\n      onRequest\n    );\n  }, [manager, onRequest]);\n};\n\n/**\n * Returns a function that sets the editor-enabled state and broadcasts it.\n */\nexport const usePostEditorEnabledState = () => {\n  const manager = useEditorStateManager();\n\n  return (value: boolean) => {\n    manager?.editorEnabled.set(value);\n    manager?.editorEnabled.postCurrentValue();\n  };\n};\n\nexport const useEditorEnabledState = () => {\n  const { enabled } = useEditorEnabled();\n  const manager = useEditorStateManager();\n  const setter = (value: boolean) => manager?.editorEnabled.set(value);\n\n  return [enabled, setter] as const;\n};\n\n/**\n * Returns a function that re-pings the client via ARE_YOU_THERE.\n * Use this as the onClick for an \"Enable Editor\" / reconnect button.\n */\nexport const useEditorPingClient = (): (() => void) => {\n  const manager = useEditorStateManager();\n\n  return () => manager?.pingClient();\n};\n"],"mappings":";;;;;;;;;;;AAcA,MAAa,yBAAkD;CAC7D,MAAM,UAAU,sBAAsB;CACtC,MAAM,CAAC,SAAS,cAAc,SAC5B,SAAS,cAAc,SAAS,KAClC;CAEA,gBAAgB;EACd,IAAI,CAAC,SAAS;EAEd,MAAM,WAAW,MACf,WAAY,EAA2B,MAAM;EAC/C,QAAQ,cAAc,iBAAiB,UAAU,OAAO;EACxD,aAAa,QAAQ,cAAc,oBAAoB,UAAU,OAAO;CAC1E,GAAG,CAAC,OAAO,CAAC;CAEZ,OAAO,EAAE,QAAQ;AACnB;;;;;;AAOA,MAAa,4BAA4B,cAA2B;CAClE,MAAM,UAAU,sBAAsB;CAEtC,gBAAgB;EACd,IAAI,CAAC,WAAW;EAEhB,OAAO,SAAS,UAAU,UACxB,GAAG,WAAW,wBAAwB,OACtC,SACF;CACF,GAAG,CAAC,SAAS,SAAS,CAAC;AACzB;;;;AAKA,MAAa,kCAAkC;CAC7C,MAAM,UAAU,sBAAsB;CAEtC,QAAQ,UAAmB;EACzB,SAAS,cAAc,IAAI,KAAK;EAChC,SAAS,cAAc,iBAAiB;CAC1C;AACF;AAEA,MAAa,8BAA8B;CACzC,MAAM,EAAE,YAAY,iBAAiB;CACrC,MAAM,UAAU,sBAAsB;CACtC,MAAM,UAAU,UAAmB,SAAS,cAAc,IAAI,KAAK;CAEnE,OAAO,CAAC,SAAS,MAAM;AACzB;;;;;AAMA,MAAa,4BAA0C;CACrD,MAAM,UAAU,sBAAsB;CAEtC,aAAa,SAAS,WAAW;AACnC"}
+{"version":3,"file":"EditorEnabledContext.mjs","names":[],"sources":["../../src/EditorEnabledContext.tsx"],"sourcesContent":["'use client';\n\nimport { useEffect, useState } from 'react';\nimport { useEditorStateManager } from './EditorStateContext';\n\nexport type EditorEnabledStateProps = {\n  enabled: boolean;\n};\n\n/**\n * Returns the current editor-enabled state, kept in sync with the shared\n * EditorStateManager. Replaces the old EditorEnabledContext + EditorEnabledProvider.\n */\nexport const useEditorEnabled = (): EditorEnabledStateProps => {\n  const manager = useEditorStateManager();\n  const [enabled, setEnabled] = useState<boolean>(\n    manager?.editorEnabled.value ?? false\n  );\n\n  useEffect(() => {\n    if (!manager) return;\n\n    const handler = (e: Event) =>\n      setEnabled((e as CustomEvent<boolean>).detail);\n    manager.editorEnabled.addEventListener('change', handler);\n    return () => manager.editorEnabled.removeEventListener('change', handler);\n  }, [manager]);\n\n  return { enabled };\n};\n\n/**\n * Returns a function that re-pings the client via ARE_YOU_THERE.\n * Use this as the onClick for an \"Enable Editor\" / reconnect button.\n */\nexport const useEditorPingClient = (): (() => void) => {\n  const manager = useEditorStateManager();\n\n  return () => manager?.pingClient();\n};\n"],"mappings":";;;;;;;;;;AAaA,MAAa,yBAAkD;CAC7D,MAAM,UAAU,sBAAsB;CACtC,MAAM,CAAC,SAAS,cAAc,SAC5B,SAAS,cAAc,SAAS,KAClC;CAEA,gBAAgB;EACd,IAAI,CAAC,SAAS;EAEd,MAAM,WAAW,MACf,WAAY,EAA2B,MAAM;EAC/C,QAAQ,cAAc,iBAAiB,UAAU,OAAO;EACxD,aAAa,QAAQ,cAAc,oBAAoB,UAAU,OAAO;CAC1E,GAAG,CAAC,OAAO,CAAC;CAEZ,OAAO,EAAE,QAAQ;AACnB;;;;;AAMA,MAAa,4BAA0C;CACrD,MAAM,UAAU,sBAAsB;CAEtC,aAAa,SAAS,WAAW;AACnC"}

package/dist/esm/FocusDictionaryContext.mjs

@@ -1,72 +1,28 @@
 'use client';
 
 import { useEditorStateManager } from "./EditorStateContext.mjs";
-import { createContext, useCallback, useContext, useEffect, useState } from "react";
-import { jsx } from "react/jsx-runtime";
-import * as NodeTypes from "@intlayer/types/nodeType";
+import { useCallback, useEffect, useState } from "react";
 
 //#region src/FocusDictionaryContext.tsx
-const FocusDictionaryReactContext = createContext(void 0);
-const FocusDictionaryProvider = ({ children }) => {
-	const manager = useEditorStateManager();
-	const [fallbackContent, setFallbackContent] = useState(null);
-	const setFocusedContent = useCallback((value) => {
-		if (manager) manager.focusedContent.set(value);
-		else setFallbackContent(value);
-	}, [manager]);
-	const setFocusedContentKeyPath = useCallback((keyPath) => {
-		if (manager) manager.setFocusedContentKeyPath(keyPath);
-		else setFallbackContent((prev) => {
-			if (!prev) return null;
-			const filtered = keyPath.filter((key) => key.type !== NodeTypes.TRANSLATION);
-			return {
-				...prev,
-				keyPath: filtered
-			};
-		});
-	}, [manager]);
-	return /* @__PURE__ */ jsx(FocusDictionaryReactContext.Provider, {
-		value: {
-			focusedContent: manager?.focusedContent.value ?? fallbackContent,
-			setFocusedContent,
-			setFocusedContentKeyPath
-		},
-		children
-	});
-};
+/**
+* Returns the content focused in the editor, shared with the client frame.
+*/
 const useFocusDictionary = () => {
 	const manager = useEditorStateManager();
-	const reactContext = useContext(FocusDictionaryReactContext);
-	const [focusedContent, setFocusedContentState] = useState(manager?.focusedContent.value ?? reactContext?.focusedContent ?? null);
+	const [focusedContent, setFocusedContentState] = useState(manager?.focusedContent.value ?? null);
 	useEffect(() => {
-		if (!manager) {
-			setFocusedContentState(reactContext?.focusedContent ?? null);
-			return;
-		}
-		const handler = (e) => setFocusedContentState(e.detail);
-		manager.focusedContent.addEventListener("change", handler);
-		return () => manager.focusedContent.removeEventListener("change", handler);
-	}, [manager, reactContext?.focusedContent]);
+		if (!manager) return;
+		const handleChange = (event) => setFocusedContentState(event.detail);
+		manager.focusedContent.addEventListener("change", handleChange);
+		return () => manager.focusedContent.removeEventListener("change", handleChange);
+	}, [manager]);
 	return {
 		focusedContent,
-		setFocusedContent: useCallback((value) => {
-			if (reactContext) reactContext.setFocusedContent(value);
-			else if (manager) manager.focusedContent.set(value);
-		}, [reactContext, manager]),
-		setFocusedContentKeyPath: useCallback((keyPath) => {
-			if (reactContext) reactContext.setFocusedContentKeyPath(keyPath);
-			else if (manager) manager.setFocusedContentKeyPath(keyPath);
-		}, [reactContext, manager])
-	};
-};
-const useFocusDictionaryActions = () => {
-	const { setFocusedContent, setFocusedContentKeyPath } = useFocusDictionary();
-	return {
-		setFocusedContent,
-		setFocusedContentKeyPath
+		setFocusedContent: useCallback((value) => manager?.focusedContent.set(value), [manager]),
+		setFocusedContentKeyPath: useCallback((keyPath) => manager?.setFocusedContentKeyPath(keyPath), [manager])
 	};
 };
 
 //#endregion
-export { FocusDictionaryProvider, useFocusDictionary, useFocusDictionaryActions };
+export { useFocusDictionary };
 //# 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 { CrossFrameStateAction, FileContent } from '@intlayer/editor';\nimport type { KeyPath } from '@intlayer/types/keyPath';\nimport * as NodeTypes from '@intlayer/types/nodeType';\nimport {\n  createContext,\n  type FC,\n  type PropsWithChildren,\n  useCallback,\n  useContext,\n  useEffect,\n  useState,\n} 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  /** Accepts a value or an updater — `setFocusedContent(prev => …)`. */\n  setFocusedContent: (value: CrossFrameStateAction<FileContent | null>) => void;\n  setFocusedContentKeyPath: (keyPath: KeyPath[]) => void;\n};\n\ntype FocusDictionaryContextType = FocusDictionaryState & FocusDictionaryActions;\n\n// Create native React context fallback\nconst FocusDictionaryReactContext = createContext<\n  FocusDictionaryContextType | undefined\n>(undefined);\n\n// Create the Provider\nexport const FocusDictionaryProvider: FC<PropsWithChildren> = ({\n  children,\n}) => {\n  const manager = useEditorStateManager();\n  const [fallbackContent, setFallbackContent] = useState<FileContent | null>(\n    null\n  );\n\n  const setFocusedContent = useCallback(\n    (value: CrossFrameStateAction<FileContent | null>) => {\n      if (manager) {\n        manager.focusedContent.set(value);\n      } else {\n        setFallbackContent(value);\n      }\n    },\n    [manager]\n  );\n\n  const setFocusedContentKeyPath = useCallback(\n    (keyPath: KeyPath[]) => {\n      if (manager) {\n        manager.setFocusedContentKeyPath(keyPath);\n      } else {\n        setFallbackContent((prev) => {\n          if (!prev) return null;\n          const filtered = keyPath.filter(\n            (key) => key.type !== NodeTypes.TRANSLATION\n          );\n          return { ...prev, keyPath: filtered };\n        });\n      }\n    },\n    [manager]\n  );\n\n  return (\n    <FocusDictionaryReactContext.Provider\n      value={{\n        focusedContent: manager?.focusedContent.value ?? fallbackContent,\n        setFocusedContent,\n        setFocusedContentKeyPath,\n      }}\n    >\n      {children}\n    </FocusDictionaryReactContext.Provider>\n  );\n};\n\n// 3. Update the hook to consume the fallback context\nexport const useFocusDictionary = (): FocusDictionaryState &\n  FocusDictionaryActions => {\n  const manager = useEditorStateManager();\n  const reactContext = useContext(FocusDictionaryReactContext);\n\n  const [focusedContent, setFocusedContentState] = useState<FileContent | null>(\n    manager?.focusedContent.value ?? reactContext?.focusedContent ?? null\n  );\n\n  useEffect(() => {\n    if (!manager) {\n      setFocusedContentState(reactContext?.focusedContent ?? null);\n      return;\n    }\n\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, reactContext?.focusedContent]);\n\n  const setFocusedContent = useCallback(\n    (value: CrossFrameStateAction<FileContent | null>) => {\n      if (reactContext) {\n        reactContext.setFocusedContent(value);\n      } else if (manager) {\n        manager.focusedContent.set(value);\n      }\n    },\n    [reactContext, manager]\n  );\n\n  const setFocusedContentKeyPath = useCallback(\n    (keyPath: KeyPath[]) => {\n      if (reactContext) {\n        reactContext.setFocusedContentKeyPath(keyPath);\n      } else if (manager) {\n        manager.setFocusedContentKeyPath(keyPath);\n      }\n    },\n    [reactContext, manager]\n  );\n\n  return {\n    focusedContent,\n    setFocusedContent,\n    setFocusedContentKeyPath,\n  };\n};\n\nexport const useFocusDictionaryActions = (): FocusDictionaryActions => {\n  const { setFocusedContent, setFocusedContentKeyPath } = useFocusDictionary();\n  return { setFocusedContent, setFocusedContentKeyPath };\n};\n"],"mappings":";;;;;;;;AA+BA,MAAM,8BAA8B,cAElC,MAAS;AAGX,MAAa,2BAAkD,EAC7D,eACI;CACJ,MAAM,UAAU,sBAAsB;CACtC,MAAM,CAAC,iBAAiB,sBAAsB,SAC5C,IACF;CAEA,MAAM,oBAAoB,aACvB,UAAqD;EACpD,IAAI,SACF,QAAQ,eAAe,IAAI,KAAK;OAEhC,mBAAmB,KAAK;CAE5B,GACA,CAAC,OAAO,CACV;CAEA,MAAM,2BAA2B,aAC9B,YAAuB;EACtB,IAAI,SACF,QAAQ,yBAAyB,OAAO;OAExC,oBAAoB,SAAS;GAC3B,IAAI,CAAC,MAAM,OAAO;GAClB,MAAM,WAAW,QAAQ,QACtB,QAAQ,IAAI,SAAS,UAAU,WAClC;GACA,OAAO;IAAE,GAAG;IAAM,SAAS;GAAS;EACtC,CAAC;CAEL,GACA,CAAC,OAAO,CACV;CAEA,OACE,oBAAC,4BAA4B,UAA7B;EACE,OAAO;GACL,gBAAgB,SAAS,eAAe,SAAS;GACjD;GACA;EACF;EAEC;CACmC;AAE1C;AAGA,MAAa,2BACe;CAC1B,MAAM,UAAU,sBAAsB;CACtC,MAAM,eAAe,WAAW,2BAA2B;CAE3D,MAAM,CAAC,gBAAgB,0BAA0B,SAC/C,SAAS,eAAe,SAAS,cAAc,kBAAkB,IACnE;CAEA,gBAAgB;EACd,IAAI,CAAC,SAAS;GACZ,uBAAuB,cAAc,kBAAkB,IAAI;GAC3D;EACF;EAEA,MAAM,WAAW,MACf,uBAAwB,EAAsC,MAAM;EACtE,QAAQ,eAAe,iBAAiB,UAAU,OAAO;EAEzD,aAAa,QAAQ,eAAe,oBAAoB,UAAU,OAAO;CAC3E,GAAG,CAAC,SAAS,cAAc,cAAc,CAAC;CAwB1C,OAAO;EACL;EACA,mBAxBwB,aACvB,UAAqD;GACpD,IAAI,cACF,aAAa,kBAAkB,KAAK;QAC/B,IAAI,SACT,QAAQ,eAAe,IAAI,KAAK;EAEpC,GACA,CAAC,cAAc,OAAO,CAgBN;EAChB,0BAd+B,aAC9B,YAAuB;GACtB,IAAI,cACF,aAAa,yBAAyB,OAAO;QACxC,IAAI,SACT,QAAQ,yBAAyB,OAAO;EAE5C,GACA,CAAC,cAAc,OAAO,CAMC;CACzB;AACF;AAEA,MAAa,kCAA0D;CACrE,MAAM,EAAE,mBAAmB,6BAA6B,mBAAmB;CAC3E,OAAO;EAAE;EAAmB;CAAyB;AACvD"}
+{"version":3,"file":"FocusDictionaryContext.mjs","names":[],"sources":["../../src/FocusDictionaryContext.tsx"],"sourcesContent":["'use client';\n\nimport type { CrossFrameStateAction, FileContent } from '@intlayer/editor';\nimport type { KeyPath } from '@intlayer/types/keyPath';\nimport { useCallback, useEffect, useState } from 'react';\nimport { useEditorStateManager } from './EditorStateContext';\n\nexport type { FileContent } from '@intlayer/editor';\n\nexport type FocusDictionaryActions = {\n  /** Accepts a value or an updater — `setFocusedContent(prev => …)`. */\n  setFocusedContent: (value: CrossFrameStateAction<FileContent | null>) => void;\n  setFocusedContentKeyPath: (keyPath: KeyPath[]) => void;\n};\n\n/**\n * Returns the content focused in the editor, shared with the client frame.\n */\nexport const useFocusDictionary = (): FocusDictionaryActions & {\n  focusedContent: FileContent | null;\n} => {\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\n    const handleChange = (event: Event) =>\n      setFocusedContentState((event as CustomEvent<FileContent | null>).detail);\n    manager.focusedContent.addEventListener('change', handleChange);\n\n    return () =>\n      manager.focusedContent.removeEventListener('change', handleChange);\n  }, [manager]);\n\n  const setFocusedContent = useCallback(\n    (value: CrossFrameStateAction<FileContent | null>) =>\n      manager?.focusedContent.set(value),\n    [manager]\n  );\n\n  const setFocusedContentKeyPath = useCallback(\n    (keyPath: KeyPath[]) => manager?.setFocusedContentKeyPath(keyPath),\n    [manager]\n  );\n\n  return { focusedContent, setFocusedContent, setFocusedContentKeyPath };\n};\n"],"mappings":";;;;;;;;;AAkBA,MAAa,2BAER;CACH,MAAM,UAAU,sBAAsB;CACtC,MAAM,CAAC,gBAAgB,0BAA0B,SAC/C,SAAS,eAAe,SAAS,IACnC;CAEA,gBAAgB;EACd,IAAI,CAAC,SAAS;EAEd,MAAM,gBAAgB,UACpB,uBAAwB,MAA0C,MAAM;EAC1E,QAAQ,eAAe,iBAAiB,UAAU,YAAY;EAE9D,aACE,QAAQ,eAAe,oBAAoB,UAAU,YAAY;CACrE,GAAG,CAAC,OAAO,CAAC;CAaZ,OAAO;EAAE;EAAgB,mBAXC,aACvB,UACC,SAAS,eAAe,IAAI,KAAK,GACnC,CAAC,OAAO,CAQ+B;EAAG,0BALX,aAC9B,YAAuB,SAAS,yBAAyB,OAAO,GACjE,CAAC,OAAO,CAGyD;CAAE;AACvE"}

package/dist/esm/index.mjs

@@ -1,17 +1,15 @@
 import { EditorStateProvider, useEditorStateManager } from "./EditorStateContext.mjs";
 import { useDictionariesRecord, useDictionariesRecordActions } from "./DictionariesRecordContext.mjs";
 import { useCrossFrameState } from "./useCrossFrameState.mjs";
-import { useCrossURLPathSetter, useCrossURLPathState } from "./useCrossURLPathState.mjs";
-import { useCrossFrameMessageListener } from "./useCrossFrameMessageListener.mjs";
-import { useIframeClickInterceptor, useIframeClickMerger } from "./useIframeClickInterceptor.mjs";
-import { useEditorLocale, useSetEditorLocale } from "./useEditorLocale.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 { useCrossURLPathState } from "./useCrossURLPathState.mjs";
+import { useEditedContent, useEditedContentActions } from "./EditedContentContext.mjs";
+import { useEditedContentPersistence } from "./useEditedContentPersistence.mjs";
+import { useEditorLocale } from "./useEditorLocale.mjs";
+import { useConfiguration } from "./ConfigurationContext.mjs";
+import { useEditorEnabled, useEditorPingClient } from "./EditorEnabledContext.mjs";
 import { EditorProvider } from "./EditorProvider.mjs";
-import { FocusDictionaryProvider, useFocusDictionary, useFocusDictionaryActions } from "./FocusDictionaryContext.mjs";
+import { useFocusDictionary } from "./FocusDictionaryContext.mjs";
 import { useFocusUnmergedDictionary } from "./useFocusUnmergedDictionary.mjs";
 import { MessageKey } from "@intlayer/editor";
 
-export { ConfigurationProvider, EditorProvider, EditorStateProvider, FocusDictionaryProvider, 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 };
+export { EditorProvider, EditorStateProvider, MessageKey, useConfiguration, useCrossFrameState, useCrossURLPathState, useDictionariesRecord, useDictionariesRecordActions, useEditedContent, useEditedContentActions, useEditedContentPersistence, useEditorEnabled, useEditorLocale, useEditorPingClient, useEditorStateManager, useFocusDictionary, useFocusUnmergedDictionary };

package/dist/esm/useCrossFrameState.mjs

@@ -1,62 +1,17 @@
 'use client';
 
 import { useEditorStateManager } from "./EditorStateContext.mjs";
-import { useEffect, useRef, useState } from "react";
-import { CrossFrameStateManager } from "@intlayer/editor";
+import { useEffect, useState } from "react";
 
 //#region src/useCrossFrameState.tsx
 /**
-* Synchronizes a React state value across frames using CrossFrameStateManager.
+* Returns the latest value another frame posted under `key`.
 */
-const useCrossFrameState = (key, initialState, options) => {
+const useCrossFrameState = (key, initialValue) => {
 	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 ?? {};
-		if (!manager?.messenger) return;
-		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
-	];
+	const [value, setValue] = useState(initialValue);
+	useEffect(() => manager?.messenger.subscribe(`${key}/post`, (postedValue) => setValue(() => postedValue)), [manager, key]);
+	return value;
 };
 
 //#endregion

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\n    if (!manager?.messenger) return;\n\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,sBAAsB;CAEtC,MAAM,kBACJ,OAAO,iBAAiB,aACnB,aAAyB,IAC1B;CAEN,MAAM,CAAC,OAAO,iBAAiB,SAAY,eAAoB;CAC/D,MAAM,WAAW,OAAU,eAAoB;CAE/C,MAAM,kBAAkB,OAAyC,IAAI;CAErE,gBAAgB;EACd,MAAM,EAAE,OAAO,MAAM,UAAU,SAAS,WAAW,CAAC;EAEpD,IAAI,CAAC,SAAS,WAAW;EAEzB,MAAM,eAAe,IAAI,uBACvB,KACA,SAAS,WACT;GACE;GACA;GACA,cAAc;EAChB,CACF;EACA,gBAAgB,UAAU;EAE1B,MAAM,WAAW,MAAa;GAC5B,MAAM,WAAY,EAAqB;GACvC,SAAS,UAAU;GACnB,cAAc,QAAQ;EACxB;EACA,aAAa,iBAAiB,UAAU,OAAO;EAC/C,aAAa,MAAM;EAEnB,aAAa;GACX,aAAa,oBAAoB,UAAU,OAAO;GAClD,aAAa,KAAK;GAClB,gBAAgB,UAAU;EAC5B;CACF,GAAG;EAAC;EAAK,SAAS;EAAW,SAAS;EAAM,SAAS;CAAO,CAAC;CAE7D,MAAM,YAAyC,mBAAmB;EAChE,eAAe,SAAS;GACtB,MAAM,WACJ,OAAO,mBAAmB,aACrB,eAAkC,IAAI,IACvC;GACN,SAAS,UAAU;GACnB,gBAAgB,SAAS,IAAI,QAAQ;GACrC,OAAO;EACT,CAAC;CACH;CAEA,MAAM,kBAAkB;EACtB,gBAAgB,SAAS,iBAAiB;CAC5C;CAEA,OAAO;EAAC;EAAO;EAAU;CAAS;AACpC"}
+{"version":3,"file":"useCrossFrameState.mjs","names":[],"sources":["../../src/useCrossFrameState.tsx"],"sourcesContent":["'use client';\n\nimport type { MessageKey } from '@intlayer/editor';\nimport { useEffect, useState } from 'react';\nimport { useEditorStateManager } from './EditorStateContext';\n\n/**\n * Returns the latest value another frame posted under `key`.\n */\nexport const useCrossFrameState = <Value,>(\n  key: `${MessageKey}`,\n  initialValue: Value\n): Value => {\n  const manager = useEditorStateManager();\n  const [value, setValue] = useState<Value>(initialValue);\n\n  useEffect(\n    () =>\n      manager?.messenger.subscribe<Value>(`${key}/post`, (postedValue) =>\n        setValue(() => postedValue)\n      ),\n    [manager, key]\n  );\n\n  return value;\n};\n"],"mappings":";;;;;;;;;AASA,MAAa,sBACX,KACA,iBACU;CACV,MAAM,UAAU,sBAAsB;CACtC,MAAM,CAAC,OAAO,YAAY,SAAgB,YAAY;CAEtD,gBAEI,SAAS,UAAU,UAAiB,GAAG,IAAI,SAAS,gBAClD,eAAe,WAAW,CAC5B,GACF,CAAC,SAAS,GAAG,CACf;CAEA,OAAO;AACT"}

package/dist/esm/useCrossURLPathState.mjs

@@ -4,14 +4,11 @@ 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
-	});
-};
+/**
+* Returns the path currently displayed by the client application.
+*/
+const useCrossURLPathState = () => useCrossFrameState(MessageKey.INTLAYER_URL_CHANGE, void 0);
 
 //#endregion
-export { useCrossURLPathSetter, useCrossURLPathState };
+export { 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":";;;;;;AAQA,MAAa,wBACX,cACA,YACG,mBAAmB,WAAW,qBAAqB,cAAc,OAAO;AAE7E,MAAa,yBAAyB,iBAA0B;CAG9D,OAAO,qBAAqB,cAAc;EAAE,MAAM;EAAM,SAAS;CAAM,CAAC;AAC1E"}
+{"version":3,"file":"useCrossURLPathState.mjs","names":[],"sources":["../../src/useCrossURLPathState.tsx"],"sourcesContent":["'use client';\n\nimport { MessageKey } from '@intlayer/editor';\nimport { useCrossFrameState } from './useCrossFrameState';\n\n/**\n * Returns the path currently displayed by the client application.\n */\nexport const useCrossURLPathState = (): string | undefined =>\n  useCrossFrameState<string | undefined>(\n    MessageKey.INTLAYER_URL_CHANGE,\n    undefined\n  );\n"],"mappings":";;;;;;;;;AAQA,MAAa,6BACX,mBACE,WAAW,qBACX,MACF"}

package/dist/esm/useEditedContentPersistence.mjs

@@ -0,0 +1,32 @@
+'use client';
+
+import { useEditedContent } from "./EditedContentContext.mjs";
+import { useEffect } from "react";
+
+//#region src/useEditedContentPersistence.tsx
+const EDITED_CONTENT_STORAGE_KEY = "INTLAYER_EDITED_CONTENT_CHANGED";
+/**
+* Persists the edited content in localStorage, and restores it on mount so
+* unsaved edits survive a page reload.
+*/
+const useEditedContentPersistence = () => {
+	const { editedContent, setEditedContentState } = useEditedContent();
+	useEffect(() => {
+		if (editedContent !== void 0) return;
+		const persistedState = localStorage.getItem(EDITED_CONTENT_STORAGE_KEY);
+		if (!persistedState) return;
+		try {
+			setEditedContentState(JSON.parse(persistedState));
+		} catch (error) {
+			console.error(error);
+		}
+	}, []);
+	useEffect(() => {
+		if (editedContent === void 0) return;
+		localStorage.setItem(EDITED_CONTENT_STORAGE_KEY, JSON.stringify(editedContent));
+	}, [editedContent]);
+};
+
+//#endregion
+export { useEditedContentPersistence };
+//# sourceMappingURL=useEditedContentPersistence.mjs.map

package/dist/esm/useEditedContentPersistence.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEditedContentPersistence.mjs","names":[],"sources":["../../src/useEditedContentPersistence.tsx"],"sourcesContent":["'use client';\n\nimport { useEffect } from 'react';\nimport { useEditedContent } from './EditedContentContext';\n\nconst EDITED_CONTENT_STORAGE_KEY = 'INTLAYER_EDITED_CONTENT_CHANGED';\n\n/**\n * Persists the edited content in localStorage, and restores it on mount so\n * unsaved edits survive a page reload.\n */\nexport const useEditedContentPersistence = (): void => {\n  const { editedContent, setEditedContentState } = useEditedContent();\n\n  useEffect(() => {\n    if (editedContent !== undefined) return;\n\n    const persistedState = localStorage.getItem(EDITED_CONTENT_STORAGE_KEY);\n    if (!persistedState) return;\n\n    try {\n      setEditedContentState(JSON.parse(persistedState));\n    } catch (error) {\n      console.error(error);\n    }\n  }, []);\n\n  useEffect(() => {\n    if (editedContent === undefined) return;\n\n    localStorage.setItem(\n      EDITED_CONTENT_STORAGE_KEY,\n      JSON.stringify(editedContent)\n    );\n  }, [editedContent]);\n};\n"],"mappings":";;;;;;AAKA,MAAM,6BAA6B;;;;;AAMnC,MAAa,oCAA0C;CACrD,MAAM,EAAE,eAAe,0BAA0B,iBAAiB;CAElE,gBAAgB;EACd,IAAI,kBAAkB,QAAW;EAEjC,MAAM,iBAAiB,aAAa,QAAQ,0BAA0B;EACtE,IAAI,CAAC,gBAAgB;EAErB,IAAI;GACF,sBAAsB,KAAK,MAAM,cAAc,CAAC;EAClD,SAAS,OAAO;GACd,QAAQ,MAAM,KAAK;EACrB;CACF,GAAG,CAAC,CAAC;CAEL,gBAAgB;EACd,IAAI,kBAAkB,QAAW;EAEjC,aAAa,QACX,4BACA,KAAK,UAAU,aAAa,CAC9B;CACF,GAAG,CAAC,aAAa,CAAC;AACpB"}

package/dist/esm/useEditorLocale.mjs

@@ -15,11 +15,7 @@ const useEditorLocale = () => {
 	}, [manager]);
 	return locale;
 };
-const useSetEditorLocale = () => {
-	const manager = useEditorStateManager();
-	return (locale) => manager?.currentLocale.set(locale);
-};
 
 //#endregion
-export { useEditorLocale, useSetEditorLocale };
+export { useEditorLocale };
 //# 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":";;;;;;AAMA,MAAa,wBAA4C;CACvD,MAAM,UAAU,sBAAsB;CACtC,MAAM,CAAC,QAAQ,aAAa,SAC1B,SAAS,cAAc,KACzB;CAEA,gBAAgB;EACd,IAAI,CAAC,SAAS;EAEd,MAAM,WAAW,MAAa,UAAW,EAA0B,MAAM;EACzE,QAAQ,cAAc,iBAAiB,UAAU,OAAO;EAExD,aAAa,QAAQ,cAAc,oBAAoB,UAAU,OAAO;CAC1E,GAAG,CAAC,OAAO,CAAC;CAEZ,OAAO;AACT;AAEA,MAAa,2BAA2B;CACtC,MAAM,UAAU,sBAAsB;CACtC,QAAQ,WAAmB,SAAS,cAAc,IAAI,MAAM;AAC9D"}
+{"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"],"mappings":";;;;;;AAMA,MAAa,wBAA4C;CACvD,MAAM,UAAU,sBAAsB;CACtC,MAAM,CAAC,QAAQ,aAAa,SAC1B,SAAS,cAAc,KACzB;CAEA,gBAAgB;EACd,IAAI,CAAC,SAAS;EAEd,MAAM,WAAW,MAAa,UAAW,EAA0B,MAAM;EACzE,QAAQ,cAAc,iBAAiB,UAAU,OAAO;EAExD,aAAa,QAAQ,cAAc,oBAAoB,UAAU,OAAO;CAC1E,GAAG,CAAC,OAAO,CAAC;CAEZ,OAAO;AACT"}

package/dist/types/ConfigurationContext.d.ts

@@ -1,11 +1,8 @@
 import { IntlayerConfig } from "@intlayer/types/config";
-import { FC, PropsWithChildren } from "react";
 //#region src/ConfigurationContext.d.ts
-export type ConfigurationProviderProps = PropsWithChildren<{
-  configuration?: IntlayerConfig;
-}>;
-export declare const ConfigurationProvider: FC<ConfigurationProviderProps>;
+/**
+ * Returns the Intlayer configuration held by the editor state manager.
+ */
 export declare const useConfiguration: () => IntlayerConfig | undefined;
-export declare const useConfigurationState: () => readonly [IntlayerConfig, import("react").Dispatch<import("react").SetStateAction<IntlayerConfig>>, () => void];
 //#endregion
 //# sourceMappingURL=ConfigurationContext.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ConfigurationContext.d.ts","names":[],"sources":["../../src/ConfigurationContext.tsx"],"mappings":";;;YAkBY,6BAA6B;EACvC,gBAAgB;;qBAGL,uBAAuB,GAAG;qBAoB1B,wBAAuB;qBA2BvB,uCAAqB,gCAAA,yBAAA,eAAA"}
+{"version":3,"file":"ConfigurationContext.d.ts","names":[],"sources":["../../src/ConfigurationContext.tsx"],"mappings":";;;;;qBASa,wBAAuB"}

package/dist/types/EditedContentContext.d.ts

@@ -10,8 +10,6 @@ type EditedContentActionsContextType = {
   renameEditedContent: (localDictionaryId: LocalDictionaryId, newKey: KeyPath['key'], keyPath?: KeyPath[]) => void;
   removeEditedContent: (localDictionaryId: LocalDictionaryId, keyPath: KeyPath[]) => void;
   restoreEditedContent: (localDictionaryId: LocalDictionaryId) => void;
-  clearEditedDictionaryContent: (localDictionaryId: LocalDictionaryId) => void;
-  clearEditedContent: () => void;
   getEditedContentValue: (localDictionaryIdOrKey: LocalDictionaryId | Dictionary['key'] | string, keyPath: KeyPath[]) => ContentNode | undefined;
 };
 export declare const useEditedContentActions: () => EditedContentActionsContextType;
@@ -23,13 +21,9 @@ export declare const useEditedContent: () => {
   renameEditedContent: (localDictionaryId: LocalDictionaryId, newKey: KeyPath['key'], keyPath?: KeyPath[]) => void;
   removeEditedContent: (localDictionaryId: LocalDictionaryId, keyPath: KeyPath[]) => void;
   restoreEditedContent: (localDictionaryId: LocalDictionaryId) => void;
-  clearEditedDictionaryContent: (localDictionaryId: LocalDictionaryId) => void;
-  clearEditedContent: () => void;
   getEditedContentValue: (localDictionaryIdOrKey: LocalDictionaryId | Dictionary['key'] | string, keyPath: KeyPath[]) => ContentNode | undefined;
   editedContent: DictionaryContent$1;
 };
-export declare const usePostEditedContentState: <S>(onEventTriggered?: (data: S) => void) => void;
-export declare const useGetEditedContentState: () => () => void;
 //#endregion
 export type { DictionaryContent };
 //# sourceMappingURL=EditedContentContext.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"EditedContentContext.d.ts","names":[],"sources":["../../src/EditedContentContext.tsx"],"mappings":";;;;KAcK;EACH,wBAAwB,eAAe;EACvC,sBAAsB,MAAM;EAC5B,mBACE,mBAAmB,mBACnB,UAAU;EAEZ,mBACE,mBAAmB,mBACnB,UAAU,kBACV,UAAU,WACV;EAEF,sBACE,mBAAmB,mBACnB,QAAQ,gBACR,UAAU;EAEZ,sBACE,mBAAmB,mBACnB,SAAS;EAEX,uBAAuB,mBAAmB;EAC1C,+BAA+B,mBAAmB;EAClD;EACA,wBACE,wBAAwB,oBAAoB,4BAC5C,SAAS,cACN;;qBAGM,+BAA8B;qBA0B9B;EAxDY,wBAAC,eAAe;EAClB,sBAAC,MAAM;EACV,mBAChB,mBAAmB,mBACnB,UAAU;EAEM,mBAChB,mBAAmB,mBACnB,UAAU,kBACV,UAAU,WACV;EAEmB,sBACnB,mBAAmB,mBACnB,QAAQ,gBACR,UAAU;EAES,sBACnB,mBAAmB,mBACnB,SAAS;EAEW,uBAAC,mBAAmB;EACZ,+BAAC,mBAAmB;EAC9B;EACG,wBACrB,wBAAwB,oBAAoB,4BAC5C,SAAS,cACN;;;qBA+CM,4BAA6B,GAAC,oBACrB,MAAM;qBAYf"}
+{"version":3,"file":"EditedContentContext.d.ts","names":[],"sources":["../../src/EditedContentContext.tsx"],"mappings":";;;;KAcK;EACH,wBAAwB,eAAe;EACvC,sBAAsB,MAAM;EAC5B,mBACE,mBAAmB,mBACnB,UAAU;EAEZ,mBACE,mBAAmB,mBACnB,UAAU,kBACV,UAAU,WACV;EAEF,sBACE,mBAAmB,mBACnB,QAAQ,gBACR,UAAU;EAEZ,sBACE,mBAAmB,mBACnB,SAAS;EAEX,uBAAuB,mBAAmB;EAC1C,wBACE,wBAAwB,oBAAoB,4BAC5C,SAAS,cACN;;qBAGM,+BAA8B;qBAwB9B;EApDY,wBAAC,eAAe;EAClB,sBAAC,MAAM;EACV,mBAChB,mBAAmB,mBACnB,UAAU;EAEM,mBAChB,mBAAmB,mBACnB,UAAU,kBACV,UAAU,WACV;EAEmB,sBACnB,mBAAmB,mBACnB,QAAQ,gBACR,UAAU;EAES,sBACnB,mBAAmB,mBACnB,SAAS;EAEW,uBAAC,mBAAmB;EACnB,wBACrB,wBAAwB,oBAAoB,4BAC5C,SAAS,cACN"}

package/dist/types/EditorEnabledContext.d.ts

@@ -7,17 +7,6 @@ export type EditorEnabledStateProps = {
  * EditorStateManager. Replaces the old EditorEnabledContext + EditorEnabledProvider.
  */
 export declare const useEditorEnabled: () => EditorEnabledStateProps;
-/**
- * Subscribes to incoming "get" requests for editor-enabled state and calls
- * the provided callback so the caller can respond.
- * Used by the editor side to respond when the client asks for the current state.
- */
-export declare const useGetEditorEnabledState: (onRequest?: () => void) => void;
-/**
- * Returns a function that sets the editor-enabled state and broadcasts it.
- */
-export declare const usePostEditorEnabledState: () => (value: boolean) => void;
-export declare const useEditorEnabledState: () => readonly [boolean, (value: boolean) => void];
 /**
  * Returns a function that re-pings the client via ARE_YOU_THERE.
  * Use this as the onClick for an "Enable Editor" / reconnect button.

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

@@ -1 +1 @@
-{"version":3,"file":"EditorEnabledContext.d.ts","names":[],"sources":["../../src/EditorEnabledContext.tsx"],"mappings":";YAMY;EACV;;;;;;qBAOW,wBAAuB;;;;;;qBAuBvB,2BAAwB;;;;qBAgBxB,kCAAyB;qBASzB,iDAAqB;;;;;qBAYrB"}
+{"version":3,"file":"EditorEnabledContext.d.ts","names":[],"sources":["../../src/EditorEnabledContext.tsx"],"mappings":";YAKY;EACV;;;;;;qBAOW,wBAAuB;;;;;qBAsBvB"}

package/dist/types/FocusDictionaryContext.d.ts

@@ -1,18 +1,17 @@
 import { CrossFrameStateAction, FileContent, FileContent as FileContent$1 } from "@intlayer/editor";
-import { FC, PropsWithChildren } from "react";
 import { KeyPath } from "@intlayer/types/keyPath";
 //#region src/FocusDictionaryContext.d.ts
-export type FocusDictionaryState = {
-  focusedContent: FileContent$1 | null;
-};
 export type FocusDictionaryActions = {
   /** Accepts a value or an updater — `setFocusedContent(prev => …)`. */
   setFocusedContent: (value: CrossFrameStateAction<FileContent$1 | null>) => void;
   setFocusedContentKeyPath: (keyPath: KeyPath[]) => void;
 };
-export declare const FocusDictionaryProvider: FC<PropsWithChildren>;
-export declare const useFocusDictionary: () => FocusDictionaryState & FocusDictionaryActions;
-export declare const useFocusDictionaryActions: () => FocusDictionaryActions;
+/**
+ * Returns the content focused in the editor, shared with the client frame.
+ */
+export declare const useFocusDictionary: () => FocusDictionaryActions & {
+  focusedContent: FileContent$1 | null;
+};
 //#endregion
 export type { FileContent };
 //# sourceMappingURL=FocusDictionaryContext.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"FocusDictionaryContext.d.ts","names":[],"sources":["../../src/FocusDictionaryContext.tsx"],"mappings":";;;;YAkBY;EACV,gBAAgB;;YAGN;;EAEV,oBAAoB,OAAO,sBAAsB;EACjD,2BAA2B,SAAS;;qBAWzB,yBAAyB,GAAG;qBAkD5B,0BAAyB,uBACpC;qBAkDW,iCAAgC"}
+{"version":3,"file":"FocusDictionaryContext.d.ts","names":[],"sources":["../../src/FocusDictionaryContext.tsx"],"mappings":";;;YASY;;EAEV,oBAAoB,OAAO,sBAAsB;EACjD,2BAA2B,SAAS;;;;;qBAMzB,0BAAyB;EACpC,gBAAgB"}

package/dist/types/index.d.ts

@@ -1,16 +1,14 @@
-import { MessengerConfig, UseCrossPlatformStateProps, useCommunicator } from "./CommunicatorContext.js";
-import { ConfigurationProvider, ConfigurationProviderProps, useConfiguration, useConfigurationState } from "./ConfigurationContext.js";
+import { useConfiguration } from "./ConfigurationContext.js";
 import { DictionaryContent as DictionaryContent$1, useDictionariesRecord, useDictionariesRecordActions } from "./DictionariesRecordContext.js";
-import { useEditedContent, useEditedContentActions, useGetEditedContentState, usePostEditedContentState } from "./EditedContentContext.js";
-import { EditorEnabledStateProps, useEditorEnabled, useEditorEnabledState, useEditorPingClient, useGetEditorEnabledState, usePostEditorEnabledState } from "./EditorEnabledContext.js";
+import { useEditedContent, useEditedContentActions } from "./EditedContentContext.js";
+import { EditorEnabledStateProps, useEditorEnabled, useEditorPingClient } from "./EditorEnabledContext.js";
 import { EditorProvider, EditorProviderProps } from "./EditorProvider.js";
 import { EditorStateProvider, useEditorStateManager } from "./EditorStateContext.js";
-import { FileContent, FocusDictionaryActions, FocusDictionaryProvider, FocusDictionaryState, useFocusDictionary, useFocusDictionaryActions } from "./FocusDictionaryContext.js";
-import { useCrossFrameMessageListener } from "./useCrossFrameMessageListener.js";
-import { CrossFrameStateOptions, useCrossFrameState } from "./useCrossFrameState.js";
-import { useCrossURLPathSetter, useCrossURLPathState } from "./useCrossURLPathState.js";
-import { useEditorLocale, useSetEditorLocale } from "./useEditorLocale.js";
+import { FileContent, FocusDictionaryActions, useFocusDictionary } from "./FocusDictionaryContext.js";
+import { useCrossFrameState } from "./useCrossFrameState.js";
+import { useCrossURLPathState } from "./useCrossURLPathState.js";
+import { useEditedContentPersistence } from "./useEditedContentPersistence.js";
+import { useEditorLocale } from "./useEditorLocale.js";
 import { useFocusUnmergedDictionary } from "./useFocusUnmergedDictionary.js";
-import { useIframeClickInterceptor, useIframeClickMerger } from "./useIframeClickInterceptor.js";
 import { MessageKey } from "@intlayer/editor";
-export { ConfigurationProvider, ConfigurationProviderProps, CrossFrameStateOptions, EditorEnabledStateProps, EditorProvider, EditorProviderProps, EditorStateProvider, type FileContent, FocusDictionaryActions, FocusDictionaryProvider, FocusDictionaryState, MessageKey, type MessengerConfig, UseCrossPlatformStateProps, 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 };
+export { EditorEnabledStateProps, EditorProvider, EditorProviderProps, EditorStateProvider, type FileContent, FocusDictionaryActions, MessageKey, useConfiguration, useCrossFrameState, useCrossURLPathState, useDictionariesRecord, useDictionariesRecordActions, useEditedContent, useEditedContentActions, useEditedContentPersistence, useEditorEnabled, useEditorLocale, useEditorPingClient, useEditorStateManager, useFocusDictionary, useFocusUnmergedDictionary };

package/dist/types/useCrossFrameState.d.ts

@@ -1,13 +1,8 @@
 import { MessageKey } from "@intlayer/editor";
-import { Dispatch, SetStateAction } from "react";
 //#region src/useCrossFrameState.d.ts
-export type CrossFrameStateOptions = {
-  emit?: boolean;
-  receive?: boolean;
-};
 /**
- * Synchronizes a React state value across frames using CrossFrameStateManager.
+ * Returns the latest value another frame posted under `key`.
  */
-export declare const useCrossFrameState: <S>(key: `${MessageKey}`, initialState?: S | (() => S), options?: CrossFrameStateOptions) => [S, Dispatch<SetStateAction<S>>, () => void];
+export declare const useCrossFrameState: <Value>(key: `${MessageKey}`, initialValue: Value) => Value;
 //#endregion
 //# sourceMappingURL=useCrossFrameState.d.ts.map