camox 0.0.0 → 0.1.2-alpha.2

package/LICENSE.md

@@ -0,0 +1,110 @@
+# Functional Source License, Version 1.1, MIT Future License
+
+## Abbreviation
+
+FSL-1.1-MIT
+
+## Notice
+
+Copyright 2026 Rémi de Juvigny
+
+## Terms and Conditions
+
+### Licensor ("We")
+
+The party offering the Software under these Terms and Conditions.
+
+### The Software
+
+The "Software" is each version of the software that we make available under
+these Terms and Conditions, as indicated by our inclusion of these Terms and
+Conditions with the Software.
+
+### License Grant
+
+Subject to your compliance with this License Grant and the Patents,
+Redistribution and Trademark clauses below, we hereby grant you the right to
+use, copy, modify, create derivative works, publicly perform, publicly display
+and redistribute the Software for any Permitted Purpose identified below.
+
+### Permitted Purpose
+
+A Permitted Purpose is any purpose other than a Competing Use. A Competing Use
+means making the Software available to others in a commercial product or
+service that:
+
+1. substitutes for the Software;
+
+2. substitutes for any other product or service we offer using the Software
+   that exists as of the date we make the Software available; or
+
+3. offers the same or substantially similar functionality as the Software.
+
+Permitted Purposes specifically include using the Software:
+
+1. for your internal use and access;
+
+2. for non-commercial education;
+
+3. for non-commercial research; and
+
+4. in connection with professional services that you provide to a licensee
+   using the Software in accordance with these Terms and Conditions.
+
+### Patents
+
+To the extent your use for a Permitted Purpose would necessarily infringe our
+patents, the license grant above includes a license under our patents. If you
+make a claim against any party that the Software infringes or contributes to
+the infringement of any patent, then your patent license to the Software ends
+immediately.
+
+### Redistribution
+
+The Terms and Conditions apply to all copies, modifications and derivatives of
+the Software.
+
+If you redistribute any copies, modifications or derivatives of the Software,
+you must include a copy of or a link to these Terms and Conditions and not
+remove any copyright notices provided in or with the Software.
+
+### Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A PARTICULAR
+PURPOSE, MERCHANTABILITY, TITLE OR NON-INFRINGEMENT.
+
+IN NO EVENT WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO THE
+SOFTWARE, INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES,
+EVEN IF WE HAVE BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
+
+### Trademarks
+
+Except for displaying the License Details and identifying us as the origin of
+the Software, you have no right under these Terms and Conditions to use our
+trademarks, trade names, service marks or product names.
+
+## Grant of Future License
+
+We hereby irrevocably grant you an additional license to use the Software under
+the MIT license that is effective on the second anniversary of the date we make
+the Software available. On or after that date, you may use the Software under
+the MIT license, in which case the following will apply:
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/components/AuthGate.d.ts

@@ -0,0 +1,7 @@
+interface AuthGateProps {
+    authenticated: React.ReactNode;
+    unauthenticated: React.ReactNode;
+}
+export declare function AuthGate({ authenticated, unauthenticated }: AuthGateProps): import('react').ReactNode;
+export {};
+//# sourceMappingURL=AuthGate.d.ts.map

package/dist/components/AuthGate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AuthGate.d.ts","sourceRoot":"","sources":["../../src/components/AuthGate.tsx"],"names":[],"mappings":"AAEA,UAAU,aAAa;IACrB,aAAa,EAAE,KAAK,CAAC,SAAS,CAAC;IAC/B,eAAe,EAAE,KAAK,CAAC,SAAS,CAAC;CAClC;AAED,wBAAgB,QAAQ,CAAC,EAAE,aAAa,EAAE,eAAe,EAAE,EAAE,aAAa,6BAKzE"}

package/dist/core/components/AddBlockControlBar.d.ts

@@ -0,0 +1,9 @@
+interface AddBlockControlBarProps {
+    position: "top" | "bottom";
+    hidden: boolean;
+    onClick: () => void;
+    onMouseLeave: () => void;
+}
+export declare const AddBlockControlBar: ({ position, hidden, onClick, onMouseLeave, }: AddBlockControlBarProps) => import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=AddBlockControlBar.d.ts.map

