preact-intlayer 6.1.6 → 7.0.0-canary.3

package/dist/cjs/editor/useCrossFrameMessageListener.cjs

@@ -1,53 +1,76 @@
-"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 useCrossFrameMessageListener_exports = {};
-__export(useCrossFrameMessageListener_exports, {
-  useCrossFrameMessageListener: () => useCrossFrameMessageListener
-});
-module.exports = __toCommonJS(useCrossFrameMessageListener_exports);
-var import_editor = require("@intlayer/editor");
-var import_hooks = require("preact/hooks");
-var import_CommunicatorContext = require('./CommunicatorContext.cjs');
+'use client';
+
+
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_editor_CommunicatorContext = require('./CommunicatorContext.cjs');
+let __intlayer_editor = require("@intlayer/editor");
+__intlayer_editor = require_rolldown_runtime.__toESM(__intlayer_editor);
+let preact_hooks = require("preact/hooks");
+preact_hooks = require_rolldown_runtime.__toESM(preact_hooks);
+
+//#region src/editor/useCrossFrameMessageListener.tsx
+/**
+* useCrossFrameMessageListener
+*
+* This React hook listens for messages sent via the `postMessage` API and triggers a callback
+* whenever a message of the specified type (`key`) is received. It is useful for synchronizing
+* state or events across different windows, iframes, or contexts.
+*
+* @template S - The type of the data payload in the message.
+* @param key - A unique identifier for the message type to listen for.
+* @param [onEventTriggered] - A callback function triggered when a message
+* @param [revalidator] - A function that re-suscribes the listener. Could be usefull if onEventTriggered depend of some state
+* with the specified key is received. The callback receives the message data as its argument.
+*
+* @returns {{ postMessage: (data: S) => void }} An object containing a `postMessage` function
+* that allows broadcasting messages with the specified key and data.
+*/
 const useCrossFrameMessageListener = (key, onEventTriggered, revalidator) => {
-  const { allowedOrigins, postMessage, senderId } = (0, import_CommunicatorContext.useCommunicator)();
-  (0, import_hooks.useEffect)(() => {
-    if (onEventTriggered) {
-      const handleMessage = (event) => {
-        const { type, data, senderId: msgSenderId } = event.data;
-        if (type !== key) return;
-        if (msgSenderId === senderId) return;
-        if (typeof allowedOrigins === "undefined" || allowedOrigins?.some((url) => (0, import_editor.compareUrls)(url, event.origin)) || allowedOrigins?.includes("*")) {
-          onEventTriggered(data);
-        }
-      };
-      window.addEventListener("message", handleMessage);
-      return () => window.removeEventListener("message", handleMessage);
-    }
-  }, [allowedOrigins, postMessage, senderId, revalidator]);
-  const postMessageWrapper = (data) => {
-    postMessage({ type: key, data, senderId });
-  };
-  return postMessageWrapper;
+	const { allowedOrigins, postMessage, senderId } = require_editor_CommunicatorContext.useCommunicator();
+	(0, preact_hooks.useEffect)(() => {
+		if (onEventTriggered) {
+			/**
+			* Message handler to process incoming messages.
+			*
+			* - **Message Filtering:** Ensures only messages with the specified `key` are processed.
+			* - **Origin Validation:** Checks that the origin of the message is within the allowed origins.
+			*
+			* @param {MessageEvent<{ type: string; data: S }>} event - The incoming message event object.
+			*/
+			const handleMessage = (event) => {
+				const { type, data, senderId: msgSenderId } = event.data;
+				if (type !== key) return;
+				if (msgSenderId === senderId) return;
+				if (typeof allowedOrigins === "undefined" || allowedOrigins?.some((url) => (0, __intlayer_editor.compareUrls)(url, event.origin)) || allowedOrigins?.includes("*")) onEventTriggered(data);
+			};
+			window.addEventListener("message", handleMessage);
+			return () => window.removeEventListener("message", handleMessage);
+		}
+	}, [
+		allowedOrigins,
+		postMessage,
+		senderId,
+		revalidator
+	]);
+	/**
+	* A wrapper function around the `postMessage` function to broadcast messages efficiently.
+	*
+	* - **Encapsulation:** Ensures the `postMessage` function is scoped to the provided key.
+	* - **Ease of Use:** Simplifies broadcasting messages with consistent type and format.
+	*
+	* @param {S} data - The data payload to include in the message.
+	* @returns {void}
+	*/
+	const postMessageWrapper = (data) => {
+		postMessage({
+			type: key,
+			data,
+			senderId
+		});
+	};
+	return postMessageWrapper;
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  useCrossFrameMessageListener
-});
+
+//#endregion
+exports.useCrossFrameMessageListener = useCrossFrameMessageListener;
 //# sourceMappingURL=useCrossFrameMessageListener.cjs.map

package/dist/cjs/editor/useCrossFrameMessageListener.cjs.map

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

package/dist/cjs/editor/useCrossFrameState.cjs

@@ -1,77 +1,110 @@
-"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_hooks = require("preact/hooks");
-var import_CommunicatorContext = require('./CommunicatorContext.cjs');
-var import_useCrossFrameMessageListener = require('./useCrossFrameMessageListener.cjs');
+'use client';
+
+
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_editor_CommunicatorContext = require('./CommunicatorContext.cjs');
+const require_editor_useCrossFrameMessageListener = require('./useCrossFrameMessageListener.cjs');
+let preact_hooks = require("preact/hooks");
+preact_hooks = require_rolldown_runtime.__toESM(preact_hooks);
+
+//#region src/editor/useCrossFrameState.tsx
 const resolveState = (valueOrUpdater, prevState) => typeof valueOrUpdater === "function" ? valueOrUpdater(prevState) : valueOrUpdater;
