@intlayer/editor-react 4.0.3

package/dist/cjs/FocusDictionaryContext.cjs

@@ -0,0 +1,79 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var FocusDictionaryContext_exports = {};
+__export(FocusDictionaryContext_exports, {
+  FocusDictionaryProvider: () => FocusDictionaryProvider,
+  useFocusDictionary: () => useFocusDictionary,
+  useFocusDictionaryActions: () => useFocusDictionaryActions
+});
+module.exports = __toCommonJS(FocusDictionaryContext_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_react = require("react");
+var import_useCrossFrameState = require('./useCrossFrameState.cjs');
+const FocusDictionaryStateContext = (0, import_react.createContext)(void 0);
+const FocusDictionaryActionsContext = (0, import_react.createContext)(void 0);
+const FocusDictionaryProvider = ({
+  children
+}) => {
+  const [focusedContent, setFocusedContentState] = (0, import_useCrossFrameState.useCrossFrameState)("FOCUSED_CONTENT_CHANGED", null);
+  const setFocusedContent = (content) => {
+    setFocusedContentState(content);
+  };
+  const setFocusedContentKeyPath = (keyPath) => {
+    setFocusedContentState((prev) => {
+      if (!prev) {
+        return prev;
+      }
+      return { ...prev, keyPath };
+    });
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(FocusDictionaryStateContext.Provider, { value: { focusedContent }, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    FocusDictionaryActionsContext.Provider,
+    {
+      value: { setFocusedContent, setFocusedContentKeyPath },
+      children
+    }
+  ) });
+};
+const useFocusDictionaryActions = () => {
+  const context = (0, import_react.useContext)(FocusDictionaryActionsContext);
+  if (context === void 0) {
+    throw new Error(
+      "useFocusDictionaryActions must be used within a FocusDictionaryProvider"
+    );
+  }
+  return context;
+};
+const useFocusDictionary = () => {
+  const actionContext = useFocusDictionaryActions();
+  const stateContext = (0, import_react.useContext)(FocusDictionaryStateContext);
+  if (stateContext === void 0) {
+    throw new Error(
+      "useFocusDictionaryState must be used within a FocusDictionaryProvider"
+    );
+  }
+  return { ...stateContext, ...actionContext };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FocusDictionaryProvider,
+  useFocusDictionary,
+  useFocusDictionaryActions
+});
+//# sourceMappingURL=FocusDictionaryContext.cjs.map