package/dist/core/components/AddBlockControlBar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AddBlockControlBar.d.ts","sourceRoot":"","sources":["../../../src/core/components/AddBlockControlBar.tsx"],"names":[],"mappings":"AAIA,UAAU,uBAAuB;IAC/B,QAAQ,EAAE,KAAK,GAAG,QAAQ,CAAC;IAC3B,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,YAAY,EAAE,MAAM,IAAI,CAAC;CAC1B;AAED,eAAO,MAAM,kBAAkB,GAAI,8CAKhC,uBAAuB,4CAiEzB,CAAC"}

package/dist/core/components/AddBlockControlBar.js

@@ -0,0 +1,65 @@
+import { OVERLAY_COLORS } from "../../features/preview/overlayConstants.js";
+import * as React from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/core/components/AddBlockControlBar.tsx
+var AddBlockControlBar = ({ position, hidden, onClick, onMouseLeave }) => {
+	const [isExpanded, setIsExpanded] = React.useState(false);
+	return /* @__PURE__ */ jsx("div", {
+		style: {
+			position: "absolute",
+			top: position === "top" ? 0 : void 0,
+			bottom: position === "bottom" ? 0 : void 0,
+			left: "50%",
+			right: 0,
+			height: "36px",
+			transform: position === "top" ? "translateX(-50%) translateY(-50%)" : "translateX(-50%) translateY(50%)",
+			width: "fit-content",
+			display: "flex",
+			alignItems: "center",
+			justifyContent: "center",
+			zIndex: 11,
+			opacity: hidden ? 0 : 1,
+			pointerEvents: hidden ? "none" : "auto",
+			transition: "opacity 150ms ease"
+		},
+		onMouseLeave,
+		children: /* @__PURE__ */ jsx("div", {
+			style: {
+				width: "120px",
+				height: "36px",
+				display: "flex",
+				alignItems: "center",
+				justifyContent: "center"
+			},
+			onMouseEnter: () => setIsExpanded(true),
+			onMouseLeave: () => setIsExpanded(false),
+			children: /* @__PURE__ */ jsxs("button", {
+				style: {
+					display: "flex",
+					alignItems: "center",
+					gap: isExpanded ? "4px" : "0px",
+					padding: isExpanded ? "4px 8px" : "0px",
+					width: isExpanded ? "auto" : "20px",
+					height: isExpanded ? "auto" : "20px",
+					justifyContent: "center",
+					backgroundColor: OVERLAY_COLORS.selected,
+					color: "white",
+					border: "none",
+					borderRadius: "9999px",
+					fontSize: "12px",
+					fontWeight: 500,
+					cursor: "pointer",
+					whiteSpace: "nowrap",
+					transition: "all 150ms ease"
+				},
+				onClick,
+				children: [/* @__PURE__ */ jsx("span", {
+					style: { lineHeight: 1 },
+					children: "+"
+				}), isExpanded && /* @__PURE__ */ jsx("span", { children: "Add block" })]
+			})
+		})
+	});
+};
+//#endregion
+export { AddBlockControlBar };

package/dist/core/components/lexical/InlineContentEditable.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+/**
+ * A ContentEditable that renders a <span> instead of <div>,
+ * so it can be nested inside phrasing elements like <h1>, <p>, etc.
+ */
+export declare const InlineContentEditable: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLSpanElement> & React.RefAttributes<HTMLSpanElement>>;
+//# sourceMappingURL=InlineContentEditable.d.ts.map

package/dist/core/components/lexical/InlineContentEditable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InlineContentEditable.d.ts","sourceRoot":"","sources":["../../../../src/core/components/lexical/InlineContentEditable.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B;;;GAGG;AACH,eAAO,MAAM,qBAAqB,+GA6ChC,CAAC"}

package/dist/core/components/lexical/InlineContentEditable.js

