lexical 0.45.0 → 0.45.1-dev.0

package/dist/Lexical.dev.js

@@ -534,9 +534,9 @@ function indexPath(root, child) {
  *
  */
 
-// `"0.45.0+dev.cjs"` is statically replaced with the build-specific
+// `"0.45.1-dev.0+dev.cjs"` is statically replaced with the build-specific
 // version string in a Rollup build, and a consumer's bundler `define` can
-// inject it the same way — so the exact `"0.45.0+dev.cjs"` member
+// inject it the same way — so the exact `"0.45.1-dev.0+dev.cjs"` member
 // expression must be preserved for that substitution to match. Reading it
 // inside a try/catch lets the source be consumed directly (via the `source`
 // export condition) in a browser bundle, where `process` is undefined and
@@ -545,11 +545,11 @@ function indexPath(root, child) {
 // `pnpm run update-version`.
 let envLexicalVersion;
 try {
-  envLexicalVersion = "0.45.0+dev.cjs";
+  envLexicalVersion = "0.45.1-dev.0+dev.cjs";
 } catch (_unused) {
   // `process` is not defined in some browser bundles; use the fallback.
 }
-const LEXICAL_VERSION = envLexicalVersion ?? '0.45.0+source';
+const LEXICAL_VERSION = envLexicalVersion ?? '0.45.1-dev.0+source';
 
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
@@ -968,7 +968,7 @@ function shouldUpdateTextNodeFromMutation(selection, targetDOM, targetNode) {
   }
   return isDOMTextNode(targetDOM) && targetNode.isAttached();
 }
-function $getNearestManagedNodePairFromDOMNode(startingDOM, editor, editorState, rootElement) {
+function $getNearestManagedNodePairFromDOMNode(startingDOM, editor, editorState) {
   for (let dom = startingDOM; dom && !isDOMUnmanaged(dom); dom = getParentElement(dom)) {
     const key = getNodeKeyFromDOMNode(dom, editor);
     if (key !== undefined) {
@@ -977,8 +977,6 @@ function $getNearestManagedNodePairFromDOMNode(startingDOM, editor, editorState,
         // All decorator nodes are unmanaged
         return $isDecoratorNode(node) || !isHTMLElement(dom) ? undefined : [dom, node];
       }
-    } else if (dom === rootElement) {
-      return [rootElement, internalGetRoot(editorState)];
     }
   }
 }
@@ -989,7 +987,6 @@ function flushMutations(editor, mutations, observer) {
     updateEditorSync(editor, () => {
       const selection = $getSelection() || getLastSelection(editor);
       const badDOMTargets = new Map();
-      const rootElement = editor.getRootElement();
       // We use the current editor state, as that reflects what is
       // actually "on screen".
       const currentEditorState = editor._editorState;
@@ -1000,7 +997,7 @@ function flushMutations(editor, mutations, observer) {
         const mutation = mutations[i];
         const type = mutation.type;
         const targetDOM = mutation.target;
-        const pair = $getNearestManagedNodePairFromDOMNode(targetDOM, editor, currentEditorState, rootElement);
+        const pair = $getNearestManagedNodePairFromDOMNode(targetDOM, editor, currentEditorState);
         if (!pair) {
           continue;
         }
@@ -2302,6 +2299,15 @@ function $createNode(key, slot) {
     dom.setAttribute('data-lexical-text', 'true');
   } else if ($isDecoratorNode(node)) {
     dom.setAttribute('data-lexical-decorator', 'true');
+    // DecoratorNode DOM is selection-captured: window selection inside
+    // a decorator subtree (e.g. an embedded input) is owned by the
+    // decorator, not by Lexical's caret management. Marking it via
+    // setDOMUnmanaged unifies the decorator case with extension-owned
+    // unmanaged subtrees so callers only need isDOMCapturingSelection /
+    // isDOMUnmanaged.
+    setDOMUnmanaged(dom, {
+      captureSelection: true
+    });
   }
   if ($isElementNode(node)) {
     const indent = node.__indent;
@@ -3806,7 +3812,7 @@ function onPointerDown(event, editor) {
     updateEditorSync(editor, () => {
       // Drag & drop should not recompute selection until mouse up; otherwise the initially
       // selected content is lost.
-      if (!$isSelectionCapturedInDecorator(target)) {
+      if (!isDOMCapturingSelection(target, editor)) {
         isSelectionChangeFromMouseDown = true;
       }
     });
@@ -4211,10 +4217,10 @@ function onInput(event, editor) {
   unprocessedBeforeInputData = null;
 }
 function $handleInput(event) {
-  if (isHTMLElement(event.target) && $isSelectionCapturedInDecorator(event.target)) {
+  const editor = getActiveEditor();
+  if (isHTMLElement(event.target) && isDOMCapturingSelection(event.target, editor)) {
     return true;
   }
-  const editor = getActiveEditor();
   const selection = $getSelection();
   const data = event.data;
   const targetRange = getTargetRange(event);
@@ -6198,101 +6204,6 @@ function setDOMStyleFromCSS(domStyle, cssText, prevCSSText = '') {
   }
 }
 
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- */
-
-/** @noInheritDoc */
-class LineBreakNode extends LexicalNode {
-  /** @internal */
-
-  static getType() {
-    return 'linebreak';
-  }
-  static clone(node) {
-    return new LineBreakNode(node.__key);
-  }
-  constructor(key) {
-    super(key);
-  }
-  getTextContent() {
-    return '\n';
-  }
-  createDOM() {
-    return document.createElement('br');
-  }
-  updateDOM() {
-    return false;
-  }
-  isInline() {
-    return true;
-  }
-  static importDOM() {
-    return {
-      br: node => {
-        if (isOnlyChildInBlockNode(node) || isLastChildInBlockNode(node)) {
-          return null;
-        }
-        return {
-          conversion: $convertLineBreakElement,
-          priority: 0
-        };
-      }
-    };
-  }
-  static importJSON(serializedLineBreakNode) {
-    return $createLineBreakNode().updateFromJSON(serializedLineBreakNode);
-  }
-}
-function $convertLineBreakElement(node) {
-  return {
-    node: $createLineBreakNode()
-  };
-}
-function $createLineBreakNode() {
-  return $applyNodeReplacement(new LineBreakNode());
-}
-function $isLineBreakNode(node) {
-  return node instanceof LineBreakNode;
-}
-function isOnlyChildInBlockNode(node) {
-  const parentElement = node.parentElement;
-  if (parentElement !== null && isBlockDomNode(parentElement)) {
-    const firstChild = parentElement.firstChild;
-    if (firstChild === node || firstChild.nextSibling === node && isWhitespaceDomTextNode(firstChild)) {
-      const lastChild = parentElement.lastChild;
-      if (lastChild === node || lastChild.previousSibling === node && isWhitespaceDomTextNode(lastChild)) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-function isLastChildInBlockNode(node) {
-  const parentElement = node.parentElement;
-  if (parentElement !== null && isBlockDomNode(parentElement)) {
-    // check if node is first child, because only child dont count
-    const firstChild = parentElement.firstChild;
-    if (firstChild === node || firstChild.nextSibling === node && isWhitespaceDomTextNode(firstChild)) {
-      return false;
-    }
-
-    // check if its last child
-    const lastChild = parentElement.lastChild;
-    if (lastChild === node || lastChild.previousSibling === node && isWhitespaceDomTextNode(lastChild)) {
-      return true;
-    }
-  }
-  return false;
-}
-function isWhitespaceDomTextNode(node) {
-  return isDOMTextNode(node) && /^( |\t|\r?\n)+$/.test(node.textContent || '');
-}
-
 function getElementOuterTag(node, format) {
   if (format & IS_CODE) {
     return 'code';
@@ -7268,21 +7179,8 @@ function $convertTextDOMNode(domNode) {
   let textContent = domNode_.textContent || '';
   // No collapse and preserve segment break for pre, pre-wrap and pre-line
   if (findParentPreDOMNode(domNode_) !== null) {
-    const parts = textContent.split(/(\r?\n|\t)/);
-    const nodes = [];
-    const length = parts.length;
-    for (let i = 0; i < length; i++) {
-      const part = parts[i];
-      if (part === '\n' || part === '\r\n') {
-        nodes.push($createLineBreakNode());
-      } else if (part === '\t') {
-        nodes.push($createTabNode());
-      } else if (part !== '') {
-        nodes.push($createTextNode(part));
-      }
-    }
     return {
-      node: nodes
+      node: $generateNodesFromRawText(textContent)
     };
   }
   textContent = textContent.replace(/\r/g, '').replace(/[ \t\n]+/g, ' ');
@@ -9221,7 +9119,7 @@ function $internalResolveSelectionPoint(dom, offset, lastPoint, editor) {
       moveSelectionToEnd = true;
       resolvedOffset = childNodesLength - 1;
     }
-    if (getNodeKeyFromDOMNode(dom, editor) === undefined && dom !== editor.getRootElement() && !$isSelectionCapturedInDecorator(dom)) {
+    if (getNodeKeyFromDOMNode(dom, editor) === undefined && !isDOMCapturingSelection(dom, editor)) {
       // The DOM caret is sitting on a node that has no Lexical key
       // (e.g. <col> inside an unmanaged <colgroup>, or any unmanaged
       // scaffolding around a DOMSlot — wrap elements, contenteditable=false
@@ -9231,14 +9129,14 @@ function $internalResolveSelectionPoint(dom, offset, lastPoint, editor) {
       // selection dirty so the reconciler writes a valid DOM caret back
       // at the resolved Lexical position.
       //
-      // Exceptions where the DOM caret is intentionally somewhere
-      // Lexical doesn't own and we should NOT force-sync it:
-      //  - the editor root element (tracked separately in
-      //    _keyToDOMMap as 'root'; has no __lexicalKey_* attribute);
-      //  - anything inside a DecoratorNode subtree (the decorator owns
-      //    its own DOM and may manage its own selection — for inputs
-      //    isSelectionCapturedInDecoratorInput rejects earlier, but
-      //    non-input decorator content also shouldn't be force-synced).
+      // Exclusions split across the two guard clauses:
+      //  - The first clause (`key !== undefined`) covers any DOM node
+      //    with a `__lexicalKey_*` attribute — Lexical-managed elements
+      //    and the editor root (stashed in `resetEditor`).
+      //  - `isDOMCapturingSelection` covers DecoratorNode subtrees (which
+      //    own their own DOM) and subtrees marked via
+      //    `setDOMUnmanaged(dom, {captureSelection: true})` —
+      //    extension-owned widgets that keep a native caret.
       //
       // Void elements that ARE Lexical nodes (LineBreakNode <br>,
       // empty decorator containers, etc.) have keys, so this check
@@ -10159,6 +10057,17 @@ function getActiveEditorState() {
   }
   return activeEditorState;
 }
+
+/** @internal */
+function $assumeActiveEditor(editor) {
+  // Throw if called outside of an update
+  if (getActiveEditorState() !== null && activeEditor === null) {
+    activeEditor = editor;
+  }
+  if (!(activeEditor === editor)) {
+    formatDevErrorMessage(`The given editor argument does not match $getEditor() in this context. Use editor.getEditorState().read(..., {editor}) if this cross-editor call is intentional.`);
+  }
+}
 function getActiveEditor() {
   if (activeEditor === null) {
     {
@@ -11774,6 +11683,119 @@ class ArtificialNode__DO_NOT_USE extends ElementNode {
   }
 }
 
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+/** @noInheritDoc */
+class LineBreakNode extends LexicalNode {
+  /** @internal */
+
+  static getType() {
+    return 'linebreak';
+  }
+  static clone(node) {
+    return new LineBreakNode(node.__key);
+  }
+  constructor(key) {
+    super(key);
+  }
+  getTextContent() {
+    return '\n';
+  }
+  createDOM() {
+    return document.createElement('br');
+  }
+  updateDOM() {
+    return false;
+  }
+  isInline() {
+    return true;
+  }
+  static importDOM() {
+    return {
+      br: node => {
+        if (isOnlyChildInBlockNode(node) || isLastChildInBlockNode(node)) {
+          return null;
+        }
+        return {
+          conversion: $convertLineBreakElement,
+          priority: 0
+        };
+      }
+    };
+  }
+  static importJSON(serializedLineBreakNode) {
+    return $createLineBreakNode().updateFromJSON(serializedLineBreakNode);
+  }
+}
+function $convertLineBreakElement(node) {
+  return {
+    node: $createLineBreakNode()
+  };
+}
+function $createLineBreakNode() {
+  return $applyNodeReplacement(new LineBreakNode());
+}
+function $isLineBreakNode(node) {
+  return node instanceof LineBreakNode;
+}
+
+/**
+ * True when `node` is the sole non-whitespace child of a block DOM
+ * element. Used by the LineBreak importer to drop stray `<br>` elements
+ * that the legacy `$generateNodesFromDOM` also skipped (matches the
+ * behavior of `LineBreakNode.importDOM`).
+ *
+ * @experimental
+ */
+function isOnlyChildInBlockNode(node) {
+  const parentElement = node.parentElement;
+  if (parentElement !== null && isBlockDomNode(parentElement)) {
+    const firstChild = parentElement.firstChild;
+    if (firstChild === node || firstChild.nextSibling === node && isWhitespaceDomTextNode(firstChild)) {
+      const lastChild = parentElement.lastChild;
+      if (lastChild === node || lastChild.previousSibling === node && isWhitespaceDomTextNode(lastChild)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+/**
+ * True when `node` is the trailing non-whitespace child of a block DOM
+ * element (excluding the only-child case). Used by the LineBreak
+ * importer to drop trailing `<br>` elements like the Apple-interchange
+ * clipboard artifact (matches `LineBreakNode.importDOM`).
+ *
+ * @experimental
+ */
+function isLastChildInBlockNode(node) {
+  const parentElement = node.parentElement;
+  if (parentElement !== null && isBlockDomNode(parentElement)) {
+    // check if node is first child, because only child dont count
+    const firstChild = parentElement.firstChild;
+    if (firstChild === node || firstChild.nextSibling === node && isWhitespaceDomTextNode(firstChild)) {
+      return false;
+    }
+
+    // check if its last child
+    const lastChild = parentElement.lastChild;
+    if (lastChild === node || lastChild.previousSibling === node && isWhitespaceDomTextNode(lastChild)) {
+      return true;
+    }
+  }
+  return false;
+}
+function isWhitespaceDomTextNode(node) {
+  return isDOMTextNode(node) && /^( |\t|\r?\n)+$/.test(node.textContent || '');
+}
+
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
@@ -12069,10 +12091,18 @@ function resetEditor(editor, prevRootElement, nextRootElement, pendingEditorStat
   // Remove all the DOM nodes from the root element
   if (prevRootElement !== null) {
     prevRootElement.textContent = '';
+    clearNodeKeyOnDOMNode(prevRootElement, editor);
   }
   if (nextRootElement !== null) {
     nextRootElement.textContent = '';
     keyNodeMap.set('root', nextRootElement);
+    // Stash __lexicalKey_${editor._key} = 'root' on the root element so it
+    // participates in the unified key lookup (selection resolution in
+    // $internalResolveSelectionPoint, mutation handling in
+    // $getNearestManagedNodePairFromDOMNode, $getNodeFromDOM, and
+    // $getNearestNodeFromDOMNode) instead of requiring a dedicated
+    // editor.getRootElement() carveout at each call site.
+    setNodeKeyOnDOMNode(nextRootElement, editor, 'root');
   }
 }
 function initializeConversionCache(nodes, additionalConversions) {
@@ -12214,9 +12244,6 @@ function createEditor(editorConfig) {
               console.warn(`${name} must implement static "${method}" method`);
             }
           });
-          if (!hasOwnStaticMethod(klass, 'importDOM') && hasOwnExportDOM(klass)) {
-            console.warn(`${name} should implement "importDOM" if using a custom "exportDOM" method to ensure HTML serialization (important for copy & paste) works as expected`);
-          }
           if (!hasOwnStaticMethod(klass, 'importJSON')) {
             console.warn(`${name} should implement "importJSON" method to ensure JSON and default HTML serialization works as expected`);
           }
@@ -12984,9 +13011,6 @@ const scheduleMicroTask = typeof queueMicrotask === 'function' ? queueMicrotask
   // No window prefix intended (#1400)
   Promise.resolve().then(fn);
 };
-function $isSelectionCapturedInDecorator(node) {
-  return $isDecoratorNode($getNearestNodeFromDOMNode(node));
-}
 function isSelectionCapturedInDecoratorInput(anchorDOM) {
   const activeElement = document.activeElement;
   if (!isHTMLElement(activeElement)) {
@@ -13312,6 +13336,10 @@ function setNodeKeyOnDOMNode(dom, editor, key) {
   const prop = `__lexicalKey_${editor._key}`;
   dom[prop] = key;
 }
+function clearNodeKeyOnDOMNode(dom, editor) {
+  const prop = `__lexicalKey_${editor._key}`;
+  delete dom[prop];
+}
 function getNodeKeyFromDOMNode(dom, editor) {
   const prop = `__lexicalKey_${editor._key}`;
   return dom[prop];
@@ -13398,10 +13426,6 @@ function $getNodeFromDOM(dom) {
   const editor = getActiveEditor();
   const nodeKey = getNodeKeyFromDOMTree(dom, editor);
   if (nodeKey === null) {
-    const rootElement = editor.getRootElement();
-    if (dom === rootElement) {
-      return $getNodeByKey('root');
-    }
     return null;
   }
   return $getNodeByKey(nodeKey);
@@ -14587,16 +14611,29 @@ function $setFormatFromDOM(node, domNode) {
   return alignment && alignment in ELEMENT_TYPE_TO_FORMAT ? node.setFormat(alignment) : node;
 }
 
+/**
+ * Options accepted by {@link setDOMUnmanaged}.
+ *
+ * @experimental
+ */
+
 /**
  * Mark this DOM element as unmanaged by lexical's mutation observer (like
  * decorator nodes are). Extensions that inject non-lexical decoration
  * elements into a node's DOM should mark them so the mutation observer
  * doesn't evict them as "unknown DOM children" during cleanup.
  *
+ * Pass `{captureSelection: true}` to additionally treat the subtree's
+ * window selection as decorator-like, so resolution does not force-sync
+ * the caret out of unmanaged DOM (see {@link isDOMCapturingSelection}).
+ *
  * @experimental
  */
-function setDOMUnmanaged(elementDom) {
+function setDOMUnmanaged(elementDom, options) {
   elementDom.__lexicalUnmanaged = true;
+  if (options && options.captureSelection !== undefined) {
+    elementDom.__lexicalCapturedSelection = options.captureSelection;
+  }
 }
 
 /**
@@ -14608,6 +14645,37 @@ function isDOMUnmanaged(elementDom) {
   return elementDom.__lexicalUnmanaged === true;
 }
 
+/**
+ * True if the DOM node sits inside a subtree marked with
+ * `{captureSelection: true}` via {@link setDOMUnmanaged}. Walks ancestors
+ * so any descendant of a marked subtree (e.g. an `<input>` inside a marked
+ * `<div>`) reports as captured too.
+ *
+ * The walk aborts at the first DOM node that corresponds to a Lexical
+ * node in `editor` — that boundary is the implicit owner of the subtree's
+ * selection, so a captureSelection marker above it (in non-Lexical
+ * scaffolding around the editor) does not leak in.
+ *
+ * DecoratorNode DOM is marked with `setDOMUnmanaged({captureSelection:
+ * true})` by the reconciler, so decorator subtrees also report as
+ * captured here.
+ *
+ * @experimental
+ */
+function isDOMCapturingSelection(elementDom, editor) {
+  let dom = elementDom;
+  while (dom != null) {
+    if (dom.__lexicalCapturedSelection === true) {
+      return true;
+    }
+    if (getNodeKeyFromDOMNode(dom, editor) !== undefined) {
+      return false;
+    }
+    dom = getParentElement(dom);
+  }
+  return false;
+}
+
 /**
  * @internal
  *
@@ -14624,13 +14692,6 @@ function hasOwnStaticMethod(klass, k) {
   return hasOwn(klass, k) && klass[k] !== LexicalNode[k];
 }
 
-/**
- * @internal
- */
-function hasOwnExportDOM(klass) {
-  return hasOwn(klass.prototype, 'exportDOM');
-}
-
 /** @internal */
 function isAbstractNodeClass(klass) {
   if (!(klass === LexicalNode || klass.prototype instanceof LexicalNode)) {
@@ -16391,6 +16452,7 @@ function mergeRegister(...func) {
 
 exports.$addUpdateTag = $addUpdateTag;
 exports.$applyNodeReplacement = $applyNodeReplacement;
+exports.$assumeActiveEditor = $assumeActiveEditor;
 exports.$caretFromPoint = $caretFromPoint;
 exports.$caretRangeFromSelection = $caretRangeFromSelection;
 exports.$cloneWithProperties = $cloneWithProperties;
@@ -16615,6 +16677,7 @@ exports.getTextDirection = getTextDirection;
 exports.getTransformSetFromKlass = getTransformSetFromKlass;
 exports.isBlockDomNode = isBlockDomNode;
 exports.isCurrentlyReadOnlyMode = isCurrentlyReadOnlyMode;
+exports.isDOMCapturingSelection = isDOMCapturingSelection;
 exports.isDOMDocumentNode = isDOMDocumentNode;
 exports.isDOMNode = isDOMNode;
 exports.isDOMTextNode = isDOMTextNode;
@@ -16626,8 +16689,10 @@ exports.isHTMLElement = isHTMLElement;
 exports.isHTMLTableCellElement = isHTMLTableCellElement;
 exports.isHTMLTableRowElement = isHTMLTableRowElement;
 exports.isInlineDomNode = isInlineDomNode;
+exports.isLastChildInBlockNode = isLastChildInBlockNode;
 exports.isLexicalEditor = isLexicalEditor;
 exports.isModifierMatch = isModifierMatch;
+exports.isOnlyChildInBlockNode = isOnlyChildInBlockNode;
 exports.isSelectionCapturedInDecoratorInput = isSelectionCapturedInDecoratorInput;
 exports.isSelectionWithinEditor = isSelectionWithinEditor;
 exports.makeStepwiseIterator = makeStepwiseIterator;