lexical 0.35.1-nightly.20250924.0 → 0.36.0

package/Lexical.dev.js

@@ -54,7 +54,7 @@ const IS_CHROME = CAN_USE_DOM && /^(?=.*Chrome).*/i.test(navigator.userAgent);
 // export const canUseTextInputEvent: boolean = CAN_USE_DOM && 'TextEvent' in window && !documentMode;
 
 const IS_ANDROID_CHROME = CAN_USE_DOM && IS_ANDROID && IS_CHROME;
-const IS_APPLE_WEBKIT = CAN_USE_DOM && /AppleWebKit\/[\d.]+/.test(navigator.userAgent) && !IS_CHROME;
+const IS_APPLE_WEBKIT = CAN_USE_DOM && /AppleWebKit\/[\d.]+/.test(navigator.userAgent) && IS_APPLE && !IS_CHROME;
 
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
@@ -552,26 +552,26 @@ function initMutationObserver(editor) {
  */
 class StateConfig {
   /** The string key used when serializing this state to JSON */
-
+  key;
   /** The parse function from the StateValueConfig passed to createState */
-
+  parse;
   /**
    * The unparse function from the StateValueConfig passed to createState,
    * with a default that is simply a pass-through that assumes the value is
    * JSON serializable.
    */
-
+  unparse;
   /**
    * An equality function from the StateValueConfig, with a default of
    * Object.is.
    */
-
+  isEqual;
   /**
    * The result of `stateValueConfig.parse(undefined)`, which is computed only
    * once and used as the default value. When the current value `isEqual` to
    * the `defaultValue`, it will not be serialized to JSON.
    */
-
+  defaultValue;
   constructor(key, stateValueConfig) {
     this.key = key;
     this.parse = stateValueConfig.parse.bind(stateValueConfig);
@@ -608,6 +608,8 @@ class StateConfig {
  * @param key The key to use
  * @param valueConfig Configuration for the value type
  * @returns a StateConfig
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 function createState(key, valueConfig) {
   return new StateConfig(key, valueConfig);
@@ -782,6 +784,7 @@ class NodeState {
    * will trigger a copy of the prevNode's NodeState with the node property
    * updated.
    */
+  node;
 
   /**
    * @internal
@@ -792,6 +795,7 @@ class NodeState {
    * Note that it uses StateConfig, so in addition to (1) the CURRENT VALUE, it has access to
    * (2) the State key (3) the DEFAULT VALUE and (4) the PARSE FUNCTION
    */
+  knownState;
 
   /**
    * @internal
@@ -809,6 +813,7 @@ class NodeState {
    * an old version of your code doesnt erase metadata that was
    * set by a newer version of your code.
    */
+  unknownState;
 
   /**
    * @internal
@@ -817,13 +822,14 @@ class NodeState {
    * node type in an editor and remains writable. It is how keys are resolved
    * to configuration.
    */
-
+  sharedNodeState;
   /**
    * @internal
    *
    * The count of known or unknown keys in this state, ignoring the
    * intersection between the two sets.
    */
+  size;
 
   /**
    * @internal
@@ -1904,6 +1910,16 @@ function warnOnlyOnce(message) {
  *
  */
 
+/**
+ * Crete a command that can be used with `editor.dispatchCommand` and
+ * `editor.registerCommand`. Commands are used by unique reference, not by
+ * name.
+ *
+ * @param type A string to identify the command, very helpful for debugging
+ * @returns A new LexicalCommand
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
 function createCommand(type) {
   return {
     type
@@ -3147,23 +3163,21 @@ function buildImportMap(importMap) {
   return importMap;
 }
 class LexicalNode {
-  /**
-   * @internal
-   * Allow us to look up the type including static props
-   */
+  /** @internal Allow us to look up the type including static props */
 
   /** @internal */
-
+  __type;
   /** @internal */
   //@ts-ignore We set the key in the constructor.
-
+  __key;
   /** @internal */
-
+  __parent;
   /** @internal */
-
+  __prev;
   /** @internal */
-
+  __next;
   /** @internal */
+  __state;
 
   // Flow doesn't support abstract classes unfortunately, so we can't _force_
   // subclasses of Node to implement statics. All subclasses of Node should have
@@ -3295,7 +3309,7 @@ class LexicalNode {
   }
 
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-
+  static importDOM;
   constructor(key) {
     this.__type = this.constructor.getType();
     this.__parent = null;
@@ -4427,14 +4441,15 @@ function wrapElementWith(element, tag) {
 class TextNode extends LexicalNode {
   /** @internal */
 
+  __text;
   /** @internal */
-
+  __format;
   /** @internal */
-
+  __style;
   /** @internal */
-
+  __mode;
   /** @internal */
-
+  __detail;
   static getType() {
     return 'text';
   }
@@ -5485,6 +5500,10 @@ function $isTabNode(node) {
 }
 
 class Point {
+  key;
+  offset;
+  type;
+  _selection;
   constructor(key, offset, type) {
     {
       // This prevents a circular reference error when serialized as JSON,
@@ -5611,6 +5630,9 @@ function $transferStartingElementPointToTextPoint(start, end, format, style) {
   start.set(textNode.__key, 0, 'text');
 }
 class NodeSelection {
+  _nodes;
+  _cachedNodes;
+  dirty;
   constructor(objects) {
     this._cachedNodes = null;
     this._nodes = objects;
@@ -5734,6 +5756,12 @@ function $isRangeSelection(x) {
   return x instanceof RangeSelection;
 }
 class RangeSelection {
+  format;
+  style;
+  anchor;
+  focus;
+  _cachedNodes;
+  dirty;
   constructor(anchor, focus, format, style) {
     this.anchor = anchor;
     this.focus = focus;
@@ -6445,7 +6473,7 @@ class RangeSelection {
     }
     const firstPoint = this.isBackward() ? this.focus : this.anchor;
     const firstNode = firstPoint.getNode();
-    const firstBlock = $getAncestor(firstNode, INTERNAL_$isBlock);
+    const firstBlock = $findMatchingParent(firstNode, INTERNAL_$isBlock);
     const last = nodes[nodes.length - 1];
 
     // CASE 1: insert inside a code block
@@ -6494,7 +6522,7 @@ class RangeSelection {
       }
       insertRangeAfter(firstBlock, firstToInsert);
     }
-    const lastInsertedBlock = $getAncestor(nodeToSelect, INTERNAL_$isBlock);
+    const lastInsertedBlock = $findMatchingParent(nodeToSelect, INTERNAL_$isBlock);
     if (insertedParagraph && $isElementNode(lastInsertedBlock) && (insertedParagraph.canMergeWhenEmpty() || INTERNAL_$isBlock(lastToInsert))) {
       lastInsertedBlock.append(...insertedParagraph.getChildren());
       insertedParagraph.remove();
@@ -6524,7 +6552,7 @@ class RangeSelection {
       return paragraph;
     }
     const index = $removeTextAndSplitBlock(this);
-    const block = $getAncestor(this.anchor.getNode(), INTERNAL_$isBlock);
+    const block = $findMatchingParent(this.anchor.getNode(), INTERNAL_$isBlock);
     if (!$isElementNode(block)) {
       formatDevErrorMessage(`Expected ancestor to be a block ElementNode`);
     }
@@ -8653,6 +8681,9 @@ function updateEditor(editor, updateFn, options) {
  * A utility class for managing the DOM children of an ElementNode
  */
 class ElementDOMSlot {
+  element;
+  before;
+  after;
   constructor(/** The element returned by createDOM */
   element, /** All managed children will be inserted before this node, if defined */
   before, /** All managed children will be inserted after this node, if defined */
@@ -8738,7 +8769,7 @@ class ElementDOMSlot {
     if (lineBreakType === null) {
       this.removeManagedLineBreak();
     } else {
-      const webkitHack = lineBreakType === 'decorator' && (IS_IOS || IS_SAFARI);
+      const webkitHack = lineBreakType === 'decorator' && (IS_APPLE_WEBKIT || IS_IOS || IS_SAFARI);
       this.insertManagedLineBreak(webkitHack);
     }
   }
@@ -8842,23 +8873,23 @@ class ElementNode extends LexicalNode {
   /** @internal */
 
   /** @internal */
-
+  __first;
   /** @internal */
-
+  __last;
   /** @internal */
-
+  __size;
   /** @internal */
-
+  __format;
   /** @internal */
-
+  __style;
   /** @internal */
-
+  __indent;
   /** @internal */
-
+  __dir;
   /** @internal */
-
+  __textFormat;
   /** @internal */
-
+  __textStyle;
   constructor(key) {
     super(key);
     this.__first = null;
@@ -9469,6 +9500,15 @@ function isPointRemoved(point, nodesToRemoveKeySet, nodesToInsertKeySet) {
   return false;
 }
 
+/**
+ * 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.
+ *
+ */
+
+
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 
 /** @noInheritDoc */
@@ -9480,9 +9520,7 @@ class DecoratorNode extends LexicalNode {
    * The returned value is added to the LexicalEditor._decorators
    */
   decorate(editor, config) {
-    {
-      formatDevErrorMessage(`decorate: base method not extended`);
-    }
+    return null;
   }
   isIsolated() {
     return false;
@@ -9501,7 +9539,7 @@ function $isDecoratorNode(node) {
 /** @noInheritDoc */
 class RootNode extends ElementNode {
   /** @internal */
-
+  __cachedText;
   static getType() {
     return 'root';
   }
@@ -9623,7 +9661,17 @@ function exportNodeToJSON(node) {
   // @ts-expect-error
   return serializedNode;
 }
+/**
+ * Type guard that returns true if the argument is an EditorState
+ */
+function $isEditorState(x) {
+  return x instanceof EditorState;
+}
 class EditorState {
+  _nodeMap;
+  _selection;
+  _flushSync;
+  _readOnly;
   constructor(nodeMap, selection) {
     this._nodeMap = nodeMap;
     this._selection = selection || null;
@@ -10018,7 +10066,6 @@ function createEditor(editorConfig) {
         // uses LexicalNode in an otherwise incorrect way
         // by mocking its static getType
         klass !== LexicalNode) {
-          const proto = klass.prototype;
           ['getType', 'clone'].forEach(method => {
             if (!hasOwnStaticMethod(klass, method)) {
               console.warn(`${name} must implement static "${method}" method`);
@@ -10027,11 +10074,6 @@ function createEditor(editorConfig) {
           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 ($isDecoratorNode(proto)) {
-            if (proto.decorate === DecoratorNode.prototype.decorate) {
-              console.warn(`${proto.constructor.name} must implement "decorate" method`);
-            }
-          }
           if (!hasOwnStaticMethod(klass, 'importJSON')) {
             console.warn(`${name} should implement "importJSON" method to ensure JSON and default HTML serialization works as expected`);
           }
@@ -10071,66 +10113,68 @@ class LexicalEditor {
   /** @internal */
 
   /** The version with build identifiers for this editor (since 0.17.1) */
+  static version;
 
   /** @internal */
-
+  _headless;
   /** @internal */
-
+  _parentEditor;
   /** @internal */
-
+  _rootElement;
   /** @internal */
-
+  _editorState;
   /** @internal */
-
+  _pendingEditorState;
   /** @internal */
-
+  _compositionKey;
   /** @internal */
-
+  _deferred;
   /** @internal */
-
+  _keyToDOMMap;
   /** @internal */
-
+  _updates;
   /** @internal */
-
+  _updating;
   /** @internal */
-
+  _listeners;
   /** @internal */
-
+  _commands;
   /** @internal */
-
+  _nodes;
   /** @internal */
-
+  _decorators;
   /** @internal */
-
+  _pendingDecorators;
   /** @internal */
-
+  _config;
   /** @internal */
-
+  _dirtyType;
   /** @internal */
-
+  _cloneNotNeeded;
   /** @internal */
-
+  _dirtyLeaves;
   /** @internal */
-
+  _dirtyElements;
   /** @internal */
-
+  _normalizedNodes;
   /** @internal */
-
+  _updateTags;
   /** @internal */
-
+  _observer;
   /** @internal */
-
+  _key;
   /** @internal */
-
+  _onError;
   /** @internal */
-
+  _htmlConversions;
   /** @internal */
-
+  _window;
   /** @internal */
-
+  _editable;
   /** @internal */
-
+  _blockCursorElement;
   /** @internal */
+  _createEditorArgs;
 
   /** @internal */
   constructor(editorState, parentEditor, nodes, config, onError, htmlConversions, editable, createEditorArgs) {
@@ -10742,7 +10786,7 @@ class LexicalEditor {
     };
   }
 }
-LexicalEditor.version = "0.35.1-nightly.20250924.0+dev.cjs";
+LexicalEditor.version = "0.36.0+dev.cjs";
 
 let pendingNodeToClone = null;
 function setPendingNodeToClone(pendingNode) {
@@ -10780,6 +10824,8 @@ function getRegisteredNodeOrThrow(editor, nodeType) {
 function getRegisteredNode(editor, nodeType) {
   return editor._nodes.get(nodeType);
 }
+
+/** @internal */
 const scheduleMicroTask = typeof queueMicrotask === 'function' ? queueMicrotask : fn => {
   // No window prefix intended (#1400)
   Promise.resolve().then(fn);
@@ -12067,13 +12113,6 @@ function INTERNAL_$isBlock(node) {
   const isLeafElement = firstChild === null || $isLineBreakNode(firstChild) || $isTextNode(firstChild) || firstChild.isInline();
   return !node.isInline() && node.canBeEmpty() !== false && isLeafElement;
 }
-function $getAncestor(node, predicate) {
-  let parent = node;
-  while (parent !== null && parent.getParent() !== null && !predicate(parent)) {
-    parent = parent.getParentOrThrow();
-  }
-  return predicate(parent) ? parent : null;
-}
 
 /**
  * Utility function for accessing current active editor instance.
@@ -12433,6 +12472,7 @@ const FLIP_DIRECTION = {
  */
 
 class AbstractCaret {
+  origin;
   constructor(origin) {
     this.origin = origin;
   }
@@ -12615,6 +12655,7 @@ class AbstractSiblingCaret extends AbstractCaret {
 }
 class AbstractTextPointCaret extends AbstractCaret {
   type = 'text';
+  offset;
   constructor(origin, offset) {
     super(origin);
     this.offset = offset;
@@ -12831,6 +12872,9 @@ function $getAdjacentChildCaret(caret) {
 }
 class CaretRangeImpl {
   type = 'node-caret-range';
+  direction;
+  anchor;
+  focus;
   constructor(anchor, focus, direction) {
     this.anchor = anchor;
     this.focus = focus;
@@ -12882,6 +12926,8 @@ class CaretRangeImpl {
 }
 class TextPointCaretSliceImpl {
   type = 'slice';
+  caret;
+  distance;
   constructor(caret, distance) {
     this.caret = caret;
     this.distance = distance;
@@ -13675,6 +13721,165 @@ function $splitAtPointCaretNext(pointCaret, {
   return parentCaret;
 }
 
+/**
+ * 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.
+ *
+ */
+
+/**
+ * @experimental
+ * Define a LexicalExtension from the given object literal. TypeScript will
+ * infer Config and Name in most cases, but you may want to use
+ * {@link safeCast} for config if there are default fields or varying types.
+ *
+ * @param extension - The LexicalExtension
+ * @returns The unmodified extension argument (this is only an inference helper)
+ *
+ * @example
+ * Basic example
+ * ```ts
+ * export const MyExtension = defineExtension({
+ *   // Extension names must be unique in an editor
+ *   name: "my",
+ *   nodes: [MyNode],
+ * });
+ * ```
+ *
+ * @example
+ * Extension with optional configuration
+ * ```ts
+ * export interface ConfigurableConfig {
+ *   optional?: string;
+ *   required: number;
+ * }
+ * export const ConfigurableExtension = defineExtension({
+ *   name: "configurable",
+ *   // The Extension's config must satisfy the full config type,
+ *   // but using the Extension as a dependency never requires
+ *   // configuration and any partial of the config can be specified
+ *   config: safeCast<ConfigurableConfig>({ required: 1 }),
+ * });
+ * ```
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+function defineExtension(extension) {
+  return extension;
+}
+
+/**
+ * @experimental
+ * Override a partial of the configuration of an Extension, to be used
+ * in the dependencies array of another extension, or as
+ * an argument to {@link buildEditorFromExtensions}.
+ *
+ * Before building the editor, configurations will be merged using
+ * `extension.mergeConfig(extension, config)` or {@link shallowMergeConfig} if
+ * this is not directly implemented by the Extension.
+ *
+ * @param args - An extension followed by one or more config partials for that extension
+ * @returns `[extension, config, ...configs]`
+ *
+ * @example
+ * ```ts
+ * export const ReactDecoratorExtension = defineExtension({
+ *   name: "react-decorator",
+ *   dependencies: [
+ *     configExtension(ReactExtension, {
+ *       decorators: [<ReactDecorator />]
+ *     }),
+ *   ],
+ * });
+ * ```
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+function configExtension(...args) {
+  return args;
+}
+
+/**
+ * @experimental
+ * Used to declare a peer dependency of an extension in a type-safe way,
+ * requires the type parameter. The most common use case for peer dependencies
+ * is to avoid a direct import dependency, so you would want to use a
+ * type import or the import type (shown in below examples).
+ *
+ * @param name - The extension's name
+ * @param config - An optional config override
+ * @returns NormalizedPeerDependency
+ *
+ * @example
+ * ```ts
+ * import type {FooExtension} from "foo";
+ *
+ * export const PeerExtension = defineExtension({
+ *   name: 'PeerExtension',
+ *   peerDependencies: [
+ *     declarePeerDependency<FooExtension>("foo"),
+ *     declarePeerDependency<typeof import("bar").BarExtension>("bar", {config: "bar"}),
+ *   ],
+ * });
+ * ```
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+function declarePeerDependency(name, config) {
+  return [name, config];
+}
+
+/**
+ * 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.
+ *
+ */
+
+/**
+ * Explicitly and safely cast a value to a specific type when inference or
+ * satisfies isn't going to work as expected (often useful for the config
+ * property with {@link defineExtension})
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+function safeCast(value) {
+  return value;
+}
+
+/**
+ * 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.
+ *
+ */
+
+/**
+ * The default merge strategy for extension configuration is a shallow merge.
+ *
+ * @param config - A full config
+ * @param overrides - A partial config of overrides
+ * @returns config if there are no overrides, otherwise `{...config, ...overrides}`
+ */
+function shallowMergeConfig(config, overrides) {
+  if (!overrides || config === overrides) {
+    return config;
+  }
+  for (const k in overrides) {
+    if (config[k] !== overrides[k]) {
+      return {
+        ...config,
+        ...overrides
+      };
+    }
+  }
+  return config;
+}
+
 exports.$addUpdateTag = $addUpdateTag;
 exports.$applyNodeReplacement = $applyNodeReplacement;
 exports.$caretFromPoint = $caretFromPoint;
@@ -13711,6 +13916,7 @@ exports.$getNearestNodeFromDOMNode = $getNearestNodeFromDOMNode;
 exports.$getNearestRootOrShadowRoot = $getNearestRootOrShadowRoot;
 exports.$getNodeByKey = $getNodeByKey;
 exports.$getNodeByKeyOrThrow = $getNodeByKeyOrThrow;
+exports.$getNodeFromDOMNode = $getNodeFromDOMNode;
 exports.$getPreviousSelection = $getPreviousSelection;
 exports.$getRoot = $getRoot;
 exports.$getSelection = $getSelection;
@@ -13728,6 +13934,7 @@ exports.$insertNodes = $insertNodes;
 exports.$isBlockElementNode = $isBlockElementNode;
 exports.$isChildCaret = $isChildCaret;
 exports.$isDecoratorNode = $isDecoratorNode;
+exports.$isEditorState = $isEditorState;
 exports.$isElementNode = $isElementNode;
 exports.$isExtendableTextPointCaret = $isExtendableTextPointCaret;
 exports.$isInlineElementOrDecoratorNode = $isInlineElementOrDecoratorNode;
@@ -13841,10 +14048,13 @@ exports.TabNode = TabNode;
 exports.TextNode = TextNode;
 exports.UNDO_COMMAND = UNDO_COMMAND;
 exports.buildImportMap = buildImportMap;
+exports.configExtension = configExtension;
 exports.createCommand = createCommand;
 exports.createEditor = createEditor;
 exports.createSharedNodeState = createSharedNodeState;
 exports.createState = createState;
+exports.declarePeerDependency = declarePeerDependency;
+exports.defineExtension = defineExtension;
 exports.flipDirection = flipDirection;
 exports.getDOMOwnerDocument = getDOMOwnerDocument;
 exports.getDOMSelection = getDOMSelection;
@@ -13873,5 +14083,7 @@ exports.isSelectionWithinEditor = isSelectionWithinEditor;
 exports.makeStepwiseIterator = makeStepwiseIterator;
 exports.removeFromParent = removeFromParent;
 exports.resetRandomKey = resetRandomKey;
+exports.safeCast = safeCast;
 exports.setDOMUnmanaged = setDOMUnmanaged;
 exports.setNodeIndentFromDOM = setNodeIndentFromDOM;
+exports.shallowMergeConfig = shallowMergeConfig;