@@ -0,0 +1,40 @@
+import * as React from "react";
+import { jsx } from "react/jsx-runtime";
+import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
+//#region src/core/components/lexical/InlineContentEditable.tsx
+/**
+* A ContentEditable that renders a <span> instead of <div>,
+* so it can be nested inside phrasing elements like <h1>, <p>, etc.
+*/
+var InlineContentEditable = React.forwardRef(function InlineContentEditable(props, ref) {
+	const [editor] = useLexicalComposerContext();
+	const [isEditable, setEditable] = React.useState(false);
+	const handleRef = React.useCallback((el) => {
+		if (el?.ownerDocument?.defaultView) editor.setRootElement(el);
+		else editor.setRootElement(null);
+	}, [editor]);
+	const mergedRef = React.useMemo(() => {
+		return (el) => {
+			handleRef(el);
+			if (typeof ref === "function") ref(el);
+			else if (ref) ref.current = el;
+		};
+	}, [handleRef, ref]);
+	React.useLayoutEffect(() => {
+		editor.setEditable(false);
+		return editor.registerEditableListener(setEditable);
+	}, [editor]);
+	const handleBlur = React.useCallback(() => {
+		editor.setEditable(false);
+	}, [editor]);
+	return /* @__PURE__ */ jsx("span", {
+		...props,
+		contentEditable: isEditable,
+		ref: mergedRef,
+		role: "textbox",
+		spellCheck: true,
+		onBlur: handleBlur
+	});
+});
+//#endregion
+export { InlineContentEditable };

package/dist/core/components/lexical/InlineLexicalEditor.d.ts

