@lobehub/editor 4.29.0 → 4.29.2

package/es/plugins/markdown/command/index.js

@@ -1,9 +1,11 @@
 import { createDebugLogger, init_debug } from "../../../utils/debug.js";
+import { $findNodeById, $getNodeId, init_node_id } from "../../common/node/node-id.js";
 import { parseMarkdownToLexical } from "../data-source/markdown/parse.js";
 import { $generateNodesFromSerializedNodes, $insertGeneratedNodes } from "../utils/index.js";
-import { $getSelection, $isRangeSelection, COMMAND_PRIORITY_HIGH, HISTORIC_TAG, HISTORY_PUSH_TAG, createCommand } from "lexical";
+import { $getNodeByKey, $getRoot, $getSelection, $isElementNode, $isRangeSelection, $isRootNode, $isTextNode, COMMAND_PRIORITY_HIGH, HISTORIC_TAG, HISTORY_PUSH_TAG, createCommand } from "lexical";
 import { mergeRegister } from "@lexical/utils";
 //#region src/plugins/markdown/command/index.ts
+init_node_id();
 init_debug();
 const logger = createDebugLogger("plugin", "markdown");
 const INSERT_MARKDOWN_COMMAND = createCommand("INSERT_MARKDOWN_COMMAND");
@@ -16,6 +18,74 @@ const SPICAL_TEXT = "￰";
 const getLineNumber = (content, charIndex) => {
 	return content.slice(0, Math.max(0, charIndex)).split("\n").length;
 };