package/dist/cjs/FocusDictionaryContext.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/FocusDictionaryContext.tsx"],"sourcesContent":["import type { KeyPath } from '@intlayer/core';\nimport { createContext, useContext, FC, PropsWithChildren } from 'react';\nimport { useCrossFrameState } from './useCrossFrameState';\n\ntype DictionaryPath = string;\n\nexport type FileContent = {\n  dictionaryKey: string;\n  keyPath?: KeyPath[];\n  dictionaryPath?: DictionaryPath;\n};\n\ninterface FocusDictionaryState {\n  focusedContent: FileContent | null;\n}\n\ninterface FocusDictionaryActions {\n  setFocusedContent: (content: FileContent | null) => void;\n  setFocusedContentKeyPath: (keyPath: KeyPath[]) => void;\n}\n\nconst FocusDictionaryStateContext = createContext<\n  FocusDictionaryState | undefined\n>(undefined);\nconst FocusDictionaryActionsContext = createContext<\n  FocusDictionaryActions | undefined\n>(undefined);\n\nexport const FocusDictionaryProvider: FC<PropsWithChildren> = ({\n  children,\n}) => {\n  const [focusedContent, setFocusedContentState] =\n    useCrossFrameState<FileContent | null>('FOCUSED_CONTENT_CHANGED', null);\n\n  const setFocusedContent = (content: FileContent | null) => {\n    setFocusedContentState(content);\n  };\n\n  const setFocusedContentKeyPath = (keyPath: KeyPath[]) => {\n    setFocusedContentState((prev) => {\n      if (!prev) {\n        return prev; // nothing to update if there's no focused content\n      }\n      return { ...prev, keyPath };\n    });\n  };\n\n  return (\n    <FocusDictionaryStateContext.Provider value={{ focusedContent }}>\n      <FocusDictionaryActionsContext.Provider\n        value={{ setFocusedContent, setFocusedContentKeyPath }}\n      >\n        {children}\n      </FocusDictionaryActionsContext.Provider>\n    </FocusDictionaryStateContext.Provider>\n  );\n};\n\nexport const useFocusDictionaryActions = () => {\n  const context = useContext(FocusDictionaryActionsContext);\n  if (context === undefined) {\n    throw new Error(\n      'useFocusDictionaryActions must be used within a FocusDictionaryProvider'\n    );\n  }\n  return context;\n};\n\nexport const useFocusDictionary = () => {\n  const actionContext = useFocusDictionaryActions();\n  const stateContext = useContext(FocusDictionaryStateContext);\n\n  if (stateContext === undefined) {\n    throw new Error(\n      'useFocusDictionaryState must be used within a FocusDictionaryProvider'\n    );\n  }\n\n  return { ...stateContext, ...actionContext };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAiDM;AAhDN,mBAAiE;AACjE,gCAAmC;AAmBnC,MAAM,kCAA8B,4BAElC,MAAS;AACX,MAAM,oCAAgC,4BAEpC,MAAS;AAEJ,MAAM,0BAAiD,CAAC;AAAA,EAC7D;AACF,MAAM;AACJ,QAAM,CAAC,gBAAgB,sBAAsB,QAC3C,8CAAuC,2BAA2B,IAAI;AAExE,QAAM,oBAAoB,CAAC,YAAgC;AACzD,2BAAuB,OAAO;AAAA,EAChC;AAEA,QAAM,2BAA2B,CAAC,YAAuB;AACvD,2BAAuB,CAAC,SAAS;AAC/B,UAAI,CAAC,MAAM;AACT,eAAO;AAAA,MACT;AACA,aAAO,EAAE,GAAG,MAAM,QAAQ;AAAA,IAC5B,CAAC;AAAA,EACH;AAEA,SACE,4CAAC,4BAA4B,UAA5B,EAAqC,OAAO,EAAE,eAAe,GAC5D;AAAA,IAAC,8BAA8B;AAAA,IAA9B;AAAA,MACC,OAAO,EAAE,mBAAmB,yBAAyB;AAAA,MAEpD;AAAA;AAAA,EACH,GACF;AAEJ;AAEO,MAAM,4BAA4B,MAAM;AAC7C,QAAM,cAAU,yBAAW,6BAA6B;AACxD,MAAI,YAAY,QAAW;AACzB,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AACA,SAAO;AACT;AAEO,MAAM,qBAAqB,MAAM;AACtC,QAAM,gBAAgB,0BAA0B;AAChD,QAAM,mBAAe,yBAAW,2BAA2B;AAE3D,MAAI,iBAAiB,QAAW;AAC9B,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AAEA,SAAO,EAAE,GAAG,cAAc,GAAG,cAAc;AAC7C;","names":[]}

package/dist/cjs/index.cjs

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var index_exports = {};
+module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, require('./DictionariesRecordContext.cjs'), module.exports);
+__reExport(index_exports, require('./EditedContentContext.cjs'), module.exports);
+__reExport(index_exports, require('./FocusDictionaryContext.cjs'), module.exports);
+__reExport(index_exports, require('./EditorProvider.cjs'), module.exports);
+__reExport(index_exports, require('./useCrossFrameState.cjs'), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require('./DictionariesRecordContext.cjs'),
+  ...require('./EditedContentContext.cjs'),
+  ...require('./FocusDictionaryContext.cjs'),
+  ...require('./EditorProvider.cjs'),
+  ...require('./useCrossFrameState.cjs')
+});
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["export * from './DictionariesRecordContext';\nexport * from './EditedContentContext';\nexport * from './FocusDictionaryContext';\nexport * from './EditorProvider';\nexport * from './useCrossFrameState';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,0BAAc,wCAAd;AACA,0BAAc,mCADd;AAEA,0BAAc,qCAFd;AAGA,0BAAc,6BAHd;AAIA,0BAAc,iCAJd;","names":[]}

package/dist/cjs/useCrossFrameState.cjs

@@ -0,0 +1,66 @@
+"use strict";
+"use client";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useCrossFrameState_exports = {};
+__export(useCrossFrameState_exports, {
+  useCrossFrameState: () => useCrossFrameState
+});
+module.exports = __toCommonJS(useCrossFrameState_exports);
+var import_editor = require("@intlayer/editor");
+var import_react = require("react");
+var import_CommunicatorContext = require('./CommunicatorContext.cjs');
+const useCrossFrameState = (key, initialValue) => {
+  const props = (0, import_CommunicatorContext.useCommunicator)();
+  const communicatorRef = (0, import_react.useRef)();
+  (0, import_react.useEffect)(() => {
+    if (!props.targetWindow) return;
+    communicatorRef.current = new import_editor.CrossFrameCommunicator(
+      props
+    );
+    communicatorRef.current.on(key, (data) => {
+      setState(data);
+    });
+    return () => {
+      communicatorRef.current?.destroy();
+    };
+  }, [props, key]);
+  const [state, setState] = (0, import_react.useState)(() => {
+    if (typeof window === "undefined") {
+      return initialValue;
+    }
+    if (initialValue !== void 0) {
+      communicatorRef.current?.sendMessage(key, initialValue);
+      return initialValue;
+    }
+    return void 0;
+  });
+  const setStateResult = (valueOrUpdater) => {
+    setState((prev) => {
+      const newValue = typeof valueOrUpdater === "function" ? valueOrUpdater(prev) : valueOrUpdater;
+      communicatorRef.current?.sendMessage(key, newValue);
+      return newValue;
+    });
+  };
+  return [state ?? initialValue, setStateResult];
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useCrossFrameState
+});
+//# sourceMappingURL=useCrossFrameState.cjs.map

package/dist/cjs/useCrossFrameState.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/useCrossFrameState.tsx"],"sourcesContent":["'use client';\n\nimport {\n  CrossFrameCommunicator,\n  type CrossFrameCommunicatorOptions,\n} from '@intlayer/editor';\nimport { type SetStateAction, useEffect, useRef, useState } from 'react';\nimport { useCommunicator } from './CommunicatorContext';\n\nexport const useCrossFrameState = <T,>(key: string, initialValue?: T) => {\n  const props = useCommunicator();\n  const communicatorRef = useRef<CrossFrameCommunicator>();\n\n  useEffect(() => {\n    if (!props.targetWindow) return;\n\n    communicatorRef.current = new CrossFrameCommunicator(\n      props as CrossFrameCommunicatorOptions\n    );\n\n    communicatorRef.current.on(key, (data) => {\n      // When a message is received, update local state\n      setState(data as T);\n    });\n\n    return () => {\n      communicatorRef.current?.destroy();\n    };\n  }, [props, key]);\n\n  const [state, setState] = useState<T>(() => {\n    if (typeof window === 'undefined') {\n      return initialValue as T;\n    }\n\n    // If you have an initial value on the client, send a message out immediately\n    if (initialValue !== undefined) {\n      communicatorRef.current?.sendMessage(key, initialValue);\n      return initialValue;\n    }\n\n    return undefined as T;\n  });\n\n  /**\n   * Allows setting state either directly or via a functional update.\n   * If passed a function, we merge/update based on the previous state.\n   */\n  const setStateResult = (valueOrUpdater: SetStateAction<T>) => {\n    setState((prev) => {\n      const newValue: T =\n        typeof valueOrUpdater === 'function'\n          ? (valueOrUpdater as (prevVal: T) => T)(prev)\n          : valueOrUpdater;\n\n      communicatorRef.current?.sendMessage(key, newValue);\n      return newValue;\n    });\n  };\n\n  // If `state` is null/undefined but you have an `initialValue`,\n  // you could optionally do `(state ?? initialValue) as T`\n  return [state ?? (initialValue as T), setStateResult] as const;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,oBAGO;AACP,mBAAiE;AACjE,iCAAgC;AAEzB,MAAM,qBAAqB,CAAK,KAAa,iBAAqB;AACvE,QAAM,YAAQ,4CAAgB;AAC9B,QAAM,sBAAkB,qBAA+B;AAEvD,8BAAU,MAAM;AACd,QAAI,CAAC,MAAM,aAAc;AAEzB,oBAAgB,UAAU,IAAI;AAAA,MAC5B;AAAA,IACF;AAEA,oBAAgB,QAAQ,GAAG,KAAK,CAAC,SAAS;AAExC,eAAS,IAAS;AAAA,IACpB,CAAC;AAED,WAAO,MAAM;AACX,sBAAgB,SAAS,QAAQ;AAAA,IACnC;AAAA,EACF,GAAG,CAAC,OAAO,GAAG,CAAC;AAEf,QAAM,CAAC,OAAO,QAAQ,QAAI,uBAAY,MAAM;AAC1C,QAAI,OAAO,WAAW,aAAa;AACjC,aAAO;AAAA,IACT;AAGA,QAAI,iBAAiB,QAAW;AAC9B,sBAAgB,SAAS,YAAY,KAAK,YAAY;AACtD,aAAO;AAAA,IACT;AAEA,WAAO;AAAA,EACT,CAAC;AAMD,QAAM,iBAAiB,CAAC,mBAAsC;AAC5D,aAAS,CAAC,SAAS;AACjB,YAAM,WACJ,OAAO,mBAAmB,aACrB,eAAqC,IAAI,IAC1C;AAEN,sBAAgB,SAAS,YAAY,KAAK,QAAQ;AAClD,aAAO;AAAA,IACT,CAAC;AAAA,EACH;AAIA,SAAO,CAAC,SAAU,cAAoB,cAAc;AACtD;","names":[]}

package/dist/esm/CommunicatorContext.mjs

@@ -0,0 +1,18 @@
+import { jsx } from "react/jsx-runtime";
+import { createContext, useContext } from "react";
+const CommunicatorContext = createContext(void 0);
+const CommunicatorProvider = ({ children, ...props }) => /* @__PURE__ */ jsx(CommunicatorContext.Provider, { value: props, children });
+const useCommunicator = () => {
+  const context = useContext(CommunicatorContext);
+  if (!context) {
+    throw new Error(
+      "useCommunicator must be used within a CommunicatorProvider"
+    );
+  }
+  return context;
+};
+export {
+  CommunicatorProvider,
+  useCommunicator
+};
+//# sourceMappingURL=CommunicatorContext.mjs.map

package/dist/esm/CommunicatorContext.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/CommunicatorContext.tsx"],"sourcesContent":["import { createContext, useContext, FC, PropsWithChildren } from 'react';\n\nexport type UseCrossPlatformStateProps = {\n  targetWindow?: Window;\n  targetOrigin?: string;\n  allowedOrigins?: string[];\n};\n\nconst CommunicatorContext = createContext<\n  UseCrossPlatformStateProps | undefined\n>(undefined);\n\nexport const CommunicatorProvider: FC<\n  PropsWithChildren<UseCrossPlatformStateProps>\n> = ({ children, ...props }) => (\n  <CommunicatorContext.Provider value={props}>\n    {children}\n  </CommunicatorContext.Provider>\n);\n\nexport const useCommunicator = () => {\n  const context = useContext(CommunicatorContext);\n\n  if (!context) {\n    throw new Error(\n      'useCommunicator must be used within a CommunicatorProvider'\n    );\n  }\n  return context;\n};\n"],"mappings":"AAeE;AAfF,SAAS,eAAe,kBAAyC;AAQjE,MAAM,sBAAsB,cAE1B,MAAS;AAEJ,MAAM,uBAET,CAAC,EAAE,UAAU,GAAG,MAAM,MACxB,oBAAC,oBAAoB,UAApB,EAA6B,OAAO,OAClC,UACH;AAGK,MAAM,kBAAkB,MAAM;AACnC,QAAM,UAAU,WAAW,mBAAmB;AAE9C,MAAI,CAAC,SAAS;AACZ,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AACA,SAAO;AACT;","names":[]}

package/dist/esm/DictionariesRecordContext.mjs

@@ -0,0 +1,36 @@
+import { jsx } from "react/jsx-runtime";
+import { createContext, useContext } from "react";
+import { useCrossFrameState } from './useCrossFrameState.mjs';
+const DictionariesRecordContext = createContext(void 0);
+const DictionariesRecordProvider = ({
+  children
+}) => {
+  const [dictionariesRecord, setDictionariesRecordState] = useCrossFrameState("DICTIONARIES_RECORD_CHANGED", {});
+  const setDictionariesRecord = (newRecord) => {
+    setDictionariesRecordState((prev) => ({
+      ...prev,
+      ...newRecord
+    }));
+  };
+  return /* @__PURE__ */ jsx(
+    DictionariesRecordContext.Provider,
+    {
+      value: { dictionariesRecord, setDictionariesRecord },
+      children
+    }
+  );
+};
+const useDictionariesRecord = () => {
+  const context = useContext(DictionariesRecordContext);
+  if (!context) {
+    throw new Error(
+      "useDictionariesRecord must be used within a DictionariesRecordProvider"
+    );
+  }
+  return context;
+};
+export {
+  DictionariesRecordProvider,
+  useDictionariesRecord
+};
+//# sourceMappingURL=DictionariesRecordContext.mjs.map

package/dist/esm/DictionariesRecordContext.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/DictionariesRecordContext.tsx"],"sourcesContent":["import { type Dictionary } from '@intlayer/core';\nimport { createContext, useContext, FC, PropsWithChildren } from 'react';\nimport { useCrossFrameState } from './useCrossFrameState';\n\n// Types for our state\nexport type DictionaryContent = Record<Dictionary['key'], Dictionary>;\n\ntype DictionariesRecordContextType = {\n  dictionariesRecord: DictionaryContent;\n  setDictionariesRecord: (\n    dictionariesRecord: Record<Dictionary['key'], Dictionary>\n  ) => void;\n};\n\nconst DictionariesRecordContext = createContext<\n  DictionariesRecordContextType | undefined\n>(undefined);\n\nexport const DictionariesRecordProvider: FC<PropsWithChildren> = ({\n  children,\n}) => {\n  const [dictionariesRecord, setDictionariesRecordState] =\n    useCrossFrameState<DictionaryContent>('DICTIONARIES_RECORD_CHANGED', {});\n\n  const setDictionariesRecord = (newRecord: DictionaryContent) => {\n    // Here we merge the new record with the existing one:\n    setDictionariesRecordState((prev) => ({\n      ...prev,\n      ...newRecord,\n    }));\n  };\n\n  return (\n    <DictionariesRecordContext.Provider\n      value={{ dictionariesRecord, setDictionariesRecord }}\n    >\n      {children}\n    </DictionariesRecordContext.Provider>\n  );\n};\n\nexport const useDictionariesRecord = () => {\n  const context = useContext(DictionariesRecordContext);\n\n  if (!context) {\n    throw new Error(\n      'useDictionariesRecord must be used within a DictionariesRecordProvider'\n    );\n  }\n  return context;\n};\n"],"mappings":"AAiCI;AAhCJ,SAAS,eAAe,kBAAyC;AACjE,SAAS,0BAA0B;AAYnC,MAAM,4BAA4B,cAEhC,MAAS;AAEJ,MAAM,6BAAoD,CAAC;AAAA,EAChE;AACF,MAAM;AACJ,QAAM,CAAC,oBAAoB,0BAA0B,IACnD,mBAAsC,+BAA+B,CAAC,CAAC;AAEzE,QAAM,wBAAwB,CAAC,cAAiC;AAE9D,+BAA2B,CAAC,UAAU;AAAA,MACpC,GAAG;AAAA,MACH,GAAG;AAAA,IACL,EAAE;AAAA,EACJ;AAEA,SACE;AAAA,IAAC,0BAA0B;AAAA,IAA1B;AAAA,MACC,OAAO,EAAE,oBAAoB,sBAAsB;AAAA,MAElD;AAAA;AAAA,EACH;AAEJ;AAEO,MAAM,wBAAwB,MAAM;AACzC,QAAM,UAAU,WAAW,yBAAyB;AAEpD,MAAI,CAAC,SAAS;AACZ,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AACA,SAAO;AACT;","names":[]}

package/dist/esm/EditedContentContext.mjs

@@ -0,0 +1,173 @@
+import { jsx } from "react/jsx-runtime";
+import {
+  editDictionaryByKeyPath,
+  getDictionaryValueByKeyPath,
+  renameDictionaryValueByKeyPath
+} from "@intlayer/core";
+import { createContext, useContext } from "react";
+import {
+  useDictionariesRecord
+} from './DictionariesRecordContext.mjs';
+import { useCrossFrameState } from './useCrossFrameState.mjs';
+const EditedContentStateContext = createContext(void 0);
+const EditedContentActionsContext = createContext(void 0);
+const EditedContentProvider = ({ children }) => {
+  const { dictionariesRecord } = useDictionariesRecord();
+  const [editedContent, setEditedContentState] = useCrossFrameState("EDITED_CONTENT_CHANGED", {});
+  const setEditedContent = (dictionaryKey, newValue) => {
+    setEditedContentState((prev) => ({
+      ...prev,
+      [dictionaryKey]: {
+        ...prev[dictionaryKey],
+        content: newValue
+      }
+    }));
+  };
+  const addEditedContent = (dictionaryKey, newValue, keyPath = [], overwrite = true) => {
+    setEditedContentState((prev) => {
+      const originalContent = dictionariesRecord[dictionaryKey]?.content;
+      const currentContent = prev[dictionaryKey]?.content || JSON.parse(JSON.stringify(originalContent));
+      let newKeyPath = keyPath;
+      if (!overwrite) {
+        let index = 0;
+        const otherKeyPath = keyPath.slice(0, -1);
+        const lastKeyPath = keyPath[keyPath.length - 1];
+        let finalKey = lastKeyPath.key;
+        while (typeof getDictionaryValueByKeyPath(currentContent, newKeyPath) !== "undefined") {
+          index++;
+          finalKey = index === 0 ? lastKeyPath.key : `${lastKeyPath.key} (${index})`;
+          newKeyPath = [
+            ...otherKeyPath,
+            { ...lastKeyPath, key: finalKey }
+          ];
+        }
+      }
+      const updatedContent = editDictionaryByKeyPath(
+        currentContent,
+        newKeyPath,
+        newValue
+      );
+      return {
+        ...prev,
+        [dictionaryKey]: {
+          ...prev[dictionaryKey],
+          content: updatedContent
+        }
+      };
+    });
+  };
+  const renameEditedContent = (dictionaryKey, newKey, keyPath = []) => {
+    setEditedContentState((prev) => {
+      const originalContent = dictionariesRecord[dictionaryKey]?.content;
+      const currentContent = prev[dictionaryKey]?.content || JSON.parse(JSON.stringify(originalContent));
+      const contentWithNewField = renameDictionaryValueByKeyPath(
+        currentContent,
+        newKey,
+        keyPath
+      );
+      return {
+        ...prev,
+        [dictionaryKey]: {
+          ...prev[dictionaryKey],
+          content: contentWithNewField
+        }
+      };
+    });
+  };
+  const removeEditedContent = (dictionaryKey, keyPath) => {
+    setEditedContentState((prev) => {
+      const originalContent = dictionariesRecord[dictionaryKey]?.content;
+      const currentContent = prev[dictionaryKey]?.content || JSON.parse(JSON.stringify(originalContent));
+      const initialContent = getDictionaryValueByKeyPath(
+        originalContent,
+        keyPath
+      );
+      const restoredContent = editDictionaryByKeyPath(
+        currentContent,
+        keyPath,
+        initialContent
+      );
+      return {
+        ...prev,
+        [dictionaryKey]: {
+          ...prev[dictionaryKey],
+          content: restoredContent
+        }
+      };
+    });
+  };
+  const restoreEditedContent = (dictionaryKey) => {
+    setEditedContentState((prev) => {
+      const updated = { ...prev };
+      delete updated[dictionaryKey];
+      return updated;
+    });
+  };
+  const clearEditedDictionaryContent = (dictionaryKey) => {
+    setEditedContentState((prev) => {
+      const filtered = Object.entries(prev).reduce((acc, [key, value]) => {
+        if (key === dictionaryKey) {
+          return acc;
+        }
+        return { ...acc, [key]: value };
+      }, {});
+      return filtered;
+    });
+  };
+  const clearEditedContent = () => {
+    setEditedContentState({});
+  };
+  const getEditedContentValue = (dictionaryKey, keyPath) => {
+    const currentContent = editedContent[dictionaryKey]?.content || {};
+    return getDictionaryValueByKeyPath(currentContent, keyPath);
+  };
+  return /* @__PURE__ */ jsx(
+    EditedContentStateContext.Provider,
+    {
+      value: {
+        editedContent
+      },
+      children: /* @__PURE__ */ jsx(
+        EditedContentActionsContext.Provider,
+        {
+          value: {
+            setEditedContent,
+            addEditedContent,
+            renameEditedContent,
+            removeEditedContent,
+            restoreEditedContent,
+            clearEditedDictionaryContent,
+            clearEditedContent,
+            getEditedContentValue
+          },
+          children
+        }
+      )
+    }
+  );
+};
+const useEditedContentActions = () => {
+  const context = useContext(EditedContentActionsContext);
+  if (!context) {
+    throw new Error(
+      "useEditedContent must be used within an EditedContentActionsProvider"
+    );
+  }
+  return context;
+};
+const useEditedContent = () => {
+  const stateContext = useContext(EditedContentStateContext);
+  const actionContext = useEditedContentActions();
+  if (!stateContext) {
+    throw new Error(
+      "useEditedContent must be used within an EditedContentStateProvider"
+    );
+  }
+  return { ...stateContext, ...actionContext };
+};
+export {
+  EditedContentProvider,
+  useEditedContent,
+  useEditedContentActions
+};
+//# sourceMappingURL=EditedContentContext.mjs.map

package/dist/esm/EditedContentContext.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/EditedContentContext.tsx"],"sourcesContent":["import {\n  type Dictionary,\n  type DictionaryValue,\n  type KeyPath,\n  editDictionaryByKeyPath,\n  getDictionaryValueByKeyPath,\n  renameDictionaryValueByKeyPath,\n} from '@intlayer/core';\nimport { createContext, useContext, FC, PropsWithChildren } from 'react';\nimport {\n  DictionaryContent,\n  useDictionariesRecord,\n} from './DictionariesRecordContext';\nimport { useCrossFrameState } from './useCrossFrameState';\n\ntype EditedContentStateContextType = {\n  editedContent: DictionaryContent;\n};\n\nconst EditedContentStateContext = createContext<\n  EditedContentStateContextType | undefined\n>(undefined);\n\ntype EditedContentActionsContextType = {\n  setEditedContent: (\n    dictionaryKey: Dictionary['key'],\n    newValue: DictionaryValue\n  ) => void;\n  addEditedContent: (\n    dictionaryKey: Dictionary['key'],\n    newValue: DictionaryValue,\n    keyPath?: KeyPath[],\n    overwrite?: boolean\n  ) => void;\n  renameEditedContent: (\n    dictionaryKey: Dictionary['key'],\n    newKey: KeyPath['key'],\n    keyPath?: KeyPath[]\n  ) => void;\n  removeEditedContent: (\n    dictionaryKey: Dictionary['key'],\n    keyPath: KeyPath[]\n  ) => void;\n  restoreEditedContent: (dictionaryKey: Dictionary['key']) => void;\n  clearEditedDictionaryContent: (dictionaryKey: Dictionary['key']) => void;\n  clearEditedContent: () => void;\n  getEditedContentValue: (\n    dictionaryKey: Dictionary['key'],\n    keyPath: KeyPath[]\n  ) => DictionaryValue | undefined;\n};\n\nconst EditedContentActionsContext = createContext<\n  EditedContentActionsContextType | undefined\n>(undefined);\n\nexport const EditedContentProvider: FC<PropsWithChildren> = ({ children }) => {\n  const { dictionariesRecord } = useDictionariesRecord();\n  const [editedContent, setEditedContentState] =\n    useCrossFrameState<DictionaryContent>('EDITED_CONTENT_CHANGED', {});\n\n  const setEditedContent = (\n    dictionaryKey: Dictionary['key'],\n    newValue: DictionaryValue\n  ) => {\n    setEditedContentState((prev) => ({\n      ...prev,\n      [dictionaryKey]: {\n        ...prev[dictionaryKey],\n        content: newValue,\n      },\n    }));\n  };\n\n  const addEditedContent = (\n    dictionaryKey: Dictionary['key'],\n    newValue: DictionaryValue,\n    keyPath: KeyPath[] = [],\n    overwrite: boolean = true\n  ) => {\n    setEditedContentState((prev) => {\n      // Get the starting content: edited version if available, otherwise a deep copy of the original\n      const originalContent = dictionariesRecord[dictionaryKey]?.content;\n      const currentContent =\n        prev[dictionaryKey]?.content ||\n        JSON.parse(JSON.stringify(originalContent));\n\n      let newKeyPath = keyPath;\n      if (!overwrite) {\n        // Find a unique key based on the keyPath provided\n        let index = 0;\n        const otherKeyPath = keyPath.slice(0, -1);\n        const lastKeyPath: KeyPath = keyPath[keyPath.length - 1];\n        let finalKey = lastKeyPath.key;\n\n        // Loop until we find a key that does not exist\n        while (\n          typeof getDictionaryValueByKeyPath(currentContent, newKeyPath) !==\n          'undefined'\n        ) {\n          index++;\n          finalKey =\n            index === 0 ? lastKeyPath.key : `${lastKeyPath.key} (${index})`;\n          newKeyPath = [\n            ...otherKeyPath,\n            { ...lastKeyPath, key: finalKey } as KeyPath,\n          ];\n        }\n      }\n\n      const updatedContent = editDictionaryByKeyPath(\n        currentContent,\n        newKeyPath,\n        newValue\n      );\n\n      return {\n        ...prev,\n        [dictionaryKey]: {\n          ...prev[dictionaryKey],\n          content: updatedContent,\n        },\n      };\n    });\n  };\n\n  const renameEditedContent = (\n    dictionaryKey: Dictionary['key'],\n    newKey: KeyPath['key'],\n    keyPath: KeyPath[] = []\n  ) => {\n    setEditedContentState((prev) => {\n      // Retrieve the base content: use edited version if available, otherwise deep copy of original\n      const originalContent = dictionariesRecord[dictionaryKey]?.content;\n      const currentContent =\n        prev[dictionaryKey]?.content ||\n        JSON.parse(JSON.stringify(originalContent));\n\n      const contentWithNewField = renameDictionaryValueByKeyPath(\n        currentContent,\n        newKey,\n        keyPath\n      );\n\n      return {\n        ...prev,\n        [dictionaryKey]: {\n          ...prev[dictionaryKey],\n          content: contentWithNewField,\n        },\n      };\n    });\n  };\n\n  const removeEditedContent = (\n    dictionaryKey: Dictionary['key'],\n    keyPath: KeyPath[]\n  ) => {\n    setEditedContentState((prev) => {\n      // Retrieve the original content as reference\n      const originalContent = dictionariesRecord[dictionaryKey]?.content;\n      const currentContent =\n        prev[dictionaryKey]?.content ||\n        JSON.parse(JSON.stringify(originalContent));\n\n      // Get the initial value from the original dictionary content\n      const initialContent = getDictionaryValueByKeyPath(\n        originalContent,\n        keyPath\n      );\n\n      // Restore the value at the given keyPath\n      const restoredContent = editDictionaryByKeyPath(\n        currentContent,\n        keyPath,\n        initialContent\n      );\n\n      return {\n        ...prev,\n        [dictionaryKey]: {\n          ...prev[dictionaryKey],\n          content: restoredContent,\n        },\n      };\n    });\n  };\n\n  const restoreEditedContent = (dictionaryKey: Dictionary['key']) => {\n    setEditedContentState((prev) => {\n      const updated = { ...prev };\n      delete updated[dictionaryKey];\n      return updated;\n    });\n  };\n\n  const clearEditedDictionaryContent = (dictionaryKey: Dictionary['key']) => {\n    setEditedContentState((prev) => {\n      const filtered = Object.entries(prev).reduce((acc, [key, value]) => {\n        if (key === dictionaryKey) {\n          return acc;\n        }\n        return { ...acc, [key]: value };\n      }, {} as DictionaryContent);\n      return filtered;\n    });\n  };\n\n  const clearEditedContent = () => {\n    setEditedContentState({});\n  };\n\n  const getEditedContentValue = (\n    dictionaryKey: Dictionary['key'],\n    keyPath: KeyPath[]\n  ): DictionaryValue | undefined => {\n    const currentContent = editedContent[dictionaryKey]?.content || {};\n    return getDictionaryValueByKeyPath(currentContent, keyPath);\n  };\n\n  return (\n    <EditedContentStateContext.Provider\n      value={{\n        editedContent,\n      }}\n    >\n      <EditedContentActionsContext.Provider\n        value={{\n          setEditedContent,\n          addEditedContent,\n          renameEditedContent,\n          removeEditedContent,\n          restoreEditedContent,\n          clearEditedDictionaryContent,\n          clearEditedContent,\n          getEditedContentValue,\n        }}\n      >\n        {children}\n      </EditedContentActionsContext.Provider>\n    </EditedContentStateContext.Provider>\n  );\n};\n\nexport const useEditedContentActions = () => {\n  const context = useContext(EditedContentActionsContext);\n\n  if (!context) {\n    throw new Error(\n      'useEditedContent must be used within an EditedContentActionsProvider'\n    );\n  }\n\n  return context;\n};\n\nexport const useEditedContent = () => {\n  const stateContext = useContext(EditedContentStateContext);\n  const actionContext = useEditedContentActions();\n\n  if (!stateContext) {\n    throw new Error(\n      'useEditedContent must be used within an EditedContentStateProvider'\n    );\n  }\n\n  return { ...stateContext, ...actionContext };\n};\n"],"mappings":"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","names":[]}

package/dist/esm/EditorProvider.mjs

@@ -0,0 +1,12 @@
+import { jsx } from "react/jsx-runtime";
+import { DictionariesRecordProvider } from './DictionariesRecordContext.mjs';
+import { FocusDictionaryProvider } from './FocusDictionaryContext.mjs';
+import {
+  CommunicatorProvider
+} from './CommunicatorContext.mjs';
+import { EditedContentProvider } from './EditedContentContext.mjs';
+const EditorProvider = ({ children, ...props }) => /* @__PURE__ */ jsx(CommunicatorProvider, { ...props, children: /* @__PURE__ */ jsx(DictionariesRecordProvider, { children: /* @__PURE__ */ jsx(EditedContentProvider, { children: /* @__PURE__ */ jsx(FocusDictionaryProvider, { children }) }) }) });
+export {
+  EditorProvider
+};
+//# sourceMappingURL=EditorProvider.mjs.map

package/dist/esm/EditorProvider.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/EditorProvider.tsx"],"sourcesContent":["import { type FC, type PropsWithChildren } from 'react';\nimport { DictionariesRecordProvider } from './DictionariesRecordContext';\nimport { FocusDictionaryProvider } from './FocusDictionaryContext';\nimport {\n  CommunicatorProvider,\n  UseCrossPlatformStateProps,\n} from './CommunicatorContext';\nimport { EditedContentProvider } from './EditedContentContext';\n\nexport const EditorProvider: FC<\n  PropsWithChildren<UseCrossPlatformStateProps>\n> = ({ children, ...props }) => (\n  <CommunicatorProvider {...props}>\n    <DictionariesRecordProvider>\n      <EditedContentProvider>\n        <FocusDictionaryProvider>{children}</FocusDictionaryProvider>\n      </EditedContentProvider>\n    </DictionariesRecordProvider>\n  </CommunicatorProvider>\n);\n"],"mappings":"AAeQ;AAdR,SAAS,kCAAkC;AAC3C,SAAS,+BAA+B;AACxC;AAAA,EACE;AAAA,OAEK;AACP,SAAS,6BAA6B;AAE/B,MAAM,iBAET,CAAC,EAAE,UAAU,GAAG,MAAM,MACxB,oBAAC,wBAAsB,GAAG,OACxB,8BAAC,8BACC,8BAAC,yBACC,8BAAC,2BAAyB,UAAS,GACrC,GACF,GACF;","names":[]}

package/dist/esm/FocusDictionaryContext.mjs

@@ -0,0 +1,53 @@
+import { jsx } from "react/jsx-runtime";
+import { createContext, useContext } from "react";
+import { useCrossFrameState } from './useCrossFrameState.mjs';
+const FocusDictionaryStateContext = createContext(void 0);
+const FocusDictionaryActionsContext = createContext(void 0);
+const FocusDictionaryProvider = ({
+  children
+}) => {
+  const [focusedContent, setFocusedContentState] = useCrossFrameState("FOCUSED_CONTENT_CHANGED", null);
+  const setFocusedContent = (content) => {
+    setFocusedContentState(content);
+  };
+  const setFocusedContentKeyPath = (keyPath) => {
+    setFocusedContentState((prev) => {
+      if (!prev) {
+        return prev;
+      }
+      return { ...prev, keyPath };
+    });
+  };
+  return /* @__PURE__ */ jsx(FocusDictionaryStateContext.Provider, { value: { focusedContent }, children: /* @__PURE__ */ jsx(
+    FocusDictionaryActionsContext.Provider,
+    {
+      value: { setFocusedContent, setFocusedContentKeyPath },
+      children
+    }
+  ) });
+};
+const useFocusDictionaryActions = () => {
+  const context = useContext(FocusDictionaryActionsContext);
+  if (context === void 0) {
+    throw new Error(
+      "useFocusDictionaryActions must be used within a FocusDictionaryProvider"
+    );
+  }
+  return context;
+};
+const useFocusDictionary = () => {
+  const actionContext = useFocusDictionaryActions();
+  const stateContext = useContext(FocusDictionaryStateContext);
+  if (stateContext === void 0) {
+    throw new Error(
+      "useFocusDictionaryState must be used within a FocusDictionaryProvider"
+    );
+  }
+  return { ...stateContext, ...actionContext };
+};
+export {
+  FocusDictionaryProvider,
+  useFocusDictionary,
+  useFocusDictionaryActions
+};
+//# sourceMappingURL=FocusDictionaryContext.mjs.map

package/dist/esm/FocusDictionaryContext.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/FocusDictionaryContext.tsx"],"sourcesContent":["import type { KeyPath } from '@intlayer/core';\nimport { createContext, useContext, FC, PropsWithChildren } from 'react';\nimport { useCrossFrameState } from './useCrossFrameState';\n\ntype DictionaryPath = string;\n\nexport type FileContent = {\n  dictionaryKey: string;\n  keyPath?: KeyPath[];\n  dictionaryPath?: DictionaryPath;\n};\n\ninterface FocusDictionaryState {\n  focusedContent: FileContent | null;\n}\n\ninterface FocusDictionaryActions {\n  setFocusedContent: (content: FileContent | null) => void;\n  setFocusedContentKeyPath: (keyPath: KeyPath[]) => void;\n}\n\nconst FocusDictionaryStateContext = createContext<\n  FocusDictionaryState | undefined\n>(undefined);\nconst FocusDictionaryActionsContext = createContext<\n  FocusDictionaryActions | undefined\n>(undefined);\n\nexport const FocusDictionaryProvider: FC<PropsWithChildren> = ({\n  children,\n}) => {\n  const [focusedContent, setFocusedContentState] =\n    useCrossFrameState<FileContent | null>('FOCUSED_CONTENT_CHANGED', null);\n\n  const setFocusedContent = (content: FileContent | null) => {\n    setFocusedContentState(content);\n  };\n\n  const setFocusedContentKeyPath = (keyPath: KeyPath[]) => {\n    setFocusedContentState((prev) => {\n      if (!prev) {\n        return prev; // nothing to update if there's no focused content\n      }\n      return { ...prev, keyPath };\n    });\n  };\n\n  return (\n    <FocusDictionaryStateContext.Provider value={{ focusedContent }}>\n      <FocusDictionaryActionsContext.Provider\n        value={{ setFocusedContent, setFocusedContentKeyPath }}\n      >\n        {children}\n      </FocusDictionaryActionsContext.Provider>\n    </FocusDictionaryStateContext.Provider>\n  );\n};\n\nexport const useFocusDictionaryActions = () => {\n  const context = useContext(FocusDictionaryActionsContext);\n  if (context === undefined) {\n    throw new Error(\n      'useFocusDictionaryActions must be used within a FocusDictionaryProvider'\n    );\n  }\n  return context;\n};\n\nexport const useFocusDictionary = () => {\n  const actionContext = useFocusDictionaryActions();\n  const stateContext = useContext(FocusDictionaryStateContext);\n\n  if (stateContext === undefined) {\n    throw new Error(\n      'useFocusDictionaryState must be used within a FocusDictionaryProvider'\n    );\n  }\n\n  return { ...stateContext, ...actionContext };\n};\n"],"mappings":"AAiDM;AAhDN,SAAS,eAAe,kBAAyC;AACjE,SAAS,0BAA0B;AAmBnC,MAAM,8BAA8B,cAElC,MAAS;AACX,MAAM,gCAAgC,cAEpC,MAAS;AAEJ,MAAM,0BAAiD,CAAC;AAAA,EAC7D;AACF,MAAM;AACJ,QAAM,CAAC,gBAAgB,sBAAsB,IAC3C,mBAAuC,2BAA2B,IAAI;AAExE,QAAM,oBAAoB,CAAC,YAAgC;AACzD,2BAAuB,OAAO;AAAA,EAChC;AAEA,QAAM,2BAA2B,CAAC,YAAuB;AACvD,2BAAuB,CAAC,SAAS;AAC/B,UAAI,CAAC,MAAM;AACT,eAAO;AAAA,MACT;AACA,aAAO,EAAE,GAAG,MAAM,QAAQ;AAAA,IAC5B,CAAC;AAAA,EACH;AAEA,SACE,oBAAC,4BAA4B,UAA5B,EAAqC,OAAO,EAAE,eAAe,GAC5D;AAAA,IAAC,8BAA8B;AAAA,IAA9B;AAAA,MACC,OAAO,EAAE,mBAAmB,yBAAyB;AAAA,MAEpD;AAAA;AAAA,EACH,GACF;AAEJ;AAEO,MAAM,4BAA4B,MAAM;AAC7C,QAAM,UAAU,WAAW,6BAA6B;AACxD,MAAI,YAAY,QAAW;AACzB,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AACA,SAAO;AACT;AAEO,MAAM,qBAAqB,MAAM;AACtC,QAAM,gBAAgB,0BAA0B;AAChD,QAAM,eAAe,WAAW,2BAA2B;AAE3D,MAAI,iBAAiB,QAAW;AAC9B,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AAEA,SAAO,EAAE,GAAG,cAAc,GAAG,cAAc;AAC7C;","names":[]}

package/dist/esm/index.mjs

@@ -0,0 +1,6 @@
+export * from './DictionariesRecordContext.mjs';
+export * from './EditedContentContext.mjs';
+export * from './FocusDictionaryContext.mjs';
+export * from './EditorProvider.mjs';
+export * from './useCrossFrameState.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/esm/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["export * from './DictionariesRecordContext';\nexport * from './EditedContentContext';\nexport * from './FocusDictionaryContext';\nexport * from './EditorProvider';\nexport * from './useCrossFrameState';\n"],"mappings":"AAAA,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;","names":[]}

package/dist/esm/useCrossFrameState.mjs

@@ -0,0 +1,44 @@
+"use client";
+import {
+  CrossFrameCommunicator
+} from "@intlayer/editor";
+import { useEffect, useRef, useState } from "react";
+import { useCommunicator } from './CommunicatorContext.mjs';
+const useCrossFrameState = (key, initialValue) => {
+  const props = useCommunicator();
+  const communicatorRef = useRef();
+  useEffect(() => {
+    if (!props.targetWindow) return;
+    communicatorRef.current = new CrossFrameCommunicator(
+      props
+    );
+    communicatorRef.current.on(key, (data) => {
+      setState(data);
+    });
+    return () => {
+      communicatorRef.current?.destroy();
+    };
+  }, [props, key]);
+  const [state, setState] = useState(() => {
+    if (typeof window === "undefined") {
+      return initialValue;
+    }
+    if (initialValue !== void 0) {
+      communicatorRef.current?.sendMessage(key, initialValue);
+      return initialValue;
+    }
+    return void 0;
+  });
+  const setStateResult = (valueOrUpdater) => {
+    setState((prev) => {
+      const newValue = typeof valueOrUpdater === "function" ? valueOrUpdater(prev) : valueOrUpdater;
+      communicatorRef.current?.sendMessage(key, newValue);
+      return newValue;
+    });
+  };
+  return [state ?? initialValue, setStateResult];
+};
+export {
+  useCrossFrameState
+};
+//# sourceMappingURL=useCrossFrameState.mjs.map

package/dist/esm/useCrossFrameState.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/useCrossFrameState.tsx"],"sourcesContent":["'use client';\n\nimport {\n  CrossFrameCommunicator,\n  type CrossFrameCommunicatorOptions,\n} from '@intlayer/editor';\nimport { type SetStateAction, useEffect, useRef, useState } from 'react';\nimport { useCommunicator } from './CommunicatorContext';\n\nexport const useCrossFrameState = <T,>(key: string, initialValue?: T) => {\n  const props = useCommunicator();\n  const communicatorRef = useRef<CrossFrameCommunicator>();\n\n  useEffect(() => {\n    if (!props.targetWindow) return;\n\n    communicatorRef.current = new CrossFrameCommunicator(\n      props as CrossFrameCommunicatorOptions\n    );\n\n    communicatorRef.current.on(key, (data) => {\n      // When a message is received, update local state\n      setState(data as T);\n    });\n\n    return () => {\n      communicatorRef.current?.destroy();\n    };\n  }, [props, key]);\n\n  const [state, setState] = useState<T>(() => {\n    if (typeof window === 'undefined') {\n      return initialValue as T;\n    }\n\n    // If you have an initial value on the client, send a message out immediately\n    if (initialValue !== undefined) {\n      communicatorRef.current?.sendMessage(key, initialValue);\n      return initialValue;\n    }\n\n    return undefined as T;\n  });\n\n  /**\n   * Allows setting state either directly or via a functional update.\n   * If passed a function, we merge/update based on the previous state.\n   */\n  const setStateResult = (valueOrUpdater: SetStateAction<T>) => {\n    setState((prev) => {\n      const newValue: T =\n        typeof valueOrUpdater === 'function'\n          ? (valueOrUpdater as (prevVal: T) => T)(prev)\n          : valueOrUpdater;\n\n      communicatorRef.current?.sendMessage(key, newValue);\n      return newValue;\n    });\n  };\n\n  // If `state` is null/undefined but you have an `initialValue`,\n  // you could optionally do `(state ?? initialValue) as T`\n  return [state ?? (initialValue as T), setStateResult] as const;\n};\n"],"mappings":";AAEA;AAAA,EACE;AAAA,OAEK;AACP,SAA8B,WAAW,QAAQ,gBAAgB;AACjE,SAAS,uBAAuB;AAEzB,MAAM,qBAAqB,CAAK,KAAa,iBAAqB;AACvE,QAAM,QAAQ,gBAAgB;AAC9B,QAAM,kBAAkB,OAA+B;AAEvD,YAAU,MAAM;AACd,QAAI,CAAC,MAAM,aAAc;AAEzB,oBAAgB,UAAU,IAAI;AAAA,MAC5B;AAAA,IACF;AAEA,oBAAgB,QAAQ,GAAG,KAAK,CAAC,SAAS;AAExC,eAAS,IAAS;AAAA,IACpB,CAAC;AAED,WAAO,MAAM;AACX,sBAAgB,SAAS,QAAQ;AAAA,IACnC;AAAA,EACF,GAAG,CAAC,OAAO,GAAG,CAAC;AAEf,QAAM,CAAC,OAAO,QAAQ,IAAI,SAAY,MAAM;AAC1C,QAAI,OAAO,WAAW,aAAa;AACjC,aAAO;AAAA,IACT;AAGA,QAAI,iBAAiB,QAAW;AAC9B,sBAAgB,SAAS,YAAY,KAAK,YAAY;AACtD,aAAO;AAAA,IACT;AAEA,WAAO;AAAA,EACT,CAAC;AAMD,QAAM,iBAAiB,CAAC,mBAAsC;AAC5D,aAAS,CAAC,SAAS;AACjB,YAAM,WACJ,OAAO,mBAAmB,aACrB,eAAqC,IAAI,IAC1C;AAEN,sBAAgB,SAAS,YAAY,KAAK,QAAQ;AAClD,aAAO;AAAA,IACT,CAAC;AAAA,EACH;AAIA,SAAO,CAAC,SAAU,cAAoB,cAAc;AACtD;","names":[]}

package/dist/types/CommunicatorContext.d.ts

@@ -0,0 +1,9 @@
+import { FC, PropsWithChildren } from 'react';
+export type UseCrossPlatformStateProps = {
+    targetWindow?: Window;
+    targetOrigin?: string;
+    allowedOrigins?: string[];
+};
+export declare const CommunicatorProvider: FC<PropsWithChildren<UseCrossPlatformStateProps>>;
+export declare const useCommunicator: () => UseCrossPlatformStateProps;
+//# sourceMappingURL=CommunicatorContext.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CommunicatorContext.d.ts","sourceRoot":"","sources":["../../src/CommunicatorContext.tsx"],"names":[],"mappings":"AAAA,OAAO,EAA6B,EAAE,EAAE,iBAAiB,EAAE,MAAM,OAAO,CAAC;AAEzE,MAAM,MAAM,0BAA0B,GAAG;IACvC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;CAC3B,CAAC;AAMF,eAAO,MAAM,oBAAoB,EAAE,EAAE,CACnC,iBAAiB,CAAC,0BAA0B,CAAC,CAK9C,CAAC;AAEF,eAAO,MAAM,eAAe,kCAS3B,CAAC"}

package/dist/types/DictionariesRecordContext.d.ts

@@ -0,0 +1,11 @@
+import { type Dictionary } from '@intlayer/core';
+import { FC, PropsWithChildren } from 'react';
+export type DictionaryContent = Record<Dictionary['key'], Dictionary>;
+type DictionariesRecordContextType = {
+    dictionariesRecord: DictionaryContent;
+    setDictionariesRecord: (dictionariesRecord: Record<Dictionary['key'], Dictionary>) => void;
+};
+export declare const DictionariesRecordProvider: FC<PropsWithChildren>;
+export declare const useDictionariesRecord: () => DictionariesRecordContextType;
+export {};
+//# sourceMappingURL=DictionariesRecordContext.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DictionariesRecordContext.d.ts","sourceRoot":"","sources":["../../src/DictionariesRecordContext.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EAA6B,EAAE,EAAE,iBAAiB,EAAE,MAAM,OAAO,CAAC;AAIzE,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,UAAU,CAAC,CAAC;AAEtE,KAAK,6BAA6B,GAAG;IACnC,kBAAkB,EAAE,iBAAiB,CAAC;IACtC,qBAAqB,EAAE,CACrB,kBAAkB,EAAE,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,UAAU,CAAC,KACtD,IAAI,CAAC;CACX,CAAC;AAMF,eAAO,MAAM,0BAA0B,EAAE,EAAE,CAAC,iBAAiB,CAqB5D,CAAC;AAEF,eAAO,MAAM,qBAAqB,qCASjC,CAAC"}