@@ -0,0 +1,12 @@
+import * as React from "react";
+interface InlineLexicalEditorProps {
+    initialState: string;
+    externalState: string;
+    onChange: (serialized: string) => void;
+    onFocus: () => void;
+    onBlur: () => void;
+    activateRef?: React.RefObject<(() => void) | null>;
+}
+export declare function InlineLexicalEditor({ initialState, externalState, onChange, onFocus, onBlur, activateRef, }: InlineLexicalEditorProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=InlineLexicalEditor.d.ts.map

package/dist/core/components/lexical/InlineLexicalEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InlineLexicalEditor.d.ts","sourceRoot":"","sources":["../../../../src/core/components/lexical/InlineLexicalEditor.tsx"],"names":[],"mappings":"AAOA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAM/B,UAAU,wBAAwB;IAChC,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,IAAI,CAAC;IACvC,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,WAAW,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;CACpD;AA0FD,wBAAgB,mBAAmB,CAAC,EAClC,YAAY,EACZ,aAAa,EACb,QAAQ,EACR,OAAO,EACP,MAAM,EACN,WAAW,GACZ,EAAE,wBAAwB,2CAsD1B"}

package/dist/core/components/lexical/InlineLexicalEditor.js

@@ -0,0 +1,133 @@
+import { createEditorConfig, normalizeLexicalState } from "./editorConfig.js";
+import { InlineContentEditable } from "./InlineContentEditable.js";
+import { SelectionBroadcaster } from "./SelectionBroadcaster.js";
+import { useFrame } from "@camox/ui/frame";
+import * as React from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { LexicalComposer } from "@lexical/react/LexicalComposer";
+import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
+import { OnChangePlugin } from "@lexical/react/LexicalOnChangePlugin";
+import { RichTextPlugin } from "@lexical/react/LexicalRichTextPlugin";
+import { COMMAND_PRIORITY_LOW, KEY_ESCAPE_COMMAND } from "lexical";
+//#region src/core/components/lexical/InlineLexicalEditor.tsx
+function ExternalStateSync({ externalState }) {
+	const [editor] = useLexicalComposerContext();
+	const isFocusedRef = React.useRef(false);
+	React.useEffect(() => {
+		return editor.registerRootListener((root) => {
+			if (!root) return;
+			const handleFocus = () => {
+				isFocusedRef.current = true;
+			};
+			const handleBlur = () => {
+				isFocusedRef.current = false;
+			};
+			root.addEventListener("focus", handleFocus);
+			root.addEventListener("blur", handleBlur);
+			return () => {
+				root.removeEventListener("focus", handleFocus);
+				root.removeEventListener("blur", handleBlur);
+			};
+		});
+	}, [editor]);
+	React.useEffect(() => {
+		if (isFocusedRef.current) return;
+		try {
+			const normalized = normalizeLexicalState(externalState);
+			const newState = editor.parseEditorState(normalized);
+			editor.setEditorState(newState);
+		} catch {}
+	}, [editor, externalState]);
+	return null;
+}
+function EscapeHandler() {
+	const [editor] = useLexicalComposerContext();
+	React.useEffect(() => {
+		return editor.registerCommand(KEY_ESCAPE_COMMAND, () => {
+			editor.getRootElement()?.blur();
+			return true;
+		}, COMMAND_PRIORITY_LOW);
+	}, [editor]);
+	return null;
+}
+function ActivateHandler({ activateRef }) {
+	const [editor] = useLexicalComposerContext();
+	React.useEffect(() => {
+		activateRef.current = () => {
+			editor.setEditable(true);
+			editor.focus();
+		};
+		return () => {
+			activateRef.current = null;
+		};
+	}, [editor, activateRef]);
+	return null;
+}
+function FocusBlurHandler({ onFocus, onBlur }) {
+	const [editor] = useLexicalComposerContext();
+	React.useEffect(() => {
+		return editor.registerRootListener((root) => {
+			if (!root) return;
+			root.addEventListener("focus", onFocus);
+			root.addEventListener("blur", onBlur);
+			return () => {
+				root.removeEventListener("focus", onFocus);
+				root.removeEventListener("blur", onBlur);
+			};
+		});
+	}, [
+		editor,
+		onFocus,
+		onBlur
+	]);
+	return null;
+}
+function InlineLexicalEditor({ initialState, externalState, onChange, onFocus, onBlur, activateRef }) {
+	const { window: iframeWindow } = useFrame();
+	const timerRef = React.useRef(null);
+	const isDirtyRef = React.useRef(false);
+	const config = React.useMemo(() => createEditorConfig(initialState), []);
+	const handleChange = React.useCallback((editorState) => {
+		if (!isDirtyRef.current) return;
+		if (timerRef.current) clearTimeout(timerRef.current);
+		timerRef.current = window.setTimeout(() => {
+			onChange(JSON.stringify(editorState.toJSON()));
+		}, 300);
+	}, [onChange]);
+	const handleFocus = React.useCallback(() => {
+		isDirtyRef.current = true;
+		onFocus();
+	}, [onFocus]);
+	const handleBlur = React.useCallback(() => {
+		isDirtyRef.current = false;
+		onBlur();
+	}, [onBlur]);
+	React.useEffect(() => {
+		return () => {
+			if (timerRef.current) clearTimeout(timerRef.current);
+		};
+	}, []);
+	return /* @__PURE__ */ jsxs(LexicalComposer, {
+		initialConfig: config,
+		children: [
+			/* @__PURE__ */ jsx(RichTextPlugin, {
+				contentEditable: /* @__PURE__ */ jsx(InlineContentEditable, { style: { outline: "none" } }),
+				ErrorBoundary: LexicalErrorBoundary
+			}),
+			/* @__PURE__ */ jsx(OnChangePlugin, { onChange: handleChange }),
+			/* @__PURE__ */ jsx(ExternalStateSync, { externalState }),
+			/* @__PURE__ */ jsx(EscapeHandler, {}),
+			activateRef && /* @__PURE__ */ jsx(ActivateHandler, { activateRef }),
+			/* @__PURE__ */ jsx(FocusBlurHandler, {
+				onFocus: handleFocus,
+				onBlur: handleBlur
+			}),
+			iframeWindow && /* @__PURE__ */ jsx(SelectionBroadcaster, { targetWindow: iframeWindow })
+		]
+	});
+}
+function LexicalErrorBoundary({ children }) {
+	return /* @__PURE__ */ jsx(Fragment, { children });
+}
+//#endregion
+export { InlineLexicalEditor };

package/dist/core/components/lexical/InlineParagraphNode.d.ts

@@ -0,0 +1,10 @@
+import { ParagraphNode, EditorConfig, SerializedParagraphNode } from 'lexical';
+export declare class InlineParagraphNode extends ParagraphNode {
+    static getType(): string;
+    static clone(node: InlineParagraphNode): InlineParagraphNode;
+    createDOM(_config: EditorConfig): HTMLElement;
+    updateDOM(): boolean;
+    static importJSON(serializedNode: SerializedParagraphNode): InlineParagraphNode;
+    exportJSON(): SerializedParagraphNode;
+}
+//# sourceMappingURL=InlineParagraphNode.d.ts.map

package/dist/core/components/lexical/InlineParagraphNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InlineParagraphNode.d.ts","sourceRoot":"","sources":["../../../../src/core/components/lexical/InlineParagraphNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,KAAK,YAAY,EAAE,KAAK,uBAAuB,EAAE,MAAM,SAAS,CAAC;AAEzF,qBAAa,mBAAoB,SAAQ,aAAa;IACpD,MAAM,CAAC,OAAO,IAAI,MAAM;IAIxB,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,mBAAmB,GAAG,mBAAmB;IAI5D,SAAS,CAAC,OAAO,EAAE,YAAY,GAAG,WAAW;IAO7C,SAAS,IAAI,OAAO;IAIpB,MAAM,CAAC,UAAU,CAAC,cAAc,EAAE,uBAAuB,GAAG,mBAAmB;IAQ/E,UAAU,IAAI,uBAAuB;CAMtC"}

package/dist/core/components/lexical/InlineParagraphNode.js

@@ -0,0 +1,34 @@
+import { ParagraphNode } from "lexical";
+//#region src/core/components/lexical/InlineParagraphNode.ts
+var InlineParagraphNode = class InlineParagraphNode extends ParagraphNode {
+	static getType() {
+		return "inline-paragraph";
+	}
+	static clone(node) {
+		return new InlineParagraphNode(node.__key);
+	}
+	createDOM(_config) {
+		const span = document.createElement("span");
+		const dir = this.getDirection();
+		if (dir) span.dir = dir;
+		return span;
+	}
+	updateDOM() {
+		return false;
+	}
+	static importJSON(serializedNode) {
+		const node = new InlineParagraphNode();
+		node.setDirection(serializedNode.direction);
+		node.setFormat(serializedNode.format);
+		node.setIndent(serializedNode.indent);
+		return node;
+	}
+	exportJSON() {
+		return {
+			...super.exportJSON(),
+			type: "inline-paragraph"
+		};
+	}
+};
+//#endregion
+export { InlineParagraphNode };

package/dist/core/components/lexical/SelectionBroadcaster.d.ts

@@ -0,0 +1,6 @@
+interface SelectionBroadcasterProps {
+    targetWindow: Window;
+}
+export declare function SelectionBroadcaster({ targetWindow }: SelectionBroadcasterProps): null;
+export {};
+//# sourceMappingURL=SelectionBroadcaster.d.ts.map

package/dist/core/components/lexical/SelectionBroadcaster.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SelectionBroadcaster.d.ts","sourceRoot":"","sources":["../../../../src/core/components/lexical/SelectionBroadcaster.tsx"],"names":[],"mappings":"AAQA,UAAU,yBAAyB;IACjC,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,wBAAgB,oBAAoB,CAAC,EAAE,YAAY,EAAE,EAAE,yBAAyB,QAwE/E"}

package/dist/core/components/lexical/SelectionBroadcaster.js

@@ -0,0 +1,62 @@
+import { isOverlayMessage, postOverlayMessage } from "../../../features/preview/overlayMessages.js";
+import { TEXT_MODIFIERS } from "../../lib/modifiers.js";
+import * as React from "react";
+import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
+import { $getSelection, $isRangeSelection, FORMAT_TEXT_COMMAND } from "lexical";
+//#region src/core/components/lexical/SelectionBroadcaster.tsx
+function SelectionBroadcaster({ targetWindow }) {
+	const [editor] = useLexicalComposerContext();
+	const broadcastSelection = React.useCallback(() => {
+		const nativeSelection = targetWindow.getSelection();
+		if (!(nativeSelection != null && nativeSelection.rangeCount > 0 && !nativeSelection.isCollapsed)) {
+			postOverlayMessage({
+				type: "CAMOX_TEXT_SELECTION_STATE",
+				hasSelection: false,
+				activeFormats: 0
+			});
+			return;
+		}
+		let format = 0;
+		editor.getEditorState().read(() => {
+			const selection = $getSelection();
+			if (!$isRangeSelection(selection)) return;
+			for (const modifier of Object.values(TEXT_MODIFIERS)) {
+				const key = modifier === TEXT_MODIFIERS.bold ? "bold" : "italic";
+				if (selection.hasFormat(key)) format |= modifier.formatFlag;
+			}
+		});
+		postOverlayMessage({
+			type: "CAMOX_TEXT_SELECTION_STATE",
+			hasSelection: true,
+			activeFormats: format
+		});
+	}, [editor, targetWindow]);
+	React.useEffect(() => {
+		const doc = targetWindow.document;
+		const handleSelectionChange = () => broadcastSelection();
+		doc.addEventListener("selectionchange", handleSelectionChange);
+		return () => doc.removeEventListener("selectionchange", handleSelectionChange);
+	}, [targetWindow, broadcastSelection]);
+	React.useEffect(() => {
+		const handleMessage = (event) => {
+			const data = event.data;
+			if (!isOverlayMessage(data) || data.type !== "CAMOX_FORMAT_TEXT") return;
+			const root = editor.getRootElement();
+			const nativeSelection = targetWindow.getSelection();
+			if (!root || !nativeSelection || nativeSelection.rangeCount === 0) return;
+			if (!root.contains(nativeSelection.anchorNode)) return;
+			root.focus();
+			editor.dispatchCommand(FORMAT_TEXT_COMMAND, data.formatKey);
+			setTimeout(broadcastSelection, 10);
+		};
+		targetWindow.addEventListener("message", handleMessage);
+		return () => targetWindow.removeEventListener("message", handleMessage);
+	}, [
+		editor,
+		targetWindow,
+		broadcastSelection
+	]);
+	return null;
+}
+//#endregion
+export { SelectionBroadcaster };

package/dist/core/components/lexical/SidebarLexicalEditor.d.ts

@@ -0,0 +1,9 @@
+interface SidebarLexicalEditorProps {
+    value: string;
+    onChange: (serialized: string) => void;
+    onFocus?: () => void;
+    onBlur?: () => void;
+}
+export declare function SidebarLexicalEditor({ value, onChange, onFocus, onBlur, }: SidebarLexicalEditorProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=SidebarLexicalEditor.d.ts.map

package/dist/core/components/lexical/SidebarLexicalEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SidebarLexicalEditor.d.ts","sourceRoot":"","sources":["../../../../src/core/components/lexical/SidebarLexicalEditor.tsx"],"names":[],"mappings":"AAYA,UAAU,yBAAyB;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,IAAI,CAAC;IACvC,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;CACrB;AAsCD,wBAAgB,oBAAoB,CAAC,EACnC,KAAK,EACL,QAAQ,EACR,OAAO,EACP,MAAM,GACP,EAAE,yBAAyB,2CA8C3B"}

package/dist/core/components/lexical/editorConfig.d.ts

@@ -0,0 +1,4 @@
+import { InitialConfigType } from '@lexical/react/LexicalComposer';
+export declare function normalizeLexicalState(value: string): string;
+export declare function createEditorConfig(initialState: string | undefined): InitialConfigType;
+//# sourceMappingURL=editorConfig.d.ts.map

package/dist/core/components/lexical/editorConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"editorConfig.d.ts","sourceRoot":"","sources":["../../../../src/core/components/lexical/editorConfig.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AAMxE,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAG3D;AAED,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,MAAM,GAAG,SAAS,GAAG,iBAAiB,CAgBtF"}

package/dist/core/components/lexical/editorConfig.js

@@ -0,0 +1,24 @@
+import { isLexicalState, plainTextToLexicalState } from "../../lib/lexicalState.js";
+import { InlineParagraphNode } from "./InlineParagraphNode.js";
+import { ParagraphNode } from "lexical";
+//#region src/core/components/lexical/editorConfig.ts
+function normalizeLexicalState(value) {
+	if (isLexicalState(value)) return value;
+	return plainTextToLexicalState(value);
+}
+function createEditorConfig(initialState) {
+	return {
+		namespace: "camox",
+		editorState: initialState ? normalizeLexicalState(initialState) : void 0,
+		onError: (error) => {
+			console.error("Lexical error:", error);
+		},
+		nodes: [InlineParagraphNode, {
+			replace: ParagraphNode,
+			with: () => new InlineParagraphNode(),
+			withKlass: InlineParagraphNode
+		}]
+	};
+}
+//#endregion
+export { createEditorConfig, normalizeLexicalState };