automerge-lexical 0.1.0

package/README.md

@@ -0,0 +1,75 @@
+# React + TypeScript + Vite
+
+This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
+
+Currently, two official plugins are available:
+
+- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react) uses [Oxc](https://oxc.rs)
+- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react-swc) uses [SWC](https://swc.rs/)
+
+## React Compiler
+
+The React Compiler is not enabled on this template because of its impact on dev & build performances. To add it, see [this documentation](https://react.dev/learn/react-compiler/installation).
+
+## Expanding the ESLint configuration
+
+If you are developing a production application, we recommend updating the configuration to enable type-aware lint rules:
+
+```js
+export default defineConfig([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{ts,tsx}'],
+    extends: [
+      // Other configs...
+
+      // Remove tseslint.configs.recommended and replace with this
+      tseslint.configs.recommendedTypeChecked,
+      // Alternatively, use this for stricter rules
+      tseslint.configs.strictTypeChecked,
+      // Optionally, add this for stylistic rules
+      tseslint.configs.stylisticTypeChecked,
+
+      // Other configs...
+    ],
+    languageOptions: {
+      parserOptions: {
+        project: ['./tsconfig.node.json', './tsconfig.app.json'],
+        tsconfigRootDir: import.meta.dirname,
+      },
+      // other options...
+    },
+  },
+])
+
+```
+
+You can also install [eslint-plugin-react-x](https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-x) and [eslint-plugin-react-dom](https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-dom) for React-specific lint rules:
+
+```js
+// eslint.config.js
+import reactX from 'eslint-plugin-react-x'
+import reactDom from 'eslint-plugin-react-dom'
+
+export default defineConfig([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{ts,tsx}'],
+    extends: [
+      // Other configs...
+      // Enable lint rules for React
+      reactX.configs['recommended-typescript'],
+      // Enable lint rules for React DOM
+      reactDom.configs.recommended,
+    ],
+    languageOptions: {
+      parserOptions: {
+        project: ['./tsconfig.node.json', './tsconfig.app.json'],
+        tsconfigRootDir: import.meta.dirname,
+      },
+      // other options...
+    },
+  },
+])
+
+```

package/dist/AutomergeChangePlugin.d.ts

@@ -0,0 +1,10 @@
+import { UpdateSpansConfig } from '@automerge/automerge';
+import { DocHandle } from '@automerge/automerge-repo';
+import { LexicalEditor } from 'lexical';
+import { default as React } from 'react';
+interface AutomergeChangePluginProps {
+    registerSync(editor: LexicalEditor, handle: DocHandle<any>, updateSpansConfig?: UpdateSpansConfig): () => void;
+    handle: DocHandle<any>;
+}
+export declare const AutomergeChangePlugin: React.FC<AutomergeChangePluginProps>;
+export {};

package/dist/AutomergeConfig.d.ts

@@ -0,0 +1,28 @@
+import { InitialConfigType } from '@lexical/react/LexicalComposer';
+import { LexicalEditor, LexicalNode } from 'lexical';
+import { AutomergeUrl } from '@automerge/react';
+import { LexicalSchemaAdapter } from './types';
+/**
+ * Creates an Automerge configuration for a Lexical editor.
+ *
+ * @param editorConfig - Lexical editor configuration.
+ * @param path - Path to the rich text object in the document.
+ * @param docUrl - URL of the Automerge document.
+ * @param schema - Schema used to map Lexical nodes to Automerge.
+ * @returns A configuration object for the editor.
+ */
+export declare function automergeConfig<T>(editorConfig: Omit<InitialConfigType, 'editorState'>, path: string[], docUrl: AutomergeUrl, schema?: LexicalSchemaAdapter): {
+    initialConfig: {
+        nodes: (import('lexical').KlassConstructor<typeof LexicalNode> | import('lexical').LexicalNodeReplacement)[];
+        editorState: (editor: LexicalEditor) => void;
+        html?: import('lexical').HTMLConfig;
+        theme?: import('lexical').EditorThemeClasses;
+        namespace: string;
+        onError: (error: Error, editor: LexicalEditor) => void;
+        onWarn?: (error: Error, editor: LexicalEditor) => void;
+        editable?: boolean;
+    };
+    doc: import('@automerge/automerge').Doc<T>;
+    changeDoc: (changeFn: import('@automerge/automerge').ChangeFn<T>, options?: import('@automerge/automerge').ChangeOptions<T> | undefined) => void;
+    registerSync: (editor: LexicalEditor, handle: import('@automerge/automerge-repo').DocHandle<T>, updateSpansConfig?: import('@automerge/automerge').UpdateSpansConfig) => () => void;
+};

package/dist/AutomergeLexical.d.ts

@@ -0,0 +1,51 @@
+import { ElementNode, LexicalEditor, LexicalNode } from 'lexical';
+import { DocHandle } from '@automerge/automerge-repo';
+import { LexicalSchemaAdapter } from './types';
+import * as am from '@automerge/automerge';
+export declare class AutomergeLexical<T> {
+    private readonly schema;
+    path: string[];
+    private isApplyingRemote;
+    private isApplyingLocal;
+    private readonly automergeListTypeToLexicalType;
+    constructor(schema: LexicalSchemaAdapter, path: string[]);
+    getBlockMappingByLexicalType(lexicalType: string): import('./types').LexicalBlockMapping | undefined;
+    getBlockFactoryCreate(automergeType: string): ((attrs: Record<string, am.MaterializeValue>) => ElementNode) | undefined;
+    buildEditorStateFromAutomerge(_editor: LexicalEditor, doc: am.Doc<T> | undefined): void;
+    /**
+   * Initializes the lexical editor using the automerge doc
+   *
+   * @param editor - The Lexical editor instance.
+   * @param doc - The Automerge document handle.
+   * @param pathToTextField - Path to the rich text object in the document.
+   * @param tag - Used to identify the origin of the update (eg: 'automerge-init', 'automerge-remote')
+   */
+    initLexicalFromAutomerge(editor: LexicalEditor, doc: am.Doc<T>, pathToTextField: am.Prop[], tag?: string): void;
+    blockTypeVal(value: unknown): string;
+    appendText(block: ElementNode, text: string, marks: am.MarkSet): void;
+    /**
+     * Converts automerge spans to lexical nodes
+     *
+     * @param spans - Automerge spans to be converted.
+     * @returns Lexical nodes.
+     */
+    automergeSpansToLexicalNodes(spans: am.Span[]): LexicalNode[];
+    /**
+     * Converts lexical nodes to automerge spans
+     *
+     * @param nodes - Lexical nodes to be converted.
+     * @returns Automerge spans.
+     */
+    lexicalNodesToAmSpans(nodes: LexicalNode[]): am.Span[];
+    private appendInlineSpans;
+    private inlineNodeToTextAndMarks;
+    /**
+     * Registers two way synchronization between lexical and automerge
+     *
+     * @param editor - The Lexical editor instance.
+     * @param handle - The Automerge document handle.
+     * @param updateSpansConfig - Optional configuration passed to `am.updateSpans()`.
+     * @returns A cleanup function that unregisters all listeners.
+     */
+    registerSync(editor: LexicalEditor, handle: DocHandle<T>, updateSpansConfig?: am.UpdateSpansConfig): () => void;
+}

package/dist/automerge-lexical-plugin.es.js

@@ -0,0 +1,368 @@
+import { useDocument as e } from "@automerge/react";
+import { $createParagraphNode as t, $createTextNode as n, $getRoot as r, ElementNode as i, ParagraphNode as a, TextNode as o } from "lexical";
+import * as s from "@automerge/automerge";
+import { $createListItemNode as c, $createListNode as l, ListItemNode as u, ListNode as d } from "@lexical/list";
+import { $createLinkNode as f, LinkNode as p } from "@lexical/link";
+import { useLayoutEffect as m, useMemo as h } from "react";
+import { $createHeadingNode as g, $createQuoteNode as _, HeadingNode as v, QuoteNode as y } from "@lexical/rich-text";
+import { $createCodeNode as b, CodeNode as x } from "@lexical/code";
+import { useLexicalComposerContext as S } from "@lexical/react/LexicalComposerContext";
+//#region src/nodes/UnknownBlockNode.ts
+var C = class e extends i {
+	__automergeType;
+	__automergeAttrs;
+	static getType() {
+		return "automerge-unknown-block";
+	}
+	static clone(t) {
+		return new e(t.__automergeType, t.__automergeAttrs, t.__key);
+	}
+	constructor(e, t = {}, n) {
+		super(n), this.__automergeType = e, this.__automergeAttrs = t;
+	}
+	getAutomergeType() {
+		return this.getLatest().__automergeType;
+	}
+	getAutomergeAttrs() {
+		return this.getLatest().__automergeAttrs;
+	}
+	createDOM() {
+		let e = document.createElement("div");
+		e.setAttribute("data-automerge-unknown-block", this.__automergeType), e.style.border = "1px dashed var(--am-unknown-block-border, #999)", e.style.borderRadius = "4px", e.style.padding = "8px", e.style.margin = "4px 0", e.style.position = "relative";
+		let t = document.createElement("div");
+		return t.textContent = `Unsupported block: ${this.__automergeType}`, t.style.fontSize = "11px", t.style.opacity = "0.6", t.style.userSelect = "none", t.contentEditable = "false", e.appendChild(t), e;
+	}
+	updateDOM() {
+		return !1;
+	}
+	exportJSON() {
+		return {
+			...super.exportJSON(),
+			type: "automerge-unknown-block",
+			version: 1,
+			automergeType: this.__automergeType,
+			automergeAttrs: this.__automergeAttrs
+		};
+	}
+	static importJSON(e) {
+		return w(e.automergeType, e.automergeAttrs).updateFromJSON(e);
+	}
+	exportDOM() {
+		return { element: this.createDOM() };
+	}
+	static importDOM() {
+		return null;
+	}
+	isInline() {
+		return !1;
+	}
+};
+function w(e, t = {}) {
+	return new C(e, t);
+}
+function T(e) {
+	return e instanceof C;
+}
+//#endregion
+//#region src/AutomergeLexical.tsx
+var E = class {
+	schema;
+	path;
+	isApplyingRemote = !1;
+	isApplyingLocal = !1;
+	automergeListTypeToLexicalType = /* @__PURE__ */ new Map();
+	constructor(e, t) {
+		this.schema = e, this.path = t;
+		for (let [t, n] of Object.entries(e.listItemTypes)) this.automergeListTypeToLexicalType.set(n, t);
+	}
+	getBlockMappingByLexicalType(e) {
+		return this.schema.blocks.find((t) => t.lexicalType === e);
+	}
+	getBlockFactoryCreate(e) {
+		let t = this.schema.blocks.find((t) => t.automergeType === e);
+		if (t) return t.create;
+	}
+	buildEditorStateFromAutomerge(e, t) {
+		r().clear(), t && this.initLexicalFromAutomerge(e, t, this.path);
+	}
+	initLexicalFromAutomerge(e, t, n, i = "automerge-init") {
+		let a = s.spans(t, n);
+		e.update(() => {
+			let e = r();
+			e.clear();
+			let t = this.automergeSpansToLexicalNodes(a);
+			for (let n of t) e.append(n);
+		}, { tag: i });
+	}
+	blockTypeVal(e) {
+		return s.isImmutableString(e) ? e.val : typeof e == "string" ? e : "paragraph";
+	}
+	appendText(e, t, r) {
+		if (t.length === 0) return;
+		let i = n(t);
+		for (let { automergeMarkName: e, apply: t } of this.schema.marks) if (e in r) {
+			let n = r[e];
+			i = t(i, n);
+		}
+		e.append(i);
+	}
+	automergeSpansToLexicalNodes(e) {
+		if (e.length === 0) return [t()];
+		let n = [], r = null, i = null, a = null;
+		for (let o of e) if (o.type === "block") {
+			let e = this.blockTypeVal(o.value.type), t = o.value.attrs || {};
+			if (Object.keys(this.schema.listItemTypes).includes(e)) {
+				(i == null || a !== e) && (i = l(this.schema.listItemTypes[e]), a = e, n.push(i));
+				let t = c();
+				i.append(t), r = t;
+				continue;
+			}
+			i = null, a = null;
+			let s = this.getBlockFactoryCreate(e);
+			r = s ? s(t) : w(e, t), n.push(r);
+		} else r ?? (r = t(), n.push(r)), this.appendText(r, o.value, o.marks || {});
+		return n;
+	}
+	lexicalNodesToAmSpans(e) {
+		let t = [];
+		for (let n of e) {
+			if (n instanceof d) {
+				let e = this.automergeListTypeToLexicalType.get(n.getListType());
+				if (e == null) {
+					console.warn(`unknown lexical list type "${n.getListType()}", skipping list`);
+					continue;
+				}
+				for (let r of n.getChildren()) r instanceof u && (t.push({
+					type: "block",
+					value: {
+						type: e,
+						attrs: {}
+					}
+				}), this.appendInlineSpans(t, r));
+				continue;
+			}
+			if (T(n)) {
+				t.push({
+					type: "block",
+					value: {
+						type: n.getAutomergeType(),
+						attrs: n.getAutomergeAttrs()
+					}
+				}), this.appendInlineSpans(t, n);
+				continue;
+			}
+			if (n instanceof i) {
+				let e = this.getBlockMappingByLexicalType(n.getType());
+				if (e == null) {
+					console.warn(`unknown lexical node type "${n.getType()}", dropping (no reverse mapping)`);
+					continue;
+				}
+				let r = e.toAutomergeAttrs ? e.toAutomergeAttrs(n) : {};
+				t.push({
+					type: "block",
+					value: {
+						type: e.automergeType,
+						attrs: r
+					}
+				}), this.appendInlineSpans(t, n);
+				continue;
+			}
+		}
+		return t;
+	}
+	appendInlineSpans(e, t) {
+		for (let n of t.getChildren()) {
+			let { text: t, marks: r } = this.inlineNodeToTextAndMarks(n);
+			if (t.length === 0) continue;
+			let i = {
+				type: "text",
+				value: t
+			};
+			Object.keys(r).length > 0 && (i.marks = r), e.push(i);
+		}
+	}
+	inlineNodeToTextAndMarks(e) {
+		let t = {}, n = e;
+		if (n instanceof p) {
+			let e = this.schema.marks.find((e) => e.automergeMarkName === "link");
+			if (e) {
+				let r = e?.toAutomergeValue(n);
+				if (r) return t.link = r, {
+					text: n.getTextContent(),
+					marks: t
+				};
+			}
+		}
+		if (!(n instanceof o)) return {
+			text: "",
+			marks: t
+		};
+		for (let e of this.schema.marks) {
+			if (e.automergeMarkName === "link") continue;
+			let r = e.toAutomergeValue(n);
+			r && (t[e.automergeMarkName] = r);
+		}
+		return {
+			text: n.getTextContent(),
+			marks: t
+		};
+	}
+	registerSync(e, t, n) {
+		let i = ({ dirtyElements: e, dirtyLeaves: i, tags: a, editorState: o }) => {
+			this.isApplyingRemote || a.has("automerge-init") || a.has("automerge-remote") || e.size === 0 && i.size === 0 || o.read(() => {
+				let e = this.lexicalNodesToAmSpans(r().getChildren());
+				this.isApplyingLocal = !0;
+				try {
+					t.change((t) => {
+						s.updateSpans(t, this.path, e, n);
+					});
+				} finally {
+					this.isApplyingLocal = !1;
+				}
+			});
+		}, a = ({ doc: t }) => {
+			if (!this.isApplyingLocal) {
+				this.isApplyingRemote = !0;
+				try {
+					this.initLexicalFromAutomerge(e, t, this.path, "automerge-remote");
+				} finally {
+					this.isApplyingRemote = !1;
+				}
+			}
+		}, o = e.registerUpdateListener(i);
+		return t.on("change", a), () => {
+			o(), t.off("change", a);
+		};
+	}
+};
+//#endregion
+//#region src/schema/richTextSchema.ts
+function D(e) {
+	if (typeof e == "string") try {
+		let t = JSON.parse(e);
+		return {
+			href: t.href || "",
+			title: t.title || ""
+		};
+	} catch {}
+	return {
+		href: "",
+		title: ""
+	};
+}
+var O = {
+	requiredNodes: [
+		v,
+		a,
+		y,
+		d,
+		u,
+		p,
+		x
+	],
+	blocks: [
+		{
+			automergeType: "paragraph",
+			lexicalType: "paragraph",
+			create: () => t()
+		},
+		{
+			automergeType: "heading",
+			lexicalType: "heading",
+			create: (e) => {
+				let t = Number(e.level) || 1;
+				return g(`h${Math.min(Math.max(t, 1), 6)}`);
+			},
+			toAutomergeAttrs: (e) => ({ level: Number(e.getTag().slice(1)) })
+		},
+		{
+			automergeType: "blockquote",
+			lexicalType: "quote",
+			create: () => _()
+		},
+		{
+			automergeType: "code-block",
+			lexicalType: "code",
+			create: (e) => {
+				let t = e.language;
+				return typeof t == "string" ? b(t) : b();
+			},
+			toAutomergeAttrs: (e) => {
+				let t = e.getLanguage();
+				return { ...typeof t == "string" && { language: t } };
+			}
+		}
+	],
+	marks: [
+		{
+			automergeMarkName: "bold",
+			lexicalMarkName: "bold",
+			apply: (e, t) => (t && e instanceof o && e.toggleFormat("bold"), e),
+			toAutomergeValue: (e) => e instanceof p ? !1 : !!e.hasFormat("bold")
+		},
+		{
+			automergeMarkName: "italic",
+			lexicalMarkName: "italic",
+			apply: (e, t) => (t && e instanceof o && e.toggleFormat("italic"), e),
+			toAutomergeValue: (e) => e instanceof p ? !1 : !!e.hasFormat("italic")
+		},
+		{
+			automergeMarkName: "underline",
+			lexicalMarkName: "underline",
+			apply: (e, t) => (t && e instanceof o && e.toggleFormat("underline"), e),
+			toAutomergeValue: (e) => e instanceof p ? !1 : !!e.hasFormat("underline")
+		},
+		{
+			automergeMarkName: "link",
+			lexicalMarkName: "link",
+			apply: (e, t) => {
+				let { href: n, title: r } = D(t), i = f(n, r ? { title: r } : void 0);
+				return i.append(e), i;
+			},
+			toAutomergeValue: (e) => e instanceof p ? JSON.stringify({
+				href: e.getURL(),
+				title: e.getTitle?.() ?? ""
+			}) : ""
+		}
+	],
+	listItemTypes: {
+		"ordered-list-item": "number",
+		"unordered-list-item": "bullet"
+	}
+};
+//#endregion
+//#region src/AutomergeConfig.tsx
+function k(t, n, r, i = O) {
+	let [a, o] = e(r, { suspense: !0 }), { amLexical: s, registerSync: c } = h(() => {
+		let e = new E(i, n);
+		return {
+			amLexical: e,
+			registerSync: e.registerSync.bind(e)
+		};
+	}, [
+		i,
+		n,
+		r
+	]), l = [...i.requiredNodes, C], u = [...l, ...(t.nodes ?? []).filter((e) => !l.includes(e))];
+	return {
+		initialConfig: {
+			...t,
+			nodes: u,
+			editorState: (e) => s.buildEditorStateFromAutomerge(e, a)
+		},
+		doc: a,
+		changeDoc: o,
+		registerSync: c
+	};
+}
+//#endregion
+//#region src/AutomergeChangePlugin.tsx
+var A = ({ registerSync: e, handle: t }) => {
+	let [n] = S();
+	return m(() => {
+		let r = e(n, t);
+		return () => r();
+	}, [n]), null;
+};
+//#endregion
+export { A as AutomergeChangePlugin, E as AutomergeLexical, k as automergeConfig };

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { automergeConfig } from './AutomergeConfig';
+export { AutomergeLexical } from './AutomergeLexical';
+export type { LexicalSchemaAdapter } from './types';
+export { AutomergeChangePlugin } from './AutomergeChangePlugin';

package/dist/nodes/UnknownBlockNode.d.ts

@@ -0,0 +1,24 @@
+import { ElementNode, DOMConversionMap, DOMExportOutput, LexicalNode, NodeKey, SerializedElementNode, Spread } from 'lexical';
+import type * as am from '@automerge/automerge';
+export type SerializedUnknownBlockNode = Spread<{
+    automergeType: string;
+    automergeAttrs: Record<string, am.MaterializeValue>;
+}, SerializedElementNode>;
+export declare class UnknownBlockNode extends ElementNode {
+    __automergeType: string;
+    __automergeAttrs: Record<string, am.MaterializeValue>;
+    static getType(): string;
+    static clone(node: UnknownBlockNode): UnknownBlockNode;
+    constructor(automergeType: string, automergeAttrs?: Record<string, am.MaterializeValue>, key?: NodeKey);
+    getAutomergeType(): string;
+    getAutomergeAttrs(): Record<string, am.MaterializeValue>;
+    createDOM(): HTMLElement;
+    updateDOM(): boolean;
+    exportJSON(): SerializedUnknownBlockNode;
+    static importJSON(serializedNode: SerializedUnknownBlockNode): UnknownBlockNode;
+    exportDOM(): DOMExportOutput;
+    static importDOM(): DOMConversionMap | null;
+    isInline(): boolean;
+}
+export declare function $createUnknownBlockNode(automergeType: string, automergeAttrs?: Record<string, am.MaterializeValue>): UnknownBlockNode;
+export declare function $isUnknownBlockNode(node: LexicalNode | null | undefined): node is UnknownBlockNode;

package/dist/schema/richTextSchema.d.ts

@@ -0,0 +1,2 @@
+import { LexicalSchemaAdapter } from '../types';
+export declare const richTextSchema: LexicalSchemaAdapter;

package/dist/types.d.ts

@@ -0,0 +1,22 @@
+import { ElementNode, Klass, LexicalNode, TextNode } from 'lexical';
+import { ListType } from '@lexical/list';
+import { LinkNode } from '@lexical/link';
+import * as am from '@automerge/automerge';
+export interface LexicalBlockMapping {
+    automergeType: string;
+    lexicalType: string;
+    create(attrs: Record<string, am.MaterializeValue>): ElementNode;
+    toAutomergeAttrs?(node: ElementNode): Record<string, am.MaterializeValue>;
+}
+export interface LexicalMarkMapping {
+    automergeMarkName: string;
+    lexicalMarkName: string;
+    apply(textNode: LexicalNode, value: am.ScalarValue | string | undefined): LexicalNode;
+    toAutomergeValue(node: TextNode | LinkNode): am.MarkValue;
+}
+export interface LexicalSchemaAdapter {
+    blocks: LexicalBlockMapping[];
+    listItemTypes: Record<string, ListType>;
+    marks: LexicalMarkMapping[];
+    requiredNodes: Klass<LexicalNode>[];
+}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "automerge-lexical",
+  "private": false,
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/automerge-lexical-plugin.es.js",
+  "module": "./dist/automerge-lexical-plugin.es.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/automerge-lexical-plugin.es.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc -b && vite build",
+    "lint": "eslint .",
+    "preview": "vite preview",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "devDependencies": {
+    "@automerge/automerge": "^3.3.2",
+    "@automerge/automerge-repo": "^2.5.6",
+    "@automerge/react": "^2.5.6",
+    "@eslint/js": "^10.0.1",
+    "@lexical/code": "^0.48.0",
+    "@lexical/headless": "^0.48.0",
+    "@lexical/link": "^0.48.0",
+    "@lexical/list": "^0.48.0",
+    "@lexical/react": "^0.48.0",
+    "@lexical/rich-text": "^0.48.0",
+    "@types/node": "^24.13.2",
+    "@types/react": "^19.2.17",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^6.0.3",
+    "eslint": "^10.6.0",
+    "eslint-plugin-react-hooks": "^7.1.1",
+    "eslint-plugin-react-refresh": "^0.5.3",
+    "globals": "^17.7.0",
+    "jsdom": "^29.1.1",
+    "lexical": "^0.48.0",
+    "react": "^19.2.7",
+    "react-dom": "^19.2.7",
+    "typescript": "~6.0.2",
+    "typescript-eslint": "^8.62.0",
+    "vite": "^8.1.1",
+    "vite-plugin-dts": "^5.0.3",
+    "vitest": "^4.1.10"
+  },
+  "peerDependencies": {
+    "@automerge/automerge": "^3.3.2",
+    "@automerge/automerge-repo": "^2.5.6",
+    "@automerge/react": "^2.5.6",
+    "@lexical/link": "^0.47.0",
+    "@lexical/list": "^0.47.0",
+    "@lexical/react": "^0.47.0",
+    "@lexical/code": "^0.47.0",
+    "@lexical/rich-text": "^0.47.0",
+    "lexical": "^0.47.0",
+    "react": "^18.2.0 || ^19.0.0",
+    "react-dom": "^18.2.0 || ^19.0.0"
+  }
+}