+function getNodeReferenceForKey(editor, key) {
+	return editor.getEditorState().read(() => {
+		const node = $getNodeByKey(key);
+		if (!node) return null;
+		if ($isRootNode(node)) return { kind: "root" };
+		const id = $getNodeId(node);
+		return id ? {
+			id,
+			kind: "node"
+		} : null;
+	});
+}
+function getNodeKeyForReference(editor, reference, offset) {
+	return editor.getEditorState().read(() => {
+		if (reference.kind === "node") {
+			const node = $findNodeById(reference.id);
+			return node ? {
+				key: node.getKey(),
+				offset
+			} : void 0;
+		}
+		const root = $getRoot();
+		const findBoundaryText = (node, first) => {
+			if ($isTextNode(node)) return node;
+			if (!$isElementNode(node)) return null;
+			const children = node.getChildren();
+			const orderedChildren = first ? children : [...children].reverse();
+			for (const child of orderedChildren) {
+				const textNode = findBoundaryText(child, first);
+				if (textNode) return textNode;
+			}
+			return null;
+		};
+		if (offset === 0) {
+			const firstText = findBoundaryText(root, true);
+			if (firstText) return {
+				key: firstText.getKey(),
+				offset: 0
+			};
+		}
+		if (offset === root.getChildrenSize()) {
+			const lastText = findBoundaryText(root, false);
+			if (lastText) return {
+				key: lastText.getKey(),
+				offset: lastText.getTextContentSize()
+			};
+		}
+		return {
+			key: root.getKey(),
+			offset
+		};
+	}, { editor });
+}
+function mapSelectionToEditor(selection, sourceEditor, targetEditor) {
+	const startReference = getNodeReferenceForKey(sourceEditor, selection.startNodeId);
+	const endReference = getNodeReferenceForKey(sourceEditor, selection.endNodeId);
+	if (!startReference || !endReference) return null;
+	const startPoint = getNodeKeyForReference(targetEditor, startReference, selection.startOffset);
+	const endPoint = getNodeKeyForReference(targetEditor, endReference, selection.endOffset);
+	if (!startPoint || !endPoint) return null;
+	return {
+		...selection,
+		endNodeId: endPoint.key,
+		endOffset: endPoint.offset,
+		startNodeId: startPoint.key,
+		startOffset: startPoint.offset
+	};
+}
 function registerMarkdownCommand(editor, kernel, service) {
 	return mergeRegister(editor.registerCommand(INSERT_MARKDOWN_COMMAND, (payload) => {
 		const { markdown } = payload;
@@ -38,9 +108,12 @@ function registerMarkdownCommand(editor, kernel, service) {
 		return false;
 	}, COMMAND_PRIORITY_HIGH), editor.registerCommand(GET_MARKDOWN_SELECTION_COMMAND, (payload) => {
 		const newEditor = kernel.cloneNodeEditor();
-		const s = kernel.getSelection();
-		if (s) {
-			newEditor.setSelection(s);
+		const sourceEditor = kernel.getLexicalEditor();
+		const selection = kernel.getSelection();
+		const targetEditor = newEditor.getLexicalEditor();
+		const mappedSelection = sourceEditor && targetEditor && selection ? mapSelectionToEditor(selection, sourceEditor, targetEditor) : null;
+		if (mappedSelection && targetEditor) {
+			newEditor.setSelection(mappedSelection);
 			newEditor.getLexicalEditor()?.update(() => {
 				const sel = $getSelection();
 				if (!sel) return;

package/es/plugins/markdown/data-source/markdown-data-source.js

@@ -1,4 +1,5 @@
 import { INodeHelper, init_helper } from "../../../editor-kernel/inode/helper.js";
+import { $normalizeNodeIds, init_node_id } from "../../common/node/node-id.js";
 import DataSource from "../../../editor-kernel/data-source.js";
 import { INodeService } from "../../inode/service/index.js";
 import { logger } from "../utils/logger.js";
@@ -10,6 +11,7 @@ import { remark } from "remark";
 import remarkGfm from "remark-gfm";
 //#region src/plugins/markdown/data-source/markdown-data-source.ts
 init_helper();
+init_node_id();
 var MarkdownDataSource = class extends DataSource {
 	formatMarkdown(markdown) {
 		try {
@@ -37,7 +39,10 @@ var MarkdownDataSource = class extends DataSource {
 		const inode = { root: parseMarkdownToLexical(data, this.markdownService.markdownReaders) };
 		this.getService?.(INodeService)?.processNodeTree(inode);
 		logger.debug("Parsed Lexical State:", inode);
-		editor.setEditorState(editor.parseEditorState(inode));
+		const editorState = editor.parseEditorState(inode, () => {
+			$normalizeNodeIds($getRoot());
+		});
+		editor.setEditorState(editorState);
 	}
 	write(editor, options) {
 		if (options?.selection) return editor.getEditorState().read(() => {

package/es/plugins/math/plugin/index.js

@@ -39,14 +39,14 @@ const MathPlugin = class extends KernelPlugin {
 		if (!litexmlService) return;
 		litexmlService.registerXMLWriter(MathInlineNode.getType(), (node, ctx) => {
 			if (node instanceof MathInlineNode) {
-				const attributes = { code: node.getTextContent() };
+				const attributes = { code: node.code };
 				return ctx.createXmlNode("math", attributes);
 			}
 			return false;
 		});
 		litexmlService.registerXMLWriter(MathBlockNode.getType(), (node, ctx) => {
 			if (node instanceof MathBlockNode) {
-				const attributes = { code: node.getTextContent() };
+				const attributes = { code: node.code };
 				return ctx.createXmlNode("mathBlock", attributes);
 			}
 			return false;

package/es/plugins/slash/service/i-slash-service.d.ts

@@ -2,13 +2,13 @@ import { IEditor, IServiceID } from "../../../types/kernel.js";
 import "../../../types/index.js";
 import "../utils/utils.js";
 import { ReactNode } from "react";
-import { DropdownMenuItemType } from "@lobehub/ui";
+import { MenuItemType } from "@lobehub/ui";
 import Fuse, { IFuseOptions } from "fuse.js";
 //#region src/plugins/slash/service/i-slash-service.d.ts
 type ISlashDividerOption = {
   type: 'divider';
 };
-interface ISlashMenuOption extends DropdownMenuItemType {
+interface ISlashMenuOption extends MenuItemType {
   description?: ReactNode;
   layout?: 'compact' | 'tile' | 'wide';
   metadata?: Record<string, any>;

package/es/plugins/yjs/plugin/index.js

@@ -5,6 +5,7 @@ import { hydrateLexicalFromYjsState, syncCurrentEditorStateToYjs } from "./utils
 import { IYjsService, YjsService } from "../service/index.js";
 import { getAwarenessUsers } from "./utils/awareness.js";
 import { registerYjsHistory } from "./utils/history.js";
+import { isNodeIdReconciliationOrigin, reconcileSharedNodeIds } from "./utils/node-identity.js";
 import { $getRoot, COLLABORATION_TAG, COMMAND_PRIORITY_CRITICAL, SKIP_COLLAB_TAG } from "lexical";
 import { UndoManager } from "yjs";
 import { CONNECTED_COMMAND, TOGGLE_CONNECT_COMMAND, createBinding, syncLexicalUpdateToYjs, syncYjsChangesToLexical } from "@lexical/yjs";
@@ -89,7 +90,8 @@ const YjsPlugin = class extends KernelPlugin {
 				return;
 			}
 			if (binding.root.isEmpty() && binding.root._xmlText._length > 0) {
-				hydrateLexicalFromYjsState(binding);
+				hydrateLexicalFromYjsState(binding, { discrete: true });
+				reconcileSharedNodeIds(binding);
 				return;
 			}
 			this.bootstrapCurrentEditorState?.();
@@ -122,8 +124,8 @@ const YjsPlugin = class extends KernelPlugin {
 	}
 	registerYjsTreeSync(binding, provider) {
 		const onYjsTreeChanges = (events, transaction) => {
-			if (transaction.origin === binding) return;
-			syncYjsChangesToLexical(binding, provider, events, transaction.origin instanceof UndoManager, () => void 0);
+			if (transaction.origin === binding || isNodeIdReconciliationOrigin(binding, transaction.origin)) return;
+			syncYjsChangesToLexical(binding, provider, events, transaction.origin instanceof UndoManager, () => reconcileSharedNodeIds(binding));
 		};
 		binding.root.getSharedType().observeDeep(onYjsTreeChanges);
 		this.register(() => {

package/es/plugins/yjs/plugin/utils/editor-state.js

@@ -1,5 +1,7 @@
+import { $normalizeNodeIds, init_node_id, migrateSerializedNodeIds } from "../../../common/node/node-id.js";
 import { $createParagraphNode, $getRoot, HISTORY_MERGE_TAG, SKIP_COLLAB_TAG } from "lexical";
 //#region src/plugins/yjs/plugin/utils/editor-state.ts
+init_node_id();
 function initializeEditor(editor, initialEditorState, options = {}) {
 	const { discrete, skipIfNotEmpty = true, tag = HISTORY_MERGE_TAG } = options;
 	const updateOptions = Object.keys({
@@ -13,7 +15,12 @@ function initializeEditor(editor, initialEditorState, options = {}) {
 		if (editor.getEditorState().read(() => {
 			return skipIfNotEmpty && !$getRoot().isEmpty();
 		})) return;
-		editor.setEditorState(typeof initialEditorState === "string" ? editor.parseEditorState(initialEditorState) : initialEditorState, updateOptions);
+		const serializedState = typeof initialEditorState === "string" ? JSON.parse(initialEditorState) : initialEditorState.toJSON();
+		migrateSerializedNodeIds(serializedState.root);
+		const parsedState = editor.parseEditorState(serializedState, () => {
+			$normalizeNodeIds($getRoot());
+		});
+		editor.setEditorState(parsedState, updateOptions);
 		return;
 	}
 	editor.update(() => {

package/es/plugins/yjs/plugin/utils/node-identity.js

@@ -0,0 +1,106 @@
+import { $getNodeIdentityPolicy, init_node_identity_policy } from "../../../common/node/node-identity-policy.js";
+import { $getNodeId, $normalizeNodeIds, init_node_id } from "../../../common/node/node-id.js";
+import { $getRoot, $isElementNode, COLLABORATION_TAG, HISTORIC_TAG } from "lexical";
+import { Map as Map$1, createRelativePositionFromTypeIndex } from "yjs";
+//#region src/plugins/yjs/plugin/utils/node-identity.ts
+init_node_id();
+init_node_identity_policy();
+const reconciliationOrigins = /* @__PURE__ */ new WeakMap();
+function getReconciliationOrigin(binding) {
+	let origin = reconciliationOrigins.get(binding);
+	if (!origin) {
+		origin = { type: "lobe-editor-node-id-reconciliation" };
+		reconciliationOrigins.set(binding, origin);
+	}
+	return origin;
+}
+function isNodeIdReconciliationOrigin(binding, origin) {
+	const reconciliationOrigin = reconciliationOrigins.get(binding);
+	return reconciliationOrigin !== void 0 && origin === reconciliationOrigin;
+}
+function getSharedNodeState(sharedType) {
+	const state = sharedType instanceof Map$1 ? sharedType.get("__state") : sharedType.getAttribute("__state");
+	return state instanceof Map$1 ? state : void 0;
+}
+function setSharedNodeState(sharedType, state) {
+	if (sharedType instanceof Map$1) sharedType.set("__state", state);
+	else sharedType.setAttribute("__state", state);
+}
+function getStableSharedIdentity(binding, node) {
+	const sharedType = binding.collabNodeMap.get(node.getKey())?.getSharedType();
+	if (!sharedType) return void 0;
+	const id = createRelativePositionFromTypeIndex(sharedType, 0).type;
+	if (!id) return void 0;
+	return `${id.client.toString(36).padStart(7, "0")}:${id.clock.toString(36).padStart(11, "0")}`;
+}
+function hasRepairableSharedIdIssues(binding) {
+	const editor = binding.editor;
+	return editor.getEditorState().read(() => {
+		const policy = $getNodeIdentityPolicy();
+		const groups = /* @__PURE__ */ new Map();
+		let hasMappedMissingId = false;
+		const visit = (node) => {
+			if (policy.isIdentityNode(node)) {
+				const nodeId = $getNodeId(node);
+				if (!nodeId) {
+					if (getStableSharedIdentity(binding, node)) hasMappedMissingId = true;
+				} else {
+					const group = groups.get(nodeId) || [];
+					group.push(node);
+					groups.set(nodeId, group);
+				}
+			}
+			if ($isElementNode(node)) node.getChildren().forEach(visit);
+		};
+		visit($getRoot());
+		if (hasMappedMissingId) return true;
+		for (const group of groups.values()) {
+			if (group.length < 2 || group.length === 2 && policy.canShareId(group[0], group[1])) continue;
+			const identities = group.map((node) => getStableSharedIdentity(binding, node));
+			if (identities.every((identity) => Boolean(identity)) && new Set(identities).size === identities.length) return true;
+		}
+		return false;
+	}, { editor });
+}
+function writeRepairedNodeIds(binding, repairs) {
+	if (repairs.length === 0) return;
+	binding.doc.transact(() => {
+		for (const repair of repairs) {
+			const sharedType = binding.collabNodeMap.get(repair.nodeKey)?.getSharedType();
+			if (!sharedType) continue;
+			const existingState = getSharedNodeState(sharedType);
+			const state = existingState ?? new Map$1();
+			const currentProperties = existingState?.get("properties");
+			const properties = currentProperties && typeof currentProperties === "object" && !Array.isArray(currentProperties) ? currentProperties : {};
+			state.set("properties", {
+				...properties,
+				nodeId: repair.nodeId
+			});
+			if (!existingState) setSharedNodeState(sharedType, state);
+		}
+	}, getReconciliationOrigin(binding));
+}
+/** Repair shared ID collisions only after the binding has mapped their Yjs types. */
+function reconcileSharedNodeIds(binding) {
+	if (!hasRepairableSharedIdIssues(binding)) return;
+	const repairs = [];
+	binding.editor.update(() => {
+		$normalizeNodeIds($getRoot(), {
+			onRepair: (node, previousId, nodeId) => {
+				if (previousId !== nodeId) repairs.push({
+					nodeId,
+					nodeKey: node.getKey()
+				});
+			},
+			stableDuplicateRepair: true,
+			stableOwnershipKey: (node) => getStableSharedIdentity(binding, node)
+		});
+	}, {
+		discrete: true,
+		onUpdate: () => writeRepairedNodeIds(binding, repairs),
+		skipTransforms: true,
+		tag: [COLLABORATION_TAG, HISTORIC_TAG]
+	});
+}
+//#endregion
+export { isNodeIdReconciliationOrigin, reconcileSharedNodeIds };

package/es/plugins/yjs/service/index.js

@@ -1,12 +1,40 @@
+import { $normalizeNodeIds, editorStateHasCompleteNodeIds, inheritMissingSerializedNodeIds, init_node_id, isValidContentNodeId, migrateSerializedNodeIds } from "../../common/node/node-id.js";
 import { createEmptyPreviousEditorState } from "../plugin/utils/editor-state.js";
 import { hydrateLexicalFromYjsState, syncCurrentEditorStateToYjs } from "../plugin/utils/sync.js";
-import { SKIP_COLLAB_TAG } from "lexical";
+import { $getRoot, SKIP_COLLAB_TAG } from "lexical";
 //#region src/plugins/yjs/service/index.ts
+init_node_id();
 const serializeComparableEditorState = (state) => {
-	const serialized = state.toJSON();
+	const serialized = structuredClone(state.toJSON());
 	if (serialized.root?.direction === "ltr") serialized.root.direction = null;
 	return JSON.stringify(serialized);
 };
+const serializeComparableStateForSnapshot = (state, snapshotRoot) => {
+	const serialized = structuredClone(state.toJSON());
+	if (serialized.root?.direction === "ltr") serialized.root.direction = null;
+	const stripMissingIds = (stateNode, snapshotNode) => {
+		if (!stateNode || typeof stateNode !== "object" || Array.isArray(stateNode) || !snapshotNode || typeof snapshotNode !== "object" || Array.isArray(snapshotNode)) return;
+		const stateRecord = stateNode;
+		const snapshotRecord = snapshotNode;
+		if (stateRecord.type === snapshotRecord.type) {
+			const properties = snapshotRecord.$?.properties;
+			if (!(snapshotRecord.type !== "root" && (isValidContentNodeId(snapshotRecord.id) || typeof snapshotRecord.id === "number" && Number.isFinite(snapshotRecord.id) || isValidContentNodeId(properties?.nodeId)))) {
+				delete stateRecord.id;
+				if (stateRecord.$?.properties) {
+					delete stateRecord.$.properties.nodeId;
+					if (Object.keys(stateRecord.$.properties).length === 0) delete stateRecord.$.properties;
+					if (Object.keys(stateRecord.$).length === 0) delete stateRecord.$;
+				}
+			}
+			if (Array.isArray(stateRecord.children) && Array.isArray(snapshotRecord.children)) {
+				const length = Math.min(stateRecord.children.length, snapshotRecord.children.length);
+				for (let index = 0; index < length; index++) stripMissingIds(stateRecord.children[index], snapshotRecord.children[index]);
+			}
+		}
+	};
+	stripMissingIds(serialized.root, snapshotRoot);
+	return JSON.stringify(serialized);
+};
 var YjsService = class {
 	constructor() {
 		this.awarenessUsers = [];
@@ -40,9 +68,15 @@ var YjsService = class {
 		const hasSharedState = !binding.root.isEmpty() || binding.root._xmlText._length > 0;
 		if (hasSharedState && binding.root.isEmpty()) hydrateLexicalFromYjsState(binding, { discrete: true });
 		const previousEditorState = binding.editor.getEditorState();
-		const nextEditorState = binding.editor.parseEditorState(JSON.stringify(editorData));
+		const snapshot = structuredClone(editorData);
+		migrateSerializedNodeIds(snapshot.root);
+		inheritMissingSerializedNodeIds(previousEditorState.toJSON().root, snapshot.root);
+		const nextEditorState = binding.editor.parseEditorState(JSON.stringify(snapshot), () => {
+			$normalizeNodeIds($getRoot(), { stableDuplicateRepair: true });
+		});
 		const isSameState = serializeComparableEditorState(previousEditorState) === serializeComparableEditorState(nextEditorState);
-		if (hasSharedState && isSameState) return false;
+		const isSameStateIgnoringOmittedIds = hasSharedState && editorStateHasCompleteNodeIds(previousEditorState, binding.editor) && serializeComparableStateForSnapshot(previousEditorState, snapshot.root) === serializeComparableStateForSnapshot(nextEditorState, snapshot.root);
+		if (hasSharedState && (isSameState || isSameStateIgnoringOmittedIds)) return false;
 		binding.editor.setEditorState(nextEditorState, { tag: SKIP_COLLAB_TAG });
 		const replaceSharedState = () => {
 			const collabRoot = binding.root;

package/es/{symbols-Do7jD4Tt.d.ts → symbols-Dyr9yyS0.d.ts}

@@ -22,21 +22,32 @@ declare enum DiffAction {
   Reject = 0,
   Accept = 1
 }
-declare const LITEXML_MODIFY_COMMAND: import("lexical").LexicalCommand<({
-  action: "insert";
+type LiteXmlModifyOperation = {
+  action: 'insert';
   beforeId: string;
   litexml: string;
 } | {
-  action: "insert";
+  action: 'insert';
   afterId: string;
   litexml: string;
 } | {
-  action: "remove";
+  action: 'remove';
   id: string;
 } | {
-  action: "modify";
+  action: 'modify';
   litexml: string | string[];
-})[]>;
+};
+interface LiteXmlOperationResult {
+  action: LiteXmlModifyOperation['action'];
+  index: number;
+  reason?: string;
+  status: 'applied' | 'failed';
+}
+declare const LITEXML_MODIFY_COMMAND: import("lexical").LexicalCommand<LiteXmlModifyOperation[]>;
+declare const LITEXML_MODIFY_WITH_RESULTS_COMMAND: import("lexical").LexicalCommand<{
+  onResults: (results: LiteXmlOperationResult[]) => void;
+  operations: ReadonlyArray<LiteXmlModifyOperation>;
+}>;
 declare const LITEXML_APPLY_COMMAND: import("lexical").LexicalCommand<{
   delay?: boolean;
   litexml: string | string[];
@@ -62,4 +73,4 @@ declare const LITEXML_DIFFNODE_ALL_COMMAND: import("lexical").LexicalCommand<{
   action: DiffAction;
 }>;
 //#endregion
-export { LITEXML_INSERT_COMMAND as a, LITEXML_DIFFNODE_COMMAND as i, LITEXML_APPLY_COMMAND as n, LITEXML_MODIFY_COMMAND as o, LITEXML_DIFFNODE_ALL_COMMAND as r, LITEXML_REMOVE_COMMAND as s, DiffAction as t };
+export { LITEXML_INSERT_COMMAND as a, LITEXML_REMOVE_COMMAND as c, LITEXML_DIFFNODE_COMMAND as i, LiteXmlModifyOperation as l, LITEXML_APPLY_COMMAND as n, LITEXML_MODIFY_COMMAND as o, LITEXML_DIFFNODE_ALL_COMMAND as r, LITEXML_MODIFY_WITH_RESULTS_COMMAND as s, DiffAction as t, LiteXmlOperationResult as u };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/editor",
-  "version": "4.29.0",
+  "version": "4.29.2",
   "description": "A powerful and extensible rich text editor built on Meta's Lexical framework, providing a modern editing experience with React integration.",
   "keywords": [
     "lobehub",
@@ -86,7 +86,8 @@
     "test": "vitest",
     "test:coverage": "vitest run --coverage  --passWithNoTests",
     "test:watch": "vitest --watch",
-    "type-check": "tsc --noEmit"
+    "type-check": "tsc --noEmit",
+    "verify:node-identity-package": "node scripts/verify-node-identity-package.mjs"
   },
   "dependencies": {
     "@floating-ui/dom": "^1.8.0",
@@ -143,8 +144,7 @@
       "chalk": "^4.1.2"
     },
     "patchedDependencies": {
-      "@lexical/yjs@0.42.0": "patches/@lexical__yjs@0.42.0.patch",
-      "lexical@0.42.0": "patches/lexical@0.42.0.patch"
+      "@lexical/yjs@0.42.0": "patches/@lexical__yjs@0.42.0.patch"
     }
   }
 }

package/scripts/postinstall-lexical-patch.cjs

@@ -7,27 +7,6 @@ const path = require('node:path');
 
 const PACKAGE_ROOT = path.resolve(__dirname, '..');
 const PATCH_CONFIGS = [
-  {
-    displayName: 'Lexical',
-    fileHashes: {
-      'Lexical.dev.js': {
-        patched: '7c81a9785b397dc09ce0ecc9f3126d3e4903cdfd12d5c51318965ed74b0e3ccb',
-      },
-      'Lexical.dev.mjs': {
-        patched: '880f22f2ec2d873e1699766de39edce5123b4730009bb88bb33d7e4da98a4ad9',
-      },
-      'Lexical.prod.js': {
-        patched: '9f97867340b84853cf82bbd2d60ef9f944ee61ef058daa37007b820c2780a103',
-      },
-      'Lexical.prod.mjs': {
-        patched: 'f7b2993582b2cc0573ca468373831b17971e0bb7383f5ca8785d4b93ab967c0b',
-      },
-    },
-    packageName: 'lexical',
-    patchFile: path.join(PACKAGE_ROOT, 'patches', 'lexical@0.42.0.patch'),
-    rootOverride: process.env.LOBE_EDITOR_LEXICAL_ROOT,
-    supportedVersion: '0.42.0',
-  },
   {
     displayName: 'Lexical Yjs',
     fileHashes: {