+/**
+* Configuration options for `useCrossFrameState`.
+* @typedef {Object} CrossFrameStateOptions
+* @property {boolean} [emit=true] - Whether to broadcast state changes to other instances.
+* @property {boolean} [receive=true] - Whether to listen for state updates from other instances.
+*/
+/**
+* useCrossFrameState
+*
+* This Preact hook synchronizes state across multiple instances (e.g., different iframes or windows).
+* It uses the `postMessage` API to communicate state changes and updates between instances.
+*
+* @template S - The type of the state.
+* @param key - A unique identifier for the state to synchronize.
+* @param initialState - The initial state value or a function to compute it lazily.
+* @param options - Configuration options to control emitting and receiving messages.
+*   - `emit` (default: true): Whether to broadcast state changes to other instances.
+*   - `receive` (default: true): Whether to listen for state updates from other instances.
+*
+* @returns {[S, StateUpdater<S>, typeof postState]} An array containing the current state and a setter function, and a function to manually post the state.
+*/
 const useCrossFrameState = (key, initialState, options) => {
-  const { postMessage, senderId } = (0, import_CommunicatorContext.useCommunicator)();
-  const { emit, receive } = options ?? { emit: true, receive: true };
-  const handleStateChange = (valueOrUpdater, prevState) => {
-    const resolvedState = resolveState(valueOrUpdater, prevState);
-    if (emit && typeof postMessage === "function" && typeof resolvedState !== "undefined") {
-      postMessage({ type: `${key}/post`, data: resolvedState, senderId });
-    }
-    return resolvedState;
-  };
-  const postState = () => {
-    if (typeof postMessage !== "function") return;
-    postMessage({ type: `${key}/post`, data: state, senderId });
-  };
-  const [state, setState] = (0, import_hooks.useState)(() => handleStateChange(initialState));
-  const setStateWrapper = (valueOrUpdater) => setState((prevState) => handleStateChange(valueOrUpdater, prevState));
-  (0, import_useCrossFrameMessageListener.useCrossFrameMessageListener)(
-    `${key}/post`,
-    // Only activate the state listener if the `receive` option is true
-    receive ? (data) => {
-      setState(data);
-    } : void 0
-  );
-  const onGetMessage = (_, originSenderId) => {
-    if (!emit) return;
-    if (typeof postMessage !== "function") return;
-    if (originSenderId === senderId) return;
-    if (typeof state === "undefined") return;
-    postMessage({ type: `${key}/post`, data: state, senderId });
-  };
-  (0, import_useCrossFrameMessageListener.useCrossFrameMessageListener)(
-    `${key}/get`,
-    // Only activate the state listener if the `emit` option is true
-    emit ? onGetMessage : void 0,
-    state
-    // Revalidate the listener if the state changes
-  );
-  (0, import_hooks.useEffect)(() => {
-    if (receive && typeof postMessage === "function" && typeof state === "undefined") {
-      postMessage({ type: `${key}/get`, senderId });
-    }
-  }, []);
-  return [state, setStateWrapper, postState];
+	const { postMessage, senderId } = require_editor_CommunicatorContext.useCommunicator();
+	const { emit, receive } = options ?? {
+		emit: true,
+		receive: true
+	};
+	const handleStateChange = (valueOrUpdater, prevState) => {
+		const resolvedState = resolveState(valueOrUpdater, prevState);
+		if (emit && typeof postMessage === "function" && typeof resolvedState !== "undefined") postMessage({
+			type: `${key}/post`,
+			data: resolvedState,
+			senderId
+		});
+		return resolvedState;
+	};
+	const postState = () => {
+		if (typeof postMessage !== "function") return;
+		postMessage({
+			type: `${key}/post`,
+			data: state,
+			senderId
+		});
+	};
+	const [state, setState] = (0, preact_hooks.useState)(() => handleStateChange(initialState));
+	/**
+	* A wrapper function around the `setState` function to handle messaging efficiently.
+	*
+	* This approach has several advantages over using an additional `useEffect`:
+	* - **Avoid Redundant Re-renders:** By emitting the message directly within the `setState` logic,
+	*   it prevents the extra render cycle that would be triggered when using `useEffect`.
+	* - **Consistency:** Ensures the message is emitted immediately when the state is updated,
+	*   avoiding potential delays caused by the asynchronous nature of `useEffect`.
+	*
+	* This function keeps the same API as `setState` and is memoized using `useCallback`
+	* to prevent unnecessary re-renders of dependent components.
+	*
+	* @template S - The type of the state.
+	* @param {S | ((prevState: S) => S)} valueOrUpdater - The new state or a function to produce it.
+	* @returns {void}
+	*/
+	const setStateWrapper = (valueOrUpdater) => setState((prevState) => handleStateChange(valueOrUpdater, prevState));
+	/**
+	* Listen for messages with the specified key and update the state accordingly.
+	*/
+	require_editor_useCrossFrameMessageListener.useCrossFrameMessageListener(`${key}/post`, receive ? (data) => {
+		setState(data);
+	} : void 0);
+	const onGetMessage = (_, originSenderId) => {
+		if (!emit) return;
+		if (typeof postMessage !== "function") return;
+		if (originSenderId === senderId) return;
+		if (typeof state === "undefined") return;
+		postMessage({
+			type: `${key}/post`,
+			data: state,
+			senderId
+		});
+	};
+	/**
+	* Listen for messages request to get the state content and send it back.
+	*/
+	require_editor_useCrossFrameMessageListener.useCrossFrameMessageListener(`${key}/get`, emit ? onGetMessage : void 0, state);
+	(0, preact_hooks.useEffect)(() => {
+		if (receive && typeof postMessage === "function" && typeof state === "undefined") postMessage({
+			type: `${key}/get`,
+			senderId
+		});
+	}, []);
+	return [
+		state,
+		setStateWrapper,
+		postState
+	];
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  useCrossFrameState
-});
+
+//#endregion
+exports.useCrossFrameState = useCrossFrameState;
 //# sourceMappingURL=useCrossFrameState.cjs.map

package/dist/cjs/editor/useCrossFrameState.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/editor/useCrossFrameState.tsx"],"sourcesContent":["'use client';\n\nimport { type MessageKey } from '@intlayer/editor';\nimport { SetStateAction } from 'preact/compat';\nimport { Dispatch, useEffect, useState, type StateUpdater } from 'preact/hooks';\nimport { useCommunicator } from './CommunicatorContext';\nimport { useCrossFrameMessageListener } from './useCrossFrameMessageListener';\n\nexport type CrossFrameStateOptions = {\n  emit?: boolean;\n  receive?: boolean;\n};\n\nconst resolveState = <S,>(\n  valueOrUpdater?: S | ((prevState: S) => S),\n  prevState?: S\n): S =>\n  typeof valueOrUpdater === 'function'\n    ? (valueOrUpdater as (prevState?: S) => S)(prevState)\n    : (valueOrUpdater as S);\n\n/**\n * Configuration options for `useCrossFrameState`.\n * @typedef {Object} CrossFrameStateOptions\n * @property {boolean} [emit=true] - Whether to broadcast state changes to other instances.\n * @property {boolean} [receive=true] - Whether to listen for state updates from other instances.\n */\n\n/**\n * useCrossFrameState\n *\n * This Preact hook synchronizes state across multiple instances (e.g., different iframes or windows).\n * It uses the `postMessage` API to communicate state changes and updates between instances.\n *\n * @template S - The type of the state.\n * @param key - A unique identifier for the state to synchronize.\n * @param initialState - The initial state value or a function to compute it lazily.\n * @param options - Configuration options to control emitting and receiving messages.\n *   - `emit` (default: true): Whether to broadcast state changes to other instances.\n *   - `receive` (default: true): Whether to listen for state updates from other instances.\n *\n * @returns {[S, StateUpdater<S>, typeof postState]} An array containing the current state and a setter function, and a function to manually post the state.\n */\nexport const useCrossFrameState = <S,>(\n  key: `${MessageKey}`,\n  initialState?: S | (() => S),\n  options?: CrossFrameStateOptions\n): [S, Dispatch<SetStateAction<S>>, typeof postState] => {\n  const { postMessage, senderId } = useCommunicator();\n\n  const { emit, receive } = options ?? { emit: true, receive: true };\n\n  const handleStateChange = (\n    valueOrUpdater?: S | ((prevState: S) => S),\n    prevState?: S\n  ): S => {\n    // Initialize state from the provided initial value, if defined\n    const resolvedState: S = resolveState(valueOrUpdater, prevState);\n\n    // Emit the initial state if `emit` is enabled and initial state is defined\n    if (\n      emit &&\n      typeof postMessage === 'function' &&\n      typeof resolvedState !== 'undefined'\n    ) {\n      postMessage({ type: `${key}/post`, data: resolvedState, senderId });\n    }\n\n    return resolvedState;\n  };\n\n  const postState = () => {\n    if (typeof postMessage !== 'function') return;\n    postMessage({ type: `${key}/post`, data: state, senderId });\n  };\n\n  const [state, setState] = useState<S>(() => handleStateChange(initialState));\n\n  /**\n   * A wrapper function around the `setState` function to handle messaging efficiently.\n   *\n   * This approach has several advantages over using an additional `useEffect`:\n   * - **Avoid Redundant Re-renders:** By emitting the message directly within the `setState` logic,\n   *   it prevents the extra render cycle that would be triggered when using `useEffect`.\n   * - **Consistency:** Ensures the message is emitted immediately when the state is updated,\n   *   avoiding potential delays caused by the asynchronous nature of `useEffect`.\n   *\n   * This function keeps the same API as `setState` and is memoized using `useCallback`\n   * to prevent unnecessary re-renders of dependent components.\n   *\n   * @template S - The type of the state.\n   * @param {S | ((prevState: S) => S)} valueOrUpdater - The new state or a function to produce it.\n   * @returns {void}\n   */\n  const setStateWrapper: Dispatch<SetStateAction<S>> = (\n    valueOrUpdater: S | ((prevState: S) => S)\n  ) => setState((prevState) => handleStateChange(valueOrUpdater, prevState));\n\n  /**\n   * Listen for messages with the specified key and update the state accordingly.\n   */\n  useCrossFrameMessageListener<S>(\n    `${key}/post`,\n    // Only activate the state listener if the `receive` option is true\n    receive\n      ? (data) => {\n          setState(data);\n        }\n      : undefined\n  );\n\n  const onGetMessage = (_: unknown, originSenderId?: string) => {\n    if (!emit) return;\n    if (typeof postMessage !== 'function') return;\n    if (originSenderId === senderId) return;\n    if (typeof state === 'undefined') return;\n\n    postMessage({ type: `${key}/post`, data: state, senderId });\n  };\n\n  /**\n   * Listen for messages request to get the state content and send it back.\n   */\n  useCrossFrameMessageListener<S>(\n    `${key}/get`,\n    // Only activate the state listener if the `emit` option is true\n    emit ? onGetMessage : undefined,\n    state // Revalidate the listener if the state changes\n  );\n\n  useEffect(() => {\n    // If the component is mounted and the hook in receive mode,\n    // Request the state from the other instance\n    if (\n      receive &&\n      typeof postMessage === 'function' &&\n      typeof state === 'undefined'\n    ) {\n      postMessage({ type: `${key}/get`, senderId });\n    }\n  }, []);\n\n  // Return the useState state and setter\n  return [state, setStateWrapper, postState];\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAIA,mBAAiE;AACjE,iCAAgC;AAChC,0CAA6C;AAO7C,MAAM,eAAe,CACnB,gBACA,cAEA,OAAO,mBAAmB,aACrB,eAAwC,SAAS,IACjD;AAwBA,MAAM,qBAAqB,CAChC,KACA,cACA,YACuD;AACvD,QAAM,EAAE,aAAa,SAAS,QAAI,4CAAgB;AAElD,QAAM,EAAE,MAAM,QAAQ,IAAI,WAAW,EAAE,MAAM,MAAM,SAAS,KAAK;AAEjE,QAAM,oBAAoB,CACxB,gBACA,cACM;AAEN,UAAM,gBAAmB,aAAa,gBAAgB,SAAS;AAG/D,QACE,QACA,OAAO,gBAAgB,cACvB,OAAO,kBAAkB,aACzB;AACA,kBAAY,EAAE,MAAM,GAAG,GAAG,SAAS,MAAM,eAAe,SAAS,CAAC;AAAA,IACpE;AAEA,WAAO;AAAA,EACT;AAEA,QAAM,YAAY,MAAM;AACtB,QAAI,OAAO,gBAAgB,WAAY;AACvC,gBAAY,EAAE,MAAM,GAAG,GAAG,SAAS,MAAM,OAAO,SAAS,CAAC;AAAA,EAC5D;AAEA,QAAM,CAAC,OAAO,QAAQ,QAAI,uBAAY,MAAM,kBAAkB,YAAY,CAAC;AAkB3E,QAAM,kBAA+C,CACnD,mBACG,SAAS,CAAC,cAAc,kBAAkB,gBAAgB,SAAS,CAAC;AAKzE;AAAA,IACE,GAAG,GAAG;AAAA;AAAA,IAEN,UACI,CAAC,SAAS;AACR,eAAS,IAAI;AAAA,IACf,IACA;AAAA,EACN;AAEA,QAAM,eAAe,CAAC,GAAY,mBAA4B;AAC5D,QAAI,CAAC,KAAM;AACX,QAAI,OAAO,gBAAgB,WAAY;AACvC,QAAI,mBAAmB,SAAU;AACjC,QAAI,OAAO,UAAU,YAAa;AAElC,gBAAY,EAAE,MAAM,GAAG,GAAG,SAAS,MAAM,OAAO,SAAS,CAAC;AAAA,EAC5D;AAKA;AAAA,IACE,GAAG,GAAG;AAAA;AAAA,IAEN,OAAO,eAAe;AAAA,IACtB;AAAA;AAAA,EACF;AAEA,8BAAU,MAAM;AAGd,QACE,WACA,OAAO,gBAAgB,cACvB,OAAO,UAAU,aACjB;AACA,kBAAY,EAAE,MAAM,GAAG,GAAG,QAAQ,SAAS,CAAC;AAAA,IAC9C;AAAA,EACF,GAAG,CAAC,CAAC;AAGL,SAAO,CAAC,OAAO,iBAAiB,SAAS;AAC3C;","names":[]}
+{"version":3,"file":"useCrossFrameState.cjs","names":["useCommunicator","resolvedState: S","setStateWrapper: Dispatch<SetStateAction<S>>"],"sources":["../../../src/editor/useCrossFrameState.tsx"],"sourcesContent":["'use client';\n\nimport type { MessageKey } from '@intlayer/editor';\nimport type { SetStateAction } from 'preact/compat';\nimport {\n  type Dispatch,\n  type StateUpdater,\n  useEffect,\n  useState,\n} from 'preact/hooks';\nimport { useCommunicator } from './CommunicatorContext';\nimport { useCrossFrameMessageListener } from './useCrossFrameMessageListener';\n\nexport type CrossFrameStateOptions = {\n  emit?: boolean;\n  receive?: boolean;\n};\n\nconst resolveState = <S,>(\n  valueOrUpdater?: S | ((prevState: S) => S),\n  prevState?: S\n): S =>\n  typeof valueOrUpdater === 'function'\n    ? (valueOrUpdater as (prevState?: S) => S)(prevState)\n    : (valueOrUpdater as S);\n\n/**\n * Configuration options for `useCrossFrameState`.\n * @typedef {Object} CrossFrameStateOptions\n * @property {boolean} [emit=true] - Whether to broadcast state changes to other instances.\n * @property {boolean} [receive=true] - Whether to listen for state updates from other instances.\n */\n\n/**\n * useCrossFrameState\n *\n * This Preact hook synchronizes state across multiple instances (e.g., different iframes or windows).\n * It uses the `postMessage` API to communicate state changes and updates between instances.\n *\n * @template S - The type of the state.\n * @param key - A unique identifier for the state to synchronize.\n * @param initialState - The initial state value or a function to compute it lazily.\n * @param options - Configuration options to control emitting and receiving messages.\n *   - `emit` (default: true): Whether to broadcast state changes to other instances.\n *   - `receive` (default: true): Whether to listen for state updates from other instances.\n *\n * @returns {[S, StateUpdater<S>, typeof postState]} An array containing the current state and a setter function, and a function to manually post the state.\n */\nexport const useCrossFrameState = <S,>(\n  key: `${MessageKey}`,\n  initialState?: S | (() => S),\n  options?: CrossFrameStateOptions\n): [S, Dispatch<SetStateAction<S>>, typeof postState] => {\n  const { postMessage, senderId } = useCommunicator();\n\n  const { emit, receive } = options ?? { emit: true, receive: true };\n\n  const handleStateChange = (\n    valueOrUpdater?: S | ((prevState: S) => S),\n    prevState?: S\n  ): S => {\n    // Initialize state from the provided initial value, if defined\n    const resolvedState: S = resolveState(valueOrUpdater, prevState);\n\n    // Emit the initial state if `emit` is enabled and initial state is defined\n    if (\n      emit &&\n      typeof postMessage === 'function' &&\n      typeof resolvedState !== 'undefined'\n    ) {\n      postMessage({ type: `${key}/post`, data: resolvedState, senderId });\n    }\n\n    return resolvedState;\n  };\n\n  const postState = () => {\n    if (typeof postMessage !== 'function') return;\n    postMessage({ type: `${key}/post`, data: state, senderId });\n  };\n\n  const [state, setState] = useState<S>(() => handleStateChange(initialState));\n\n  /**\n   * A wrapper function around the `setState` function to handle messaging efficiently.\n   *\n   * This approach has several advantages over using an additional `useEffect`:\n   * - **Avoid Redundant Re-renders:** By emitting the message directly within the `setState` logic,\n   *   it prevents the extra render cycle that would be triggered when using `useEffect`.\n   * - **Consistency:** Ensures the message is emitted immediately when the state is updated,\n   *   avoiding potential delays caused by the asynchronous nature of `useEffect`.\n   *\n   * This function keeps the same API as `setState` and is memoized using `useCallback`\n   * to prevent unnecessary re-renders of dependent components.\n   *\n   * @template S - The type of the state.\n   * @param {S | ((prevState: S) => S)} valueOrUpdater - The new state or a function to produce it.\n   * @returns {void}\n   */\n  const setStateWrapper: Dispatch<SetStateAction<S>> = (\n    valueOrUpdater: S | ((prevState: S) => S)\n  ) => setState((prevState) => handleStateChange(valueOrUpdater, prevState));\n\n  /**\n   * Listen for messages with the specified key and update the state accordingly.\n   */\n  useCrossFrameMessageListener<S>(\n    `${key}/post`,\n    // Only activate the state listener if the `receive` option is true\n    receive\n      ? (data) => {\n          setState(data);\n        }\n      : undefined\n  );\n\n  const onGetMessage = (_: unknown, originSenderId?: string) => {\n    if (!emit) return;\n    if (typeof postMessage !== 'function') return;\n    if (originSenderId === senderId) return;\n    if (typeof state === 'undefined') return;\n\n    postMessage({ type: `${key}/post`, data: state, senderId });\n  };\n\n  /**\n   * Listen for messages request to get the state content and send it back.\n   */\n  useCrossFrameMessageListener<S>(\n    `${key}/get`,\n    // Only activate the state listener if the `emit` option is true\n    emit ? onGetMessage : undefined,\n    state // Revalidate the listener if the state changes\n  );\n\n  useEffect(() => {\n    // If the component is mounted and the hook in receive mode,\n    // Request the state from the other instance\n    if (\n      receive &&\n      typeof postMessage === 'function' &&\n      typeof state === 'undefined'\n    ) {\n      postMessage({ type: `${key}/get`, senderId });\n    }\n  }, []);\n\n  // Return the useState state and setter\n  return [state, setStateWrapper, postState];\n};\n"],"mappings":";;;;;;;;;;AAkBA,MAAM,gBACJ,gBACA,cAEA,OAAO,mBAAmB,aACrB,eAAwC,UAAU,GAClD;;;;;;;;;;;;;;;;;;;;;;AAwBP,MAAa,sBACX,KACA,cACA,YACuD;CACvD,MAAM,EAAE,aAAa,aAAaA,oDAAiB;CAEnD,MAAM,EAAE,MAAM,YAAY,WAAW;EAAE,MAAM;EAAM,SAAS;EAAM;CAElE,MAAM,qBACJ,gBACA,cACM;EAEN,MAAMC,gBAAmB,aAAa,gBAAgB,UAAU;AAGhE,MACE,QACA,OAAO,gBAAgB,cACvB,OAAO,kBAAkB,YAEzB,aAAY;GAAE,MAAM,GAAG,IAAI;GAAQ,MAAM;GAAe;GAAU,CAAC;AAGrE,SAAO;;CAGT,MAAM,kBAAkB;AACtB,MAAI,OAAO,gBAAgB,WAAY;AACvC,cAAY;GAAE,MAAM,GAAG,IAAI;GAAQ,MAAM;GAAO;GAAU,CAAC;;CAG7D,MAAM,CAAC,OAAO,6CAA8B,kBAAkB,aAAa,CAAC;;;;;;;;;;;;;;;;;CAkB5E,MAAMC,mBACJ,mBACG,UAAU,cAAc,kBAAkB,gBAAgB,UAAU,CAAC;;;;AAK1E,0EACE,GAAG,IAAI,QAEP,WACK,SAAS;AACR,WAAS,KAAK;KAEhB,OACL;CAED,MAAM,gBAAgB,GAAY,mBAA4B;AAC5D,MAAI,CAAC,KAAM;AACX,MAAI,OAAO,gBAAgB,WAAY;AACvC,MAAI,mBAAmB,SAAU;AACjC,MAAI,OAAO,UAAU,YAAa;AAElC,cAAY;GAAE,MAAM,GAAG,IAAI;GAAQ,MAAM;GAAO;GAAU,CAAC;;;;;AAM7D,0EACE,GAAG,IAAI,OAEP,OAAO,eAAe,QACtB,MACD;AAED,mCAAgB;AAGd,MACE,WACA,OAAO,gBAAgB,cACvB,OAAO,UAAU,YAEjB,aAAY;GAAE,MAAM,GAAG,IAAI;GAAO;GAAU,CAAC;IAE9C,EAAE,CAAC;AAGN,QAAO;EAAC;EAAO;EAAiB;EAAU"}

package/dist/cjs/editor/useCrossURLPathState.cjs

@@ -1,69 +1,70 @@
-"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 useCrossURLPathState_exports = {};
-__export(useCrossURLPathState_exports, {
-  useCrossURLPathSetter: () => useCrossURLPathSetter,
-  useCrossURLPathState: () => useCrossURLPathState
-});
-module.exports = __toCommonJS(useCrossURLPathState_exports);
-var import_editor = require("@intlayer/editor");
-var import_hooks = require("preact/hooks");
-var import_useCrossFrameState = require('./useCrossFrameState.cjs');
-const useCrossURLPathState = (initialState, options) => (0, import_useCrossFrameState.useCrossFrameState)(import_editor.MessageKey.INTLAYER_URL_CHANGE, initialState, options);
+'use client';
+
+
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_editor_useCrossFrameState = require('./useCrossFrameState.cjs');
+let __intlayer_editor = require("@intlayer/editor");
+__intlayer_editor = require_rolldown_runtime.__toESM(__intlayer_editor);
+let preact_hooks = require("preact/hooks");
+preact_hooks = require_rolldown_runtime.__toESM(preact_hooks);
+
+//#region src/editor/useCrossURLPathState.tsx
+const useCrossURLPathState = (initialState, options) => require_editor_useCrossFrameState.useCrossFrameState(__intlayer_editor.MessageKey.INTLAYER_URL_CHANGE, initialState, options);
 const useCrossURLPathSetter = (initialState) => {
-  const states = useCrossURLPathState(initialState, {
-    emit: true,
-    receive: false
-  });
-  const [_state, setState] = states;
-  (0, import_hooks.useEffect)(() => {
-    const originalPushState = history.pushState;
-    const originalReplaceState = history.replaceState;
-    const injectLocationChangeEvent = (method) => function(...args) {
-      method.apply(this, args);
-      window.dispatchEvent(new Event("locationchange"));
-    };
-    history.pushState = injectLocationChangeEvent(originalPushState);
-    history.replaceState = injectLocationChangeEvent(originalReplaceState);
-    const updateURLState = () => {
-      setState(window.location.pathname);
-    };
-    window.addEventListener("locationchange", updateURLState);
-    window.addEventListener("popstate", updateURLState);
-    window.addEventListener("hashchange", updateURLState);
-    window.addEventListener("load", updateURLState);
-    updateURLState();
-    return () => {
-      window.removeEventListener("locationchange", updateURLState);
-      window.removeEventListener("popstate", updateURLState);
-      window.removeEventListener("hashchange", updateURLState);
-      window.removeEventListener("load", updateURLState);
-      history.pushState = originalPushState;
-      history.replaceState = originalReplaceState;
-    };
-  }, []);
-  return states;
+	const states = useCrossURLPathState(initialState, {
+		emit: true,
+		receive: false
+	});
+	const [_state, setState] = states;
+	(0, preact_hooks.useEffect)(() => {
+		/**
+		* 1) Monkey patch history methods (pushState, replaceState)
+		*    to dispatch a custom event whenever they are called.
+		*/
+		const originalPushState = history.pushState;
+		const originalReplaceState = history.replaceState;
+		const injectLocationChangeEvent = (method) => function(...args) {
+			method.apply(this, args);
+			window.dispatchEvent(new Event("locationchange"));
+		};
+		history.pushState = injectLocationChangeEvent(originalPushState);
+		history.replaceState = injectLocationChangeEvent(originalReplaceState);
+		/**
+		* 2) The callback to update our state whenever the URL changes.
+		*/
+		const updateURLState = () => {
+			setState(window.location.pathname);
+		};
+		/**
+		* 3) Attach event listeners for locationchange, popstate, hashchange.
+		*    - 'locationchange' is our custom event triggered by push/replaceState overrides.
+		*    - 'popstate' is fired on back/forward navigation.
+		*    - 'hashchange' is for URL hash (#) changes.
+		*    - 'load' is when new page is loaded
+		*/
+		window.addEventListener("locationchange", updateURLState);
+		window.addEventListener("popstate", updateURLState);
+		window.addEventListener("hashchange", updateURLState);
+		window.addEventListener("load", updateURLState);
+		updateURLState();
+		/**
+		* 4) Cleanup when the component unmounts:
+		*    - Remove event listeners.
+		*    - Restore original pushState & replaceState to avoid side effects.
+		*/
+		return () => {
+			window.removeEventListener("locationchange", updateURLState);
+			window.removeEventListener("popstate", updateURLState);
+			window.removeEventListener("hashchange", updateURLState);
+			window.removeEventListener("load", updateURLState);
+			history.pushState = originalPushState;
+			history.replaceState = originalReplaceState;
+		};
+	}, []);
+	return states;
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  useCrossURLPathSetter,
-  useCrossURLPathState
-});
+
+//#endregion
+exports.useCrossURLPathSetter = useCrossURLPathSetter;
+exports.useCrossURLPathState = useCrossURLPathState;
 //# sourceMappingURL=useCrossURLPathState.cjs.map

package/dist/cjs/editor/useCrossURLPathState.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/editor/useCrossURLPathState.tsx"],"sourcesContent":["'use client';\n\nimport { MessageKey } from '@intlayer/editor';\nimport { useEffect } from 'preact/hooks';\nimport {\n  useCrossFrameState,\n  type CrossFrameStateOptions,\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  const states = useCrossURLPathState(initialState, {\n    emit: true,\n    receive: false,\n  });\n  const [_state, setState] = states;\n\n  useEffect(() => {\n    /**\n     * 1) Monkey patch history methods (pushState, replaceState)\n     *    to dispatch a custom event whenever they are called.\n     */\n    const originalPushState = history.pushState;\n    const originalReplaceState = history.replaceState;\n\n    const injectLocationChangeEvent = (method: (...args: any[]) => void) =>\n      function (this: typeof history, ...args: [any, string, string?]) {\n        method.apply(this, args);\n        window.dispatchEvent(new Event('locationchange'));\n      };\n\n    history.pushState = injectLocationChangeEvent(originalPushState);\n    history.replaceState = injectLocationChangeEvent(originalReplaceState);\n\n    /**\n     * 2) The callback to update our state whenever the URL changes.\n     */\n    const updateURLState = () => {\n      setState(window.location.pathname);\n    };\n\n    /**\n     * 3) Attach event listeners for locationchange, popstate, hashchange.\n     *    - 'locationchange' is our custom event triggered by push/replaceState overrides.\n     *    - 'popstate' is fired on back/forward navigation.\n     *    - 'hashchange' is for URL hash (#) changes.\n     *    - 'load' is when new page is loaded\n     */\n    window.addEventListener('locationchange', updateURLState);\n    window.addEventListener('popstate', updateURLState);\n    window.addEventListener('hashchange', updateURLState);\n    window.addEventListener('load', updateURLState);\n\n    // Initialize our state immediately on mount\n    updateURLState();\n\n    /**\n     * 4) Cleanup when the component unmounts:\n     *    - Remove event listeners.\n     *    - Restore original pushState & replaceState to avoid side effects.\n     */\n    return () => {\n      window.removeEventListener('locationchange', updateURLState);\n      window.removeEventListener('popstate', updateURLState);\n      window.removeEventListener('hashchange', updateURLState);\n      window.removeEventListener('load', updateURLState);\n      history.pushState = originalPushState;\n      history.replaceState = originalReplaceState;\n    };\n  }, []);\n\n  return states;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,oBAA2B;AAC3B,mBAA0B;AAC1B,gCAGO;AAEA,MAAM,uBAAuB,CAClC,cACA,gBACG,8CAAmB,yBAAW,qBAAqB,cAAc,OAAO;AAEtE,MAAM,wBAAwB,CAAC,iBAA0B;AAC9D,QAAM,SAAS,qBAAqB,cAAc;AAAA,IAChD,MAAM;AAAA,IACN,SAAS;AAAA,EACX,CAAC;AACD,QAAM,CAAC,QAAQ,QAAQ,IAAI;AAE3B,8BAAU,MAAM;AAKd,UAAM,oBAAoB,QAAQ;AAClC,UAAM,uBAAuB,QAAQ;AAErC,UAAM,4BAA4B,CAAC,WACjC,YAAmC,MAA8B;AAC/D,aAAO,MAAM,MAAM,IAAI;AACvB,aAAO,cAAc,IAAI,MAAM,gBAAgB,CAAC;AAAA,IAClD;AAEF,YAAQ,YAAY,0BAA0B,iBAAiB;AAC/D,YAAQ,eAAe,0BAA0B,oBAAoB;AAKrE,UAAM,iBAAiB,MAAM;AAC3B,eAAS,OAAO,SAAS,QAAQ;AAAA,IACnC;AASA,WAAO,iBAAiB,kBAAkB,cAAc;AACxD,WAAO,iBAAiB,YAAY,cAAc;AAClD,WAAO,iBAAiB,cAAc,cAAc;AACpD,WAAO,iBAAiB,QAAQ,cAAc;AAG9C,mBAAe;AAOf,WAAO,MAAM;AACX,aAAO,oBAAoB,kBAAkB,cAAc;AAC3D,aAAO,oBAAoB,YAAY,cAAc;AACrD,aAAO,oBAAoB,cAAc,cAAc;AACvD,aAAO,oBAAoB,QAAQ,cAAc;AACjD,cAAQ,YAAY;AACpB,cAAQ,eAAe;AAAA,IACzB;AAAA,EACF,GAAG,CAAC,CAAC;AAEL,SAAO;AACT;","names":[]}
+{"version":3,"file":"useCrossURLPathState.cjs","names":["useCrossFrameState","MessageKey"],"sources":["../../../src/editor/useCrossURLPathState.tsx"],"sourcesContent":["'use client';\n\nimport { MessageKey } from '@intlayer/editor';\nimport { useEffect } from 'preact/hooks';\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  const states = useCrossURLPathState(initialState, {\n    emit: true,\n    receive: false,\n  });\n  const [_state, setState] = states;\n\n  useEffect(() => {\n    /**\n     * 1) Monkey patch history methods (pushState, replaceState)\n     *    to dispatch a custom event whenever they are called.\n     */\n    const originalPushState = history.pushState;\n    const originalReplaceState = history.replaceState;\n\n    const injectLocationChangeEvent = (method: (...args: any[]) => void) =>\n      function (this: typeof history, ...args: [any, string, string?]) {\n        method.apply(this, args);\n        window.dispatchEvent(new Event('locationchange'));\n      };\n\n    history.pushState = injectLocationChangeEvent(originalPushState);\n    history.replaceState = injectLocationChangeEvent(originalReplaceState);\n\n    /**\n     * 2) The callback to update our state whenever the URL changes.\n     */\n    const updateURLState = () => {\n      setState(window.location.pathname);\n    };\n\n    /**\n     * 3) Attach event listeners for locationchange, popstate, hashchange.\n     *    - 'locationchange' is our custom event triggered by push/replaceState overrides.\n     *    - 'popstate' is fired on back/forward navigation.\n     *    - 'hashchange' is for URL hash (#) changes.\n     *    - 'load' is when new page is loaded\n     */\n    window.addEventListener('locationchange', updateURLState);\n    window.addEventListener('popstate', updateURLState);\n    window.addEventListener('hashchange', updateURLState);\n    window.addEventListener('load', updateURLState);\n\n    // Initialize our state immediately on mount\n    updateURLState();\n\n    /**\n     * 4) Cleanup when the component unmounts:\n     *    - Remove event listeners.\n     *    - Restore original pushState & replaceState to avoid side effects.\n     */\n    return () => {\n      window.removeEventListener('locationchange', updateURLState);\n      window.removeEventListener('popstate', updateURLState);\n      window.removeEventListener('hashchange', updateURLState);\n      window.removeEventListener('load', updateURLState);\n      history.pushState = originalPushState;\n      history.replaceState = originalReplaceState;\n    };\n  }, []);\n\n  return states;\n};\n"],"mappings":";;;;;;;;;;;AASA,MAAa,wBACX,cACA,YACGA,qDAAmBC,6BAAW,qBAAqB,cAAc,QAAQ;AAE9E,MAAa,yBAAyB,iBAA0B;CAC9D,MAAM,SAAS,qBAAqB,cAAc;EAChD,MAAM;EACN,SAAS;EACV,CAAC;CACF,MAAM,CAAC,QAAQ,YAAY;AAE3B,mCAAgB;;;;;EAKd,MAAM,oBAAoB,QAAQ;EAClC,MAAM,uBAAuB,QAAQ;EAErC,MAAM,6BAA6B,WACjC,SAAgC,GAAG,MAA8B;AAC/D,UAAO,MAAM,MAAM,KAAK;AACxB,UAAO,cAAc,IAAI,MAAM,iBAAiB,CAAC;;AAGrD,UAAQ,YAAY,0BAA0B,kBAAkB;AAChE,UAAQ,eAAe,0BAA0B,qBAAqB;;;;EAKtE,MAAM,uBAAuB;AAC3B,YAAS,OAAO,SAAS,SAAS;;;;;;;;;AAUpC,SAAO,iBAAiB,kBAAkB,eAAe;AACzD,SAAO,iBAAiB,YAAY,eAAe;AACnD,SAAO,iBAAiB,cAAc,eAAe;AACrD,SAAO,iBAAiB,QAAQ,eAAe;AAG/C,kBAAgB;;;;;;AAOhB,eAAa;AACX,UAAO,oBAAoB,kBAAkB,eAAe;AAC5D,UAAO,oBAAoB,YAAY,eAAe;AACtD,UAAO,oBAAoB,cAAc,eAAe;AACxD,UAAO,oBAAoB,QAAQ,eAAe;AAClD,WAAQ,YAAY;AACpB,WAAQ,eAAe;;IAExB,EAAE,CAAC;AAEN,QAAO"}