• node.getKey() 获取节点的 key 唯一标识符
  提示

  节点的唯一标识符 key 的数据类型是字符串，但内容是数字（除了 RootNode 根节点的 key 为 root）

• LexicalNode.getType() 获取节点的类型/名称
  提示

  该方法其实是 LexicalNode 类的静态方法，所有类型的节点都需要具有该方法

  返回的节点类型需要具有唯一性，即与（注册在当前编辑器中）其他节点名称不同

• node.isAttached() 返回一个布尔值，表示该节点是否已经添加到编辑器中（可以沿着节点树回溯找到 RootNode 根节点），如果返回 false（即节点并未插入到编辑器的节点树中），则 Lexical 在编辑器更新 DOM Reconciler 协调器不会对其进行处理，而且最终会被 Lexical 垃圾回收处理掉。
• node.is(otherNode) 返回一个布尔值，比较给定节点 otherNode 与当前节点是否为同一个节点
• node.getLatest() 从当前编辑器状态 editorState 中获取该节点的最新版本
  最新值

  通过该方法可以确保所获得的节点值是最新的，而避免从以前的引用获取到旧的节点的值

• node.getWritable() 获取一个可更新 mutable 版本的节点
  注意

  如果该方法在编辑器实例方法 editor.update(callbackFn) 的回调函数以外调用以上方法，会抛出错误提示

• node.getTextContent() 获取节点内的文本内容
  提示

  该方法供其他自定义节点覆写，以指定在（纯）文本中哪些内容表示这种类型的节点（例如在复制粘贴时）

  ElementNode 元素节点就覆写了该方法，获取其所有后代节点里所有 TextNode 文本节点，并将它们的内容拼接起来

• node.getTextContentSize() 获取节点内的文本的长度。其实是基于前一个方法 const str = node.getTextContent() 再通过 str.length() 得到字符串的长度
• node.isBefore(targetNode) 返回一个布尔值，判断当前节点是否在给定节点 targetNode 之前
• node.isDirty() 返回一个布尔值，表示该节点在当前更新流程中，是否被标记为 dirty 「脏节点」
• node.isSelected(selection?) 返回一个布尔值，表示该节点是否在给定的选区 selection 中

• node.markDirty() 手动将该节点标记为 dirty 「脏节点」，强制该节点在当前更新流程中被节点转换器 transform 以及 DOM reconciler 协调器处理
• node.remove(preserveEmptyParent?) 移除该节点，第二个（可选）参数 preserveEmptyParent 是一个布尔值，表示移除该节点后，如果造成其父节点内容为空，是否还需要保留该父节点（默认值为 false 即移除内容为空的父节点）
  提示

  可以通过设置父节点的方法 parentNode.canBeEmpty() 来覆写子节点以上方法所设置的行为

• node.replace(replaceWithNode, includeChildren?) 用给定的节点 replaceWithNode 替换当前节点，第二个（可选）参数 includeChildren 是一个布尔值，表示是否将原节点的内容（后代节点）转移到给定节点内
• LexicalNode.clone(_data) 返回该节点的一份克隆，该拷贝会具有不同的 key 唯一标识符，用于复制粘贴 ❓
  提示

  该方法其实是 LexicalNode 类的静态方法，所有类型的节点都需要具有该方法

• LexicalNode.transform() 为当前类型的节点设置一个节点转换器 transform，该方法是会在编辑器初始化时进行注册
  该方法返回的是一个函数 (node: LexicalNode) => void 作为节点转换器
  提示

  该方法其实是 LexicalNode 类的静态方法

  为特定节点类型添加/注册节点转换器 transform 更常见的方式是使用编辑器对象的方法 editor.registerNodeTransform()

• node.createDOM(_config, _editor) 该方法一般会被所继承的后代子类覆写，用于指定该类型的节点在页面上所对应的 DOM 元素结构。最后返回一个 HTML 元素
  该方法会接受两个参数
  • 第一个参数 _config 是编辑器的配置对象（一般用于获取 _config.theme 编辑器主题为相应的 DOM 元素添加 Class 类名）
  • 第二个参数 _editor 是编辑器实例
  注意

  该方法会在 Lexical 使用 DOM Reconciler 协调器（更新页面上的元素）时被调用，请不要在该方法中修改/更新编辑器状态 editorState，会触发循环更新

  该方法所返回的只能是单一个 HTML 元素，而不能具有嵌套节点 ❓

• node.updateDOM(_prevNode, _dom, _config) 当节点变化时，该方法会被调用，其作用主要是更新 DOM 元素，以便与节点的最新状态保持一致
  该方法的返回值是一个布尔值，表示更新节点时，是否需要调用上一个方法 node.createDOM() 方法重新创建一个新的 DOM 元素来取代页面上原有的旧元素
  提示

  该方法的返回值一般是 false，因为大部分节点在其生命周期中，所对应的 DOM 元素类型是一直不变的

  而对于节点某个属性变更后触发 DOM 元素类型变化，则该方法需要返回 true 以触发页面的 DOM 元素重新渲染

• node.exportDOM(editor) 该方法一般会被所继承的后代子类覆写，在导出节点时，将节点序列化为 DOM 元素（字符串）时会调用该方法。该方法会接受一个参数 editor 编辑器实例
  说明

  将节点序列化为 DOM 元素导出，一般发生在复制粘贴时，为了兼容 Lexical 与其他文本编辑器，以及不同命名空间的 Lexical 编辑器之间进行内容的复制粘贴

  
  该方法的返回值类型是 DOMExportOutput（Typescript 类型）的对象
  ts

  // DOMExportOutput 类型（对象）
  // * 属性 element 其值就是转换生成的 HTMLElement
  // 但是 element 属性值也可以是 null，这样该节点在序列化为 HTML 时就会「丢失」不见了
  // * 属性 after 是一个 hook，它是一个函数（以所生成的 element 作为入参），会在导出生成 HTML 元素后运行
  // 因为有时候需要对转换生成的 HTML 元素进一步处理，Lexical 为此提供了一个 API，即可实现对 HTMLElement 的「后处理」
  export type DOMExportOutput = {
    after?: (generatedElement: ?HTMLElement) => ?HTMLElement,
    element?: HTMLElement | null,
  };
  

• node.exportJSON() 该方法一般会被所继承的后代子类覆写，在导出节点时，将节点序列化为 JSON 格式（对象）时会调用该方法。
  说明

  将节点序列化为 JSON 格式导出，一般发生在相同命名空间的 Lexical 编辑器内/之间进行内容的复制粘贴

  而且 JSON（对象）格式很容易序列化为字符串（使用 JS 原生方法 JSON.stringify(value)），这样就可以将让数据更容易地在网络中传输或保存到数据库中

  注意

  该方法的返回值一个 JSON 对象，其中所包含的属性因不同类型的节点而异

  但是所有序列化后的节点都需要确保具有 type 字段和 version 字段 属性，以标注该 JSON 对象所对应的节点类型/名称以及版本

• LexicalNode.importJSON(_serializedNode) 该方法一般会被所继承的后代子类覆写，将 JSON 数据反序列化为节点时调用的方法，返回一个该节点实例
  提示

  该方法其实是 LexicalNode 类的静态方法，所以不需要实例化就可以直接调用该方法，基于传入的参数（序列化为 JSON 的节点）生成一个该节点的实例

• node.isParentOf(targetNode) 返回一个布尔值，判断当前的节点是否为给定节点 targetNode 的祖先节点
• node.getParent() 获取父节点，如果没有则返回 null
  提示

  如果希望没有获取到父节点时，在终端抛出错误提示（而不是返回 null）可以使用另一个方法 node.getParentOrThrow()

  该方法会在未获取到父节点时抛出 'Expected node {key} to have a parent.' 错误提示

• node.getParents() 获取祖先节点（直到 RootNode，包含根节点），返回一个数组（元素的顺序是按照祖先节点从里到外）
• node.getParentKeys() 获取祖先节点的 key 唯一标识符（直到 RootNode，包含根节点），返回一个数组（元素的顺序是按照祖先节点从里到外）
• node.getCommonAncestor(otherNode) 获取当前节点 node 与给定节点 otherNode 最近的共同祖先节点（ElementNode 元素节点），如果没有则返回 null （ ❓ 至少会返回 RootNode 根节点，除非其中一个节点就是根节点）
• node.getIndexWithinParent() 获取节点相对于其父节点的排序位置（索引值从 0 开始）
• node.getTopLevelElement() 获取该节点（沿着节点树回溯）最顶部的祖先（元素）节点，如果没有则返回 null
  说明

  最顶部的祖先节点并不包含根节点或影子根节点 ShadowRoot

  影子根节点 ShadowRoot 是指一些节点的行为类似于根节点，一般表示局部的节点树结构的终点/树根，例如表格的单元格节点 TableCellNode 就是影子根节点

  可以使用方法 $isRootOrShadowRoot(node) 判断给定的节点 node 是否为根节点或影子根节点 ShadowRoot

  提示

  如果希望没有获取到祖先节点时，在终端抛出错误提示（而不是返回 null）可以使用另一个方法 node.getTopLevelElementOrThrow()

  该方法会在未获取到父节点时抛出 'Expected node {key} to have a top parent element.' 错误提示

• node.isParentRequired() 返回一个布尔值，表示该节点存在时，是否需要有父节点将其包裹，一般在复制粘贴时会配合调用以下的 node.createParentElementNode() 方法，以保证在复制粘贴过程中节点的完整性
• node.createParentElementNode() 该方法一般会被所继承的后代子类覆写，用于创建父节点。返回一个 ElementNode 元素节点作为父节点
  说明

  当节点的方法 node.isParentRequired() 返回 true 时，在复制粘贴时会配合调用以上方法，以保证在复制粘贴过程中节点的完整性

  例如对于列表项节点，复制粘贴会包含相应的父节点（列表节点）

• node.getPreviousSibling() 获取该节点的前一个兄弟节点，如果没有则返回 null
• node.getPreviousSiblings() 获取该节点之前的所有兄弟节点，返回一个数组，里面包含这些兄弟节点
• node.getNextSibling() 获取该节点的下一个兄弟节点，如果没有则返回 null
• node.getNextSiblings() 获取该节点之后的所有兄弟节点，返回一个数组，里面包含这些兄弟节点
• node.getNodesBetween(targetNode) 获取该节点和给定的目标节点 targetNode 之间的节点，返回一个数组，里面包含当前节点 node 和目标节点 targetNode 以及它们之间的节点
  注意

  如果当前节点 node 和 目标节点 并不在同一个父节点下

  则可以将数组中所列出的节点，想象为沿着节点树从 node 节点到达 targetNode 所遇到的节点，即它们各自及其父节点，以及之间的节点（及其后代节点）都会被包含在其中

• node.insertBefore(nodeToInsert, restoreSelection?) 将给定的节点 nodeToInsert 插入到当前节点的前面（作为前一个兄弟节点），第二个（可选）参数 restoreSelection 是一个布尔值，以控制是否在插入节点之后，重新调整选区（将光标移到回当前节点的后面，在视觉上的效果就是光标保持不动）
• node.insertAfter(nodeToInsert, restoreSelection?) 将给定的节点 nodeToInsert 插入到当前节点的后面（作为下一个兄弟节点），第二个（可选）参数 restoreSelection 是一个布尔值，以控制是否在插入节点之后，重新调整选区（将光标移到所插入节点的后面）
• node.selectPrevious(anchorOffset?, focusOffset?) 将选区移动到上一个兄弟节点，第一个（可选）参数 anchorOffset 用于设置选区的锚点/固定点位置，第二个（可选）参数 focusOffset 用于设置选区的焦点/可移动点的位置
• node.selectNext(anchorOffset?, focusOffset?) 将选区移动到下一个兄弟节点，第一个（可选）参数 anchorOffset 用于设置选区的锚点/固定点位置，第二个（可选）参数 focusOffset 用于设置选区的焦点/可移动点的位置

• elementNode.canBeEmpty() 返回一个布尔值，用于设置元素节点是否允许内容为空的情况下依然存在
  提示

  如果子节点 node 通过调用方法 node.remove(false) 来移除自身时，造成父节点（一般是 ElementNode 元素节点）内容为空，则会同时删除父节点

  而以上方法如果返回 true 则会覆写子节点的行为，保留内容为空的父节点

• elementNode.canExtractContents() 返回一个布尔值，用于设置是否可以提取该节点的（文本 ❓ ）内容
  提示

  该方法可能 ❓ 是用于区分 TableNode 表格节点的，该节点不允许提取节点的文本内容（会丢失格式）

• elementNode.canIndent() 返回一个布尔值，用于表示元素节点是否允许设置缩进
• elementNode.canInsertAfter(targetNode) 返回一个布尔值，用于表示是否允许在该节点的后面插入目标节点 targetNode（作为兄弟节点）
  提示

  使用该方法可以对兄弟节点进行约束

  例如可以使用该方法来限制在列表项节点的后面只能插入的也是列表项节点

• elementNode.canInsertTextBefore() 返回一个布尔值，用于表示如果光标在节点最前面时继续输入文字的行为方式。如果返回 true（默认值）则文字会插入 prepend 到节点内（作为节点的内容）；如果返回 false 则会紧挨着链接节点创建一个段落节点（作为兄弟节点）来容纳新输入的文本
  提示

  例如对于 LinkNode 链接节点覆写了该方法，让返回值为 false

  所以在链接前面继续输入文本，并不会纳入到链接节点的范围中，可以在 Playground 尝试与链接节点进行交互，看看具体效果

• elementNode.canInsertTextAfter() 返回一个布尔值，用于表示如果光标在节点最后面时继续输入文字的行为方式。如果返回 true（默认值）则文字会插入 append 到节点内（作为节点的内容）；如果返回 false 则会紧挨着链接节点创建一个段落节点（作为兄弟节点）来容纳新输入的文本
  提示

  例如对于 LinkNode 链接节点覆写了该方法，让返回值为 false

  所以在链接后面继续输入文本，并不会纳入到链接节点的范围中，可以在 Playground 尝试与链接节点进行交互，看看具体效果

• elementNode.canMergeWith(targetNode) 返回一个布尔值，用于表示当前节点是否可以与给定的节点 targetNode 进行合并
  提示

  一般返回 false 即两个节点并不会融合

  但可以对该方法进行覆写，例如列表项节点可以与特定类型的节点/内容融合，以简化列表结构

• elementNode.canReplaceWith(targetNode) 返回一个布尔值，用于表示当前节点是否可以被给定的节点 targetNode 替换
  提示

  使用该方法可以约束粘贴替换的行为

  例如可以使用该方法来限制列表项节点只能被其他列表项节点替换，以保证列表的结构层次

• elementNode.excludeFromCopy(destination) 返回一个布尔值，以表示是否在复制中排除该节点。（可选）参数 destination 用于设置复制的特定场景，它的值可以是 "clone" 或 "html"
• elementNode.extractWithChild(child, selection, destination) 返回一个布尔值（默认值为 false），用于设置复制的行为。由于 ElementNode 元素节点一般不易选中，当复制该节点的子节点时，是否同时用该节点进行包裹。
  该方法会传入三个参数：
  • 第一个参数 child 是被选中的后代节点
  • 第二个参数 selection 是选区
  • 第三个参数 destination 表示复制的特定场景，它的值可以是 "clone" 或 "html"
  提示

  该方法用于 @lexical/clipboard 模块中，以实现复制粘贴的相关功能

  例如对于 HeadingNode 标题节点，覆写了该方法让返回值为 true，所以即使只是复制标题节点内的（部分）文本，再粘贴回编辑器也会是标题节点

• elementNode.getDirection() 返回元素节点种的文本书写方向，返回值是 "ltr" 表示从左往右，"rtl" 表示从右到左，如果没有设置则返回 null
• elementNode.getFormat() 返回元素节点中的文本对齐类型，返回值是数值
  不同的数值对应于不同的对齐类型
  • 1 表示左对齐 left
  • 2 表示居中对齐 right
  • 3 表示右对齐 center
  • 4 表示两端对齐 justify
  • 5 表示（根据文本的书写方向的）起始对齐 start
  • 6 表示（根据文本的书写方向的）结束对齐 end
• elementNode.getFormatType() 返回元素节点中的文本对齐类型，返回值是字符串 "left" | "right" | "center" | "justify" | "start" | "end" 如果没有设置则返回 "" 空字符串
• elementNode.hasFormat(type) 返回一个布尔值，表示节点的对齐类型和给定的类型 type 一致。传入的参数 type 可以是 "left" | "right" | "center" | "justify" | "start" | "end" | ""（空字符串） 这些字符串中的任一值
• elementNode.getIndent() 返回元素节点的缩进值，返回值是数值
• elementNode.getTextContent() 获取节点内的文本内容（包含所有后代节点里所有 TextNode 文本节点，并将它们的内容拼接起来，而且在块元素的文本之间添加了双换行符 \n\n）
• elementNode.getTextContentSize() 获取节点内的文本的长度。其实是基于前一个方法 const str = node.getTextContent() 再通过 str.length() 得到字符串的长度
• elementNode.isDirty() 返回一个布尔值，表示该节点在当前更新流程中，是否被标记为 dirty 「脏节点」
• elementNode.isEmpty() 返回一个布尔值，表示该节点内容是否为空（即没有子节点）
• elementNode.isInline() 返回一个布尔值，表示该节点内容是否为行内节点
• elementNode.isLastChild() 返回一个布尔值，表示该节点内容是否作为其父节点的最后一个子节点
• elementNode.isShadowRoot() 返回一个布尔值，表示该节点是否作为影子根节点
  影子根节点

  影子根节点 ShadowRoot 是指一些节点的行为类似于根节点，一般表示局部节点树结构的终点/树根，例如表格的单元格节点 TableCellNode 就是影子根节点

  也可以使用方法 $isRootOrShadowRoot(node) 判断给定的节点 node 是否为根节点或影子根节点 ShadowRoot

• elementNode.clear() 移除该节点内部的所有后代节点
• elementNode.collapseAtStart(selection) 该方法是在光标位于节点的开头（即选区的锚点 anchor 位于该节点，且偏移量 offset 为 0 时），并且用户按下 Backspace 键时调用的。传入的参数 selection 是 RangeSelection 范围选区
  该方法返回一个布尔值，用来表示该方法是否已经处理完用户的操作交互。如果返回 false 则除了执行该函数中的一些逻辑，Lexical 在后台还会继续执行一些（关于删除单个字符的）通用处理逻辑
  注意

  该方法用于删除单个字符的场景（具体参考核心模块的文件 LexicalSelection 源码中的 deleteCharacter 方法）

  但是一般情况下该方法其实并不会被调用，由于 ElementNode 元素节点一般作为容器，所以它会包含子节点（如文本节点），当光标从视觉上移动这些节点开头，但是实际上选区的锚点 anchor 依然位于子节点内（一般是位于文本节点的开头），所以当用户按下 Backspace 键时并没有调用相应的元素节点的 collapseAtStart 方法，而是执行删除单个字符的通用处理逻辑

  如果要测试以上方法，则可以将节点置于编辑器的开头，在这个特殊的位置按下 Backspace 键，一般都会触发元素节点的 collapseAtStart 方法，因为按下多次 Backspace 键后，将 ElementNode 元素节点的内容/子节点都删除掉以后，就可以保证光标真的触达元素节点的开头了

  所以对于一些元素节点，它们位于编辑器的开头与位于中间，行为会有所不同

  具体可以参考官方编写的一些元素节点实例

  • ParagraphNode 段落节点
  • HeadingNode 标题节点
  • QuoteNode 引文节点
  • LexicalListItemNode 列表项节点
  • CodeNode 代码（块）节点
• elementNode.insertNewAfter(selection, restoreSelection?) 设置在该节点上按 Enter 回车键时的行为（一般处理逻辑是根据光标锚点的位置而插入不同类型的节点）。第一个参数 selection 是范围选区，第二个（可选）参数 restoreSelection 是一个布尔值，以控制是否在插入节点之后，是否重新调整选区（将光标移到所插入节点里）。返回值是新插入的节点或 null（如果该操作没有插入节点）
• elementNode.setDirection(direction) 设置文本书写方向，传入的参数 direction 可以是 "ltr" | "rtl" | null 这些中的任一值
• elementNode.setFormat(type) 设置文本对齐类型，传入的参数 type 可以是 "left" | "right" | "center" | "justify" | "start" | "end" | ""（空字符串） 这些字符串中的任一值
• elementNode.setIndent(indentLevel) 设置节点的缩进级别，传入的参数 indentLevel 是数值，表示缩进的级别
• elementNode.splice(start, deleteCount, nodesToInsert) 在特定的索引值 start 位置删除特定数量的 deleteCount 的子节点，并在后面插入给定的一系列节点 nodesToInsert（数组）作为子节点

• elementNode.exportJSON() 在导出节点时，将节点序列化为 JSON 格式（对象）时会调用该方法。
  说明

  该方法覆写了父类 LexicalNode 核心节点的对应方法，提供了元素节点序列化 JSON 对象的模板

  ts

  // 返回的 JSON 对象模板
  {
    children: [], // 所包含的子节点
    direction: this.getDirection(), // 书写方向
    format: this.getFormatType(), // 对齐方式
    indent: this.getIndent(), // 缩进级别
    type: 'element', // 节点类型名称
    version: 1, // 节点版本
  }
  

  除了所有节点都需要确保具有 type 字段和 version 字段 属性，ElementNode 还必须要有 children、direction 等属性，以描述元素节点的相关信息

  该方法一般会被所继承的后代子类覆写，在返回的 JSON 对象中增添更多的属性

• elementNode.getFirstChild() 获取该节点的第一个（直接）子节点（即节点的属性 __first 所指向的子节点），如果未能获取相应的子节点则返回 null
  提示

  如果希望没有获取到子节点时，在终端抛出错误提示（而不是返回 null）可以使用另一个方法 elementNode.getFirstChildOrThrow()

  该方法会在未获取到子节点时抛出 'Expected node {key} to have a first child.' 错误提示

• elementNode.getLastChild() 获取该节点的最后一个（直接）子节点（即节点的属性 __last 所指向的子节点），如果未能获取相应的子节点则返回 null
  提示

  如果希望没有获取到子节点时，在终端抛出错误提示（而不是返回 null）可以使用另一个方法 elementNode.getLastChildOrThrow()

  该方法会在未获取到子节点时抛出 'Expected node {key} to have a last child.' 错误提示

• elementNode.getChildrenKeys() 获取所有子节点的 key 唯一标识符，返回一个数组
• elementNode.getChildrenSize() 返回所包含的子节点数量
• elementNode.getChildAtIndex(index) 根据给定索引 index 获取该节点的某个（直接）子节点，如果未能获取相应的子节点（索引值不在范围中）则返回 null
• elementNode.getFirstDescendant() 获取「第一个」末端节点。如果元素节点本来就没有子节点则返回 null
  说明

  这里所说的后代节点是指在节点树种「末端」的节点（即没有子节点的元素节点，或叶子节点）

  
  这里所指的「第一个」是指按照节点 __first 属性所指向的子节点，以上方法就是按照此规则进行递归寻找，直至找到「末端」的节点
• elementNode.getLastDescendant() 获取「最后一个」末端节点。如果元素节点本来就没有子节点则返回 null
  说明

  这里所说的后代节点是指在节点树种「末端」的节点（即没有子节点的元素节点，或叶子节点）

  
  这里所指的「最后一个」是指按照节点 __last 属性所指向的子节点，以上方法就是按照此规则进行递归寻找，直至找到「末端」的节点
• elementNode.getDescendantByIndex(index) 根据给定索引 index 获取该节点的末端节点，如果未能获取相应的子节点则返回 null
  如果传入的参数 index 比直接子节点的数量大，则获取「最后一个」末端节点。
  如果传入的参数 index 在直接子节点的数量范围中，则先判断索引所对应的直接子节点是否就是末端节点，如果是则直接返回；如果不是则获取「第一个」末端节点
  说明

  这里所说的后代节点是指在节点树种「末端」的节点（即没有子节点的元素节点，或叶子节点）

  「最后一个」是指按照节点 __last 属性所指向的子节点，并按照此规则进行递归寻找，直至找到「末端」的节点

  「第一个」是指按照节点 __first 属性所指向的子节点，并按照此规则进行递归寻找，直至找到「末端」的节点

• elementNode.append(nodesToAppend) 将给定的一系列节点 nodesToAppend（数组）插入到该元素节点内，作为最后的子节点
• elementNode.getAllTextNodes() 获取该节点内的所有文本节点，返回一个数组，里面包含一系列的文本节点（以递归的方式获取文本节点，所以包括嵌套在后代节点中的文本节点）

• elementNode.select(_anchorOffset?, _focusOffset?) 根据传入的（可选）参数 _anchorOffset 和 _focusOffset 作用选区的锚点偏移量和焦点偏移量（以选中该元素节点内的子节点），返回所创建的 RageSelection 范围选区
• elementNode.selectStart() 将光标移动到「第一个」末端节点的开头（从视觉上其效果就相当于将光标移动到该元素节点的开头）
  说明

  末端节点是指即没有子节点的元素节点，或叶子节点

  「第一个」是指按照节点 __first 属性所指向的子节点，并按照此规则进行递归寻找，直至找到「末端」的节点

• elementNode.selectEnd() 将光标移动到「最后一个」末端节点的结尾（从视觉上其效果就相当于将光标移动到该元素节点的尾部）
  说明

  末端节点是指即没有子节点的元素节点，或叶子节点

  「最后一个」是指按照节点 __last 属性所指向的子节点，并按照此规则进行递归寻找，直至找到「末端」的节点

在文本节点中所使用的一些概念

format 格式：可以是 bold、italic、underline、strikethrough、code、subscript、superscript 这些值的组合

mode 模式：可以是 normal、token、segmented 这三种模式之一

• 如果为 token 表示该节点是不可变的 immutable，它的内容不可更改，在删除时只能整体删掉
• 如果为 segmented 表示该节点的内容是片段化的，即在删除内容时，每次删掉一个单词。所以该节点是可编辑的，但是内容更新后就会变成非片段化的 ❓

style 样式：用于为文本添加行内 CSS 样式

以下是获取文本节点信息的一些方法

• TextNode.getType() 获取节点的类型/名称
  该节点覆写了父节点（LexicalNode 核心节点）的相应方法，返回值为 'text'
  提示

  该方法其实是 TextNode 类的静态方法，所以不需要实例化就可以直接调用该方法

• textNode.canInsertTextAfter() 返回 true，用于表示如果光标在节点最后面时继续输入文字，则文字会插入 append 到节点内（作为节点的内容）
  提示

  如果返回 false 则会紧挨着该节点创建一个兄弟节点来容纳新输入的文本

  例如官方基于 TextNode 所创建的一个子类 TabNode 它用来表示一个缩进，并不允许在该节点中添加文本，所以要覆写该方法返回 false

• textNode.canInsertTextBefore() 和上一个方法类似，也是返回 true，表示在节点前可以继续输入文字
• textNode.getDetail() 一个 32 位的整数，关于书写方向和是否可进行节点融合的信息
  提示

  该方法所返回的是一个数值，可读性较低

  可以分别调用 textNode.isUnmergeable() 和 textNode.isDirectionless() 方法获取节点相应的信息

• textNode.isUnmergeable() 返回一个布尔值，以表示节点是否不可以和临近的兄弟文本节点进行 merge 连接/融合为一个文本节点
• textNode.getFormat() 返回一个 32 位的整数，表示节点所设有的格式
  提示

  还有另一个类似的方法 textNode.getFormat(type, alignWithFormat) 也是返回一个 32 位的整数，表示节点所设有的格式

  这些方法所返回的是一个数值，可读性较低

  可以调用 textNode.hasFormat(textFormatType) 方法检测文本节点是否具有某种格式

• textNode.hasFormat(type) 返回一个布尔值，以表示文本节点是否具有给定的 type 格式
  其中入参 type 可以是 "bold"、"underline"、"strikethrough"、"italic"、"highlight"、"code"、"subscript" 或 "superscript"
• textNode.getMode() 获取文本节点的模式，可以是 normal | token | segmented 这三种模式之一
• textNode.getStyle() 获取应用于文本节点所对应的 DOM 元素的行内 CSS 样式（字符串）
• textNode.getTextContent() 获取节点的文本内容
  该节点覆写了父节点（LexicalNode 核心节点）的相应方法
• textNode.isComposing() 返回一个布尔值，表示检测文本节点的内容是否正在处于「组合」输入模式
  说明

  「组合」输入模式是指通过 IME 或第三方扩展接收输入时（最终输出的内容并不是键盘上的字母，而是转换为其他语言符号）

  通过该方法可以判断用户是否使用 IME 输入法并正在输入时，如果是则编辑器一般不执行相关的逻辑处理，要等到真正的内容键入/插入到编辑器中再执行相关的处理

• textNode.isDirectionless() 返回一个布尔值，表示文本内容排版并不受 RTL 从右往左或 LTR 从左往右的书写方式的影响
• textNode.isSegmented() 返回一个布尔值，表示节点的模式是否为 segmented
  提示

  如果节点的 mode 模式是 segmented 则节点的内容是片段化的，即使用光标导航时，会按照单词为单位，例如在删除内容时，每次删掉一个单词（以空格为标准）

• textNode.isToken() 返回一个布尔值，表示节点的模式是否为 token
  提示

  如果节点的 mode 模式是 token 则节点的内容不可更改，使用光标导航时，会按照单词为单位，而在删除内容时，只能整体删掉

• textNode.isSimpleText() 返回一个布尔值，表示该节点是否为文本节点（节点类型 type 为 text而不是文本节点子类），而且节点并不处于 segmented 或 token 这两种特殊的模式下
• textNode.isTextEntity() 返回一个布尔值，表示编辑器是否针对该类型的节点，使用 registerLexicalTextEntity 注册了一个节点转换器
  说明

  使用 editor.registerLexicalTextEntity 方法注册的节点转换器会根据文本内容的匹配模式而对节点进行转换

• textNode.mergeWithSibling(targetTextNode) 将给定的文本节点 targetTextNode 与当前文本节点融合（提取出内容，追加到当前节点内），并删除这个给定的文本节点
• textNode.setDetail(detail) 用于设置节点的 __detail 属性（关于书写方向和是否可进行节点融合的信息），参数 detail 是一个 32 位的整数或 'directionless' | 'unmergable' 这两个字符串之一
• textNode.toggleDirectionless() 切换节点的文本内容排版是否受书写方式影响的状态
• textNode.toggleUnmergeable() 切换文本节点的可否 merge 的属性
• textNode.setFormat(format) 为节点设置格式，每次只能设置一种格式，⚠️ 而且该方法会覆盖/移除掉文本原本已有的格式。参数 format 可以是一个表示格式的 32 位的整数或 bold | italic | underline | strikethrough | code | subscript | superscript 这些字符串之一
• textNode.toggleFormat(type) 为节点切换（添加或移除）给定的格式 type，并不影响其他类型的格式
• textNode.setMode(type) 为文本节点设置模式。其中入参 type 可以是 "normal" | "token" | "segmented" 这三个字符串之一
• textNode.setStyle(type) 为文本节点所对应的 DOM 元素设置行内 CSS 样式。参数 type 是字符串，作为 inline style
• textNode.setTextContent(str) 为文本节点设置内容
• textNode.spliceText(offset, delCount, newText, moveSelection?) 在特定的位置 offset 删除特定数量 delCount 字符，并插入新的内容 newText 旧文本并插入新文本。最后的（可选）参数 moveSelection 是一个布尔值，以决定是否将光标移动到插入内容的最后
• textNode.splitText(splitOffsets) 将一个文本节点「切分」为多个文本节点，并以这些文本节点取代原来的文本节点。返回一个数组，包含切分后的文本节点
  其中入参 splitOffsets 是一个数组，里面的元素都是数字，表示切分的位置
• TextNode.clone(targetTextNode) 返回该节点的一份克隆，用于复制粘贴 ❓
  该节点覆写了父节点（LexicalNode 核心节点）的相应方法，返回一个文本节点，与给定的文本节点 targetTextNode 具有相同的内容和相同的 key 唯一标识符
  提示

  该方法其实是 TextNode 类的静态方法，所以不需要实例化就可以直接调用该方法，基于传入的文本节点生成一个拷贝

• textNode.createDOM(config) 用于指定该节点在页面上所对应的 DOM 元素结构。参数 config 是编辑器的配置对象（一般用于获取 config.theme 编辑器主题为相应的 DOM 元素添加 Class 类名）。最后返回一个 HTML 元素。
  提示

  该节点覆写了父节点（LexicalNode 核心节点）的相应方法，返回的 HTML 元素会根据文本节点的格式而不同

  而且一些格式会对应于外层标签 Outer Tag，一些格式会对应于内层标签 Inner tag

  与外层标签 Outer Tag 相关的格式（如果没有以下的格式，则不设置外层标签）

  • 如果文本节点具有 code 格式，则返回一个 <code></code> 元素
  • 如果文本节点具有 highlight 格式，则返回一个 <mark></mark> 元素
  • 如果文本节点具有 subscript 格式，则返回一个 <sub></sub> 元素
  • 如果文本节点具有 superscript 格式，则返回一个 <sup></sup> 元素

  与内层标签 Inner Tag 相关的格式（如果没有以下的格式，则内层标签为 <span></span> 标签）

  • 如果文本节点具有 strong 格式，则返回一个 <strong></strong> 元素
  • 如果文本节点具有 italic 格式，则返回一个 <em></em> 元素

  然后将外层元素和内层元素进行整合，返回一个 HTML 元素

  例如对于具有 highlight 和 strong 的文本节点，最终返回的 HTML 元素是 <mark><strong></strong></mark>

  并从编辑器主题中 config.theme.text 获取相应的 Class 类名添加到元素上

• textNode.updateDOM(prevNode, dom, config) 当节点变化时，该方法会被调用，其作用主要是更新 DOM 元素，以便与节点的最新状态保持一致
  该节点覆写了祖先节点（LexicalNode 核心节点）的相应方法，根据文本节点的格式的不同，执行不同的逻辑（如果格式的改变导致文本节点所对应 HTML 元素改变，则返回 true，表示需要调用方法 textNode.createDOM() 重新渲染页面相应的 DOM 元素；如果格式的改变没有导致 HTML 元素改变，则返回 false）

• textNode.exportDOM(editor) 在导出节点时，将节点序列化为 DOM 元素（字符串）时会调用该方法。该方法会接受一个参数 editor 编辑器实例
  该节点覆写了父节点（LexicalNode 核心节点）的相应方法，以实现具体的逻辑
• textNode.exportJSON() 在导出节点时，将节点序列化为 JSON 格式（对象）时会调用该方法。
  说明

  该方法覆写了父类 LexicalNode 核心节点的对应方法，提供了元素节点序列化 JSON 对象的模板

  ts

  // 返回的 JSON 对象模板
  {
    detail: this.getDetail(), // 一个 32位的整数，关于书写方向和是否可进行节点融合的信息
    format: this.getFormat(), // 对齐方式
    mode: this.getMode(), // 模式，`normal`、`token`、`segmented`这三个值之一
    style: this.getStyle(), // CSS 样式
    text: this.getTextContent(), // 文本内容
    type: 'text', // 节点类型名称
    version: 1, // 节点版本
  };
  

• TextNode.importDOM() 将 HTML 元素反序列化为节点时调用的方法
  该方法返回的是一个 DOMConversionMap 类型的值（表示转换成功）或 null（表示该 DOM 与当前的节点不匹配，转换失败，会被更低级的转换函数进行处理）
  说明

  DOMConversionMap 类型是一个映射，具体介绍可以查看另一篇笔记的相关章节

  该节点转换一系列的 HTML 元素（对应于含有不同 format 格式的文本），具体可以查看相关源码

  提示

  该方法其实是静态方法，所以不需要实例化就可以直接调用该方法，基于传入的参数（序列化为 HTML 的节点）生成一个该节点的实例

• TextNode.importJSON(serializedNode) 将 JSON 数据反序列化为节点时调用的方法，返回一个该节点实例
  该节点覆写了父节点（LexicalNode 核心节点）的相应方法，以实现具体的逻辑
  提示

  该方法其实是静态方法，所以不需要实例化就可以直接调用该方法，基于传入的参数（序列化为 JSON 的节点）生成一个该节点的实例

• textNode.select(_anchorOffset?, _focusOffset?) 根据传入的（可选）参数 _anchorOffset 和 _focusOffset 作用选区的锚点偏移量和焦点偏移量（以选中节点中的相应字符），返回所创建的 RageSelection 范围选区
• textNode.selectionTransform(prevSelection, nextSelection) 在选区发生变化时，如果锚点或焦点位于该节点中，则会执行该方法所设置的逻辑 ❓

• decoratorNode.decorate(editor, config) 该方法一般会被所继承的后代子类覆写，用于设置装饰节点的具体实现，例如返回一个虚拟 DOM 或组件等。第一个参数 editor 是编辑器对象，第二个参数 config 是编辑器的配置对象
• decoratorNode.isInline() 返回一个布尔值，表示该装饰节点是否为行内元素
• decoratorNode.isIsolated() 返回一个布尔值，表示该节点是否脱离编辑器文档的瀑布流 ❓
• decoratorNode.isKeyboardSelectable() 返回一个布尔值，表示是否可以通过键盘导航选中（创建一个节点选区） ❓

• LineBreakNode.getType() 获取节点的类型/名称
  该节点覆写了父节点（LexicalNode 核心节点）的相应方法，返回值为 'linebreak'
  提示

  该方法其实是 LineBreakNode 类的静态方法，所以不需要实例化就可以直接调用该方法

• lineBreakNode.getTextContent() 获取节点内的文本内容
  该节点覆写了父节点（LexicalNode 核心节点）的相应方法，返回值恒为 \n，即在（纯）文本中 \n 字符串表示换行节点（例如在复制粘贴时）

• LineBreakNode.clone(targetLineBreakNode) 返回该节点的一份克隆，用于复制粘贴 ❓
  该节点覆写了父节点（LexicalNode 核心节点）的相应方法，返回一个换行节点，与给定的换行节点 targetLineBreakNode 具有相同的 key 唯一标识符
  提示

  该方法其实是 LineBreakNode 类的静态方法，所以不需要实例化就可以直接调用该方法，基于传入的换行节点生成一个拷贝

• lineBreakNode.createDOM() 用于指定该节点在页面上所对应的 DOM 元素结构。
  该节点覆写了父节点（LexicalNode 核心节点）的相应方法，返回的 HTML 元素是 <br>
• lineBreakNode.updateDOM(prevNode, dom, config) 当节点变化时，该方法会被调用，其作用主要是更新 DOM 元素，以便与节点的最新状态保持一致
  该节点覆写了父节点（LexicalNode 核心节点）的相应方法，返回 false 表示不需要重新创建一个新的 DOM 元素来取代页面上原有的旧元素

• lineBreakNode.exportJSON() 在导出节点时，将节点序列化为 JSON 格式（对象）时会调用该方法。
  该节点覆写了父节点（LexicalNode 核心节点）的相应方法，以实现具体的逻辑
  换行节点的 JSON 格式

  换行节点序列化为 JSON 对象具有如下属性

  ts

  // 返回的 JSON 对象
  {
    type: 'linebreak', // 节点类型名称
    version: 1, // 节点版本
  }
  

• LineBreakNode.importJSON(serializedNode) 将 JSON 数据反序列化为节点时调用的方法，返回一个该节点实例
  该节点覆写了父节点（LexicalNode 核心节点）的相应方法，以实现具体的逻辑
  提示

  该方法其实是静态方法，所以不需要实例化就可以直接调用该方法，基于传入的参数（序列化为 JSON 的节点）生成一个该节点的实例

• LineBreakNode.importDOM() 将 HTML 元素反序列化为节点时调用的方法
  该方法根据当前节点的父节点的不同情况，返回一个 DOMConversionMap 类型的值（表示转换成功）或 null（表示该 DOM 与当前的节点不匹配，转换失败，会被更低级的转换函数进行处理），如果当前节点作为其父节点的唯一子节点，则跳过解析导入（相当于对于单独存在的 <br> 元素进行「压缩」/省略的处理）
  说明

  DOMConversionMap 类型是一个映射，具体介绍可以查看另一篇笔记的相关章节

  提示

  该方法其实是静态方法，所以不需要实例化就可以直接调用该方法，基于传入的参数（序列化为 HTML 的节点）生成一个该节点的实例

• RootNode.getType() 获取节点的类型/名称
  该节点覆写了祖先节点（LexicalNode 核心节点）的相应方法，返回值为 'root'
  提示

  该方法其实是 RootNode 类的静态方法，所以不需要实例化就可以直接调用该方法

• rootNode.getTextContent() 获取编辑器内的所有文本内容
  该节点覆写了父节点（ElementNode 元素节点）的相应方法，参考相关的源码会先判断编辑器是否处于只读模式，如果是则返回 cachedText 缓存的文本 ❓ 如果不是则调用父节点的相应，即返回编辑器内的所有文本节点的内容

• rootNode.collapseAtStart() 该方法是在光标位于节点的开头（即选区的锚点 anchor 位于该节点，且偏移量 offset 为 0 时），并且用户按下 Backspace 键时调用的。
  该节点覆写了父节点（ElementNode 元素节点）的相应方法，参考相关的源码该函数内部并没有进行任何其他处理就直接返回 true（以表示完成了对用户操作交互的响应），即光标在根节点的开头时，如果用户按下 Backspace 键，在视觉上是看不出任何的响应操作的
  注意

  该方法用于删除单个字符的场景（具体参考核心模块的文件 LexicalSelection 源码中的 deleteCharacter 方法）

  但是一般情况下该方法其实并不会被调用，由于 ElementNode 元素节点一般作为容器，所以它会包含子节点（如文本节点），当光标从视觉上移动这些节点开头，但是实际上选区的锚点 anchor 依然位于子节点内（一般是位于文本节点的开头），所以当用户按下 Backspace 键时并没有调用相应的元素节点的 collapseAtStart 方法，而是执行删除单个字符的通用处理逻辑

• rootNode.remove() 该节点覆写了祖先节点（LexicalNode 核心节点）的相应方法。该方法原本的目的是移除该节点，但是由于根节点是（倒置）节点树的最顶部的节点，所以它一般需要存在（不允许删除），所以这里该方法必然会抛出错误提示 'remove: cannot be called on root nodes'
• rootNode.replace(replaceWithNode) 该节点覆写了祖先节点（LexicalNode 核心节点）的相应方法。该方法原本的目的是用给定的节点 replaceWithNode 替换当前节点，但是由于根节点是（倒置）节点树的最顶部的节点，所以它一般不允许被替换为其他节点，所以这里该方法必然会抛出错误提示 'replace: cannot be called on root nodes'
• RootNode.clone() 返回该节点的一份克隆，用于复制粘贴 ❓
  该节点覆写了祖先节点（LexicalNode 核心节点）的相应方法，返回一个根节点，该拷贝会具有不同的 key 唯一标识符，用于复制粘贴 ❓
  提示

  该方法其实是 RootNode 类的静态方法，所以不需要实例化就可以直接调用该方法，生成一个根节点拷贝

• rootNode.updateDOM(prevNode, dom) 当节点变化时，该方法会被调用，其作用主要是更新 DOM 元素，以便与节点的最新状态保持一致
  该节点覆写了祖先节点（LexicalNode 核心节点）的相应方法，直接返回 false 表示不需要重新创建一个新的 DOM 元素来取代页面上原有的旧元素

• rootNode.exportJSON() 在导出节点时，将节点序列化为 JSON 格式（对象）时会调用该方法。
  该节点覆写了父节点（ElementNode 元素节点）的相应方法，以实现具体的逻辑
  根节点的 JSON 格式

  根节点序列化为 JSON 对象具有如下属性

  ts

  // 返回的 JSON 对象
  {
    children: [], // 所包含的子节点
    direction: this.getDirection(), // 书写方向
    format: this.getFormatType(), // 对齐方式
    indent: this.getIndent(), // 缩进级别
    type: 'root', // 节点类型名称
    version: 1, // 节点版本
  }
  

• RootNode.importJSON(serializedNode) 将 JSON 数据反序列化为节点时调用的方法，返回一个该节点实例
  该节点覆写了祖先节点（LexicalNode 核心节点）的相应方法，以实现具体的逻辑
  提示

  该方法其实是静态方法，所以不需要实例化就可以直接调用该方法，基于传入的参数（序列化为 JSON 的节点）生成一个该节点的实例

• rootNode.getTopLevelElementOrThrow() 该节点覆写了祖先节点（LexicalNode 核心节点）的相应方法。该方法原本的目的是获取该节点（沿着节点树回溯）最顶部的祖先（元素）节点，但是由于根节点是（倒置）节点树的最顶部的节点，所以这里该方法必然会抛出错误提示 'getTopLevelElementOrThrow: root nodes are not top level elements'
  说明

  最顶部的祖先节点并不包含根节点或影子根节点 ShadowRoot

• rootNode.insertAfter(nodeToInsert) 该节点覆写了祖先节点（LexicalNode 核心节点）的相应方法。该方法原本的目的是将给定的节点 nodeToInsert 插入到当前节点的后面（作为下一个兄弟节点），但是由于根节点是（倒置）节点树的最顶部的节点，所以不允许有兄弟节点，所以这里该方法必然会抛出错误提示 'insertAfter: cannot be called on root nodes'
• rootNode.insertBefore(nodeToInsert) 该节点覆写了祖先节点（LexicalNode 核心节点）的相应方法。该方法原本的目的是将给定的节点 nodeToInsert 插入到当前节点的前面（作为前一个兄弟节点），但是由于根节点是（倒置）节点树的最顶部的节点，所以不允许有兄弟节点，所以这里该方法必然会抛出错误提示 'insertBefore: cannot be called on root nodes'

• rootNode.append(nodes) 将给定的列表中的一系列节点 nodes（数组）插入到根节点内，作为最后的子元素
  注意

  只有 ElementNode 元素节点或 DecoratorNode 装饰节点才可以作为 rootNode 根节点的直接子节点，即以上方法中所传入的参数 [nodes] 列表中的节点不能是 TextNode 文本节点（或它的子类）

• ParagraphNode.getType() 获取节点的类型/名称
  该节点覆写了祖先节点（LexicalNode 核心节点）的相应方法，返回值为 'paragraph'
  提示

  该方法其实是 ParagraphNode 类的静态方法，所以不需要实例化就可以直接调用该方法

• paragraphNode.collapseAtStart() 该方法是在光标位于节点的开头（即选区的锚点 anchor 位于该节点，且偏移量 offset 为 0 时），并且用户按下 Backspace 键时调用的。
  该方法返回一个布尔值，用来表示该方法是否已经处理完用户的操作交互。如果返回 false 则除了执行该函数中的一些逻辑，Lexical 在后台还会继续执行一些（关于删除单个字符的）通用处理逻辑
  注意

  该方法用于删除单个字符的场景（具体参考核心模块的文件 LexicalSelection 源码中的 deleteCharacter 方法）

  但是一般情况下该方法其实并不会被调用，由于 ElementNode 元素节点一般作为容器，所以它会包含子节点（如文本节点），当光标从视觉上移动这些节点开头，但是实际上选区的锚点 anchor 依然位于子节点内（一般是位于文本节点的开头），所以当用户按下 Backspace 键时并没有调用相应的元素节点的 collapseAtStart 方法，而是执行删除单个字符的通用处理逻辑

  如果要测试以上方法，则可以将节点置于编辑器的开头，在这个特殊的位置按下 Backspace 键，一般都会触发元素节点的 collapseAtStart 方法，因为按下多次 Backspace 键后，将 ElementNode 元素节点的内容/子节点都删除掉以后，就可以保证光标真的触达元素节点的开头了

  所以对于一些元素节点，它们位于编辑器的开头与位于中间，行为会有所不同

  
  该节点覆写了父节点（ElementNode 元素节点）的相应方法，以针对删除编辑器开头的空段落的场景，如果编辑器中仅有这一个空段落（即该节点），则将该节点无法删除
  提示

  参考相关的源码，其核心逻辑如下

  首先基于该节点的子节点的数量，来判断该节点是否为空；如果该节点为空，则进一步判断该节点之后是否存在兄弟节点；如果存在兄弟节点，则执行删除该节点的操作，否则就不执行删除操作。

• ParagraphNode.clone(targetParagraphNode) 返回该节点的一份克隆，用于复制粘贴 ❓
  该节点覆写了祖先节点（LexicalNode 核心节点）的相应方法，返回一个段落节点，与给定的段落节点 targetParagraphNode 具有相同的 key 唯一标识符
  提示

  该方法其实是 ParagraphNode 类的静态方法，所以不需要实例化就可以直接调用该方法，基于传入的段落节点生成一个拷贝

• paragraphNode.createDOM(config) 用于指定该节点在页面上所对应的 DOM 元素结构。参数 config 是编辑器的配置对象（一般用于获取 config.theme 编辑器主题为相应的 DOM 元素添加 Class 类名）。最后返回一个 HTML 元素。
  该节点覆写了祖先节点（LexicalNode 核心节点）的相应方法，返回的 HTML 元素是 <p>，并从编辑器主题中 config.theme.paragraph 获取相应的 Class 类名添加到该元素上
• paragraphNode.insertNewAfter(selection, restoreSelection) 设置在该节点上按 Enter 回车键时的行为
  该节点覆写了祖先节点（LexicalNode 核心节点）的相应方法，返回一个新建的 paragraphNode 段落节点
• paragraphNode.updateDOM(prevNode, dom, config) 当节点变化时，该方法会被调用，其作用主要是更新 DOM 元素，以便与节点的最新状态保持一致
  该节点覆写了祖先节点（LexicalNode 核心节点）的相应方法，返回 false 表示不需要重新创建一个新的 DOM 元素来取代页面上原有的旧元素

• paragraphNode.exportDOM(editor) 在导出节点时，将节点序列化为 DOM 元素（字符串）时会调用该方法。该方法会接受一个参数 editor 编辑器实例
  该节点覆写了祖先节点（LexicalNode 核心节点）的相应方法，以实现具体的逻辑
• ParagraphNode.importDOM() 将 HTML 元素反序列化为节点时调用的方法
  该方法返回的是一个 DOMConversionMap 类型的值（表示转换成功）或 null（表示该 DOM 与当前的节点不匹配，转换失败，会被更低级的转换函数进行处理）
  说明

  DOMConversionMap 类型是一个映射，具体介绍可以查看另一篇笔记的相关章节

  提示

  该方法其实是静态方法，所以不需要实例化就可以直接调用该方法，基于传入的参数（序列化为 HTML 的节点）生成一个该节点的实例

• paragraphNode.exportJSON() 在导出节点时，将节点序列化为 JSON 格式（对象）时会调用该方法。
  该节点覆写了父节点（ElementNode 元素节点）的相应方法，以实现具体的逻辑
  段落节点的 JSON 格式

  段落节点序列化为 JSON 对象具有如下属性

  ts

  // 返回的 JSON 对象
  {
    ...super.exportJSON(), // ElementNode 元素节点序列化为 JSON 对象所具有的属性
    type: 'paragraph', // 节点类型名称
    version: 1, // 节点版本
  }
  

• ParagraphNode.importJSON(serializedNode) 将 JSON 数据反序列化为节点时调用的方法，返回一个该节点实例
  该节点覆写了祖先节点（LexicalNode 核心节点）的相应方法，以实现具体的逻辑
  提示

  该方法其实是静态方法，所以不需要实例化就可以直接调用该方法，基于传入的参数（序列化为 JSON 的节点）生成一个该节点的实例

• TabNode.getType() 获取节点的类型/名称
  该节点覆写了父节点（TextNode 文本节点）的相应方法，返回值为 'tab'
  提示

  该方法其实是 TextNode 类的静态方法，所以不需要实例化就可以直接调用该方法

• tabNode.canInsertTextAfter() 返回 false，用于表示如果光标在节点最后面时继续输入文字，则会创建一个兄弟节点（文本节点）来容纳新输入的文本
  该节点覆写了父节点（TextNode 文本节点）的相应方法，将返回值改为 false
• tabNode.canInsertTextBefore() 和上一个方法类似，也是返回 false，表示在节点前如果继续输入文字，则会创建一个兄弟节点（文本节点）来容纳新输入的文本
  该节点覆写了父节点（TextNode 文本节点）的相应方法，将返回值改为 false

• tabNode.setDetail(detail) 该节点覆写了父节点（TextNode 文本节点）的相应方法。该方法原本的目的是设置节点的 __detail 属性（关于书写方向和是否可进行节点融合的信息），但是由于缩进节点与书写方向无关且不支持节点融合 ❓ 所以这里该方法必然会抛出错误提示 'TabNode does not support setDetail'
• tabNode.setMode(type) 该节点覆写了父节点（TextNode 文本节点）的相应方法。该方法原本的目的是设置文本节点的模式（"normal" | "token" | "segmented" 这三个字符串之一），但是由于缩进节点并不支持设置模式，所以这里该方法必然会抛出错误提示 'TabNode does not support setMode'
• tabNode.setTextContent(str) 该节点覆写了父节点（TextNode 文本节点）的相应方法。该方法原本的目的是设置文本节点的内容，但是由于缩进节点并不支持内容，所以这里该方法必然会抛出错误提示 'TabNode does not support setTextContent'
  说明

  在实例化缩进节点 tabNode时就设置好文本内容为 \t 而且之后不能再更改

• TabNode.clone(targetTabNode) 返回该节点的一份克隆，用于复制粘贴
  该节点覆写了父节点（TextNode 文本节点）的相应方法，返回一个缩进节点，与给定的缩进节点 targetTabNode 具有相同的 key 唯一标识符
  提示

  该方法其实是 TabNode 类的静态方法，所以不需要实例化就可以直接调用该方法，基于传入的缩进节点生成一个拷贝

• tabNode.exportJSON() 在导出节点时，将节点序列化为 JSON 格式（对象）时会调用该方法。
  该节点覆写了父节点（TextNode 文本节点）的相应方法，以实现具体的逻辑
  缩进节点的 JSON 格式

  缩进点序列化为 JSON 对象具有如下属性

  ts

  // 返回的 JSON 对象
  {
    ...super.exportJSON(), // TextNode 文本节点序列化为 JSON 对象所具有的属性
    type: 'tab', // 节点类型名称
    version: 1, // 节点版本
  }
  

• TabNode.importDOM() 将 HTML 元素反序列化为节点时调用的方法
  该方法返回 null 表示（导入时）没有相应 DOM 元素与之对应
  提示

  该方法其实是静态方法，所以不需要实例化就可以直接调用该方法

• TabNode.importJSON(serializedNode) 将 JSON 数据反序列化为节点时调用的方法，返回一个该节点实例
  该节点覆写了父节点（TextNode 文本节点）的相应方法，以实现具体的逻辑
  提示

  该方法其实是静态方法，所以不需要实例化就可以直接调用该方法，基于传入的参数（序列化为 JSON 的节点）生成一个该节点的实例

• rangeSelection.extract() 提取选区中的节点（返回一个数组，包含一系列的节点）
  注意

  该方法会执行必要的节点分割 split node 以适应选择文本节点的部分内容的场景

  例如链接节点提供一个切换 toggle 功能，可以新建一个链接节点，只对选中的文本进行包裹，使之成为链接

  由于用户可能只选中一个文本节点中的部分文字，所以需要使用 rangeSelection.extract() 方法基于选区的端点对文本节点进行分隔（创建新的邻近兄弟节点），仅提取出选中的文本，再使用链接节点对这部分的文字（节点）进行包裹

• rangeSelection.getCharacterOffsets() 获取选区两个端点的偏移量，返回一个二维数组 [anchorOffset, focusOffset] 每个元素都是一个数值，依次表示选区的锚点和焦点的偏移量
  提示

  对于文本/字符串内容，偏移量是按字符个数计算的；对于非文本的节点，则按照子节点的数量计算

• rangeSelection.getNodes() 获取选区中的节点（返回一个数组，包含一系列的节点）
  区分

  与 rangeSelection.extract() 不同，该方法不会对节点进行分割 split node 操作

• rangeSelection.getTextContent() 获取选区中的（纯）文本内容
• rangeSelection.hasFormat(type) 返回一个布尔值，以表示选区中的（所有）文本是否具有给定的格式 type
  参数 type 是文本节点格式，可以是 "bold" | "underline" | "strikethrough" | "italic" | "highlight" | "code" | "subscript" | "superscript" 这几个值之一
• rangeSelection.is(targetSelection) 返回一个布尔值，以表示给定的选区 targetSelection 是否于当前的选区一样（包括 anchor 锚点、focus 焦点、format 所设置的文本格式、style 所设置的 CSS 样式）
• rangeSelection.isBackward() 返回一个布尔值，以表示该选区的焦点 focus 是否位于锚点 anchor 之前（当用户通过从右往左进行框选时）
• rangeSelection.isCollapsed() 返回一个布尔值，以表示该选区的焦点和锚点是否「坍缩」 collapse 到同一个位置，从视觉上而言就是当前的范围选区是否处于光标状态

• rangeSelection.applyDOMRange(range) 基于给定的 DOM 原生的 range 设置/生成当前范围选区
• rangeSelection.setTextNodeRange(anchorNode, anchorOffset, focusNode, focusOffset) 根据给定的节点和偏移值创建一个范围选区。
  正如该方法的名称所创建的范围选区与文本节点相关，因为该方法所接受的第一个参数 anchorNode 和第三个参数 focusNode 都是 TextNode 文本节点，而第二个参数 anchorOffset 和第三个参数 focusOffset 是数值，分别表示选区的两个端点的（基于字符）偏移量。
• rangeSelection.clone() 创建一个该选区的克隆
• rangeSelection.deleteCharacter(isBackward) 删除选区中的字符（执行了字符级删除的逻辑操作，相当于按下一次 Backspace 键或 Delete 键），参数 isBackward 表示删除的方向是否向后（相当于按下 Delete 键）
• rangeSelection.deleteWord(isBackward) 删除光标前面（如果参数 isBackward 为 true 则删除后面）一个单词
  按单词删除

  如果当前范围选区并不是光标状态，则直接删除选中的文本

  按单词删除是用户按下 Backspace 键 或 Delete 键 的同时按下 Ctrl 键（对于 MacOS 用户则是同时按下 Alt 键）时所预期的行为

  Lexical 提供了一些内置的指令，它们已经与特定的快捷键（按键事件）绑定，例如当用户按下上述的快捷键时就会分发内置的指令 DELETE_WORD_COMMAND，由于该快捷键在系统的文本编辑器中的预期行为是删除一个单词，所以一般在设置该指令的响应函数时调用这个范围选区的方法 rangeSelection.deleteWord()

• rangeSelection.deleteLine(isBackward) 删除光标所在的行的字符（执行了行删除的逻辑操作）
  按行删除

  如果当前范围选区并不是光标状态，则直接删除选中的文本

  按行删除只在 MacOS 系统中才起作用，一般是在用户按下 Backspace 键 或 Delete 键 的同时，按下 Meta 徽标键，执行行删除

  Lexical 提供了一些内置的指令，它们已经与特定的快捷键（按键事件）绑定，例如当 MacOS 用户按下上述的快捷键时就会分发内置的指令 DELETE_LINE_COMMAND，由于该快捷键在 MacOS 的文本编辑器中的预期行为是删除一行内容，所以一般在设置该指令的响应函数时调用这个范围选区的方法 rangeSelection.deleteLine()

• rangeSelection.formatText(type) 为选区中的（所有）文本节点设置给定的格式 type
  参数 type 是文本节点格式，可以是 "bold" | "underline" | "strikethrough" | "italic" | "highlight" | "code" | "subscript" | "superscript" 这几个值之一
  提示

  在设置选区中的文本格式时，可能会进行必要的文本节点分割和融合，由于不同的格式的字符串内容需要使用不同的文本节点进行包裹

  设置格式采用的是 toggle 切换（添加或移除）的方式，即如果选区的所有文本已经具有给定的格式时，则再调用该方法的结果是取消给定的格式；如果选区中并不是所有文本具有给定的格式，则为所有文本设置该格式

• rangeSelection.toggleFormat(type) 设置选区的属性 format，切换（添加或移除）给定的格式 type
  参数 type 是文本节点格式，可以是 "bold" | "underline" | "strikethrough" | "italic" | "highlight" | "code" | "subscript" | "superscript" 这几个值之一
• rangeSelection.setStyle(style) 设置选区的属性 style 为传入的参数值（一般是表示 inline style 行内样式的字符串）

• rangeSelection.insertLineBreak(selectStart?) 在光标位置插入一个 LineBreakNode 换行节点。（可选）参数 selectStart 是一个布尔值，以表示是否在插入完成时调整光标位置，将光标调整回换行节点之前（相当于将光标留着上一行）
  提示

  如果当前范围选区并不是光标状态，则先删除选中的文本，再插入 LineBreakNode 换行节点

• rangeSelection.insertNodes(nodes, selectStart?) 在光标位置插入插入给定的一系列节点（数组） nodes。（可选）参数 selectStart 是一个布尔值，以表示是否在插入完成时调整光标位置，将光标调整回换行节点之前（相当于将光标留着上一行）
  返回一个布尔值，以表示是否插入成功
  提示

  如果当前范围选区并不是光标状态，则先删除选中的文本，再插入给定的一系列节点

• rangeSelection.insertParagraph() 在光标位置插入一个 ParagraphNode 段落节点。
  提示

  如果当前范围选区并不是光标状态，则先删除选中的文本，再插入 ParagraphNode 段落节点

• rangeSelection.insertRawText(text) 在光标位置插入文本
  提示

  该方法会对给定的文本 text 中的一些特殊字符进行转换处理

  • 将 \n 或 \r\n 字符转换为 LineBreakNode 换行节点
  • 将 \t 字符转换为 TabNode 缩进节点
• rangeSelection.insertText(text) 在光标位置插入文本
  提示

  该方法不会对给定的文本 text 中的 \t、\n 等特殊字符进行转换处理

  虽然使用该方法将文本插入到页面上，从视觉上而言和使用方法 rangeSelection.insertRawText(text) 并无区别（例如对于 \n 字符，浏览器也会解析为换行操作），但是节点树和 DOM 结构树会有所区别

  使用该方法插入的文本是扁平化的，即这些字符串都只会包含在一个节点中；而使用 rangeSelection.insertRawText(text) 方法插入的文本，如果含有特殊的字符会进行转换，所以传入的文本可能对应得到多个节点

• rangeSelection.removeText() 删除选区中的文本
  提示

  如果当前选区处于光标状态，则不对任何文本删除

• rangeSelection.modify(alter, isBackward, granularity) 调整/修改当前的范围选区，可以用于移动或扩展 一个「逻辑」单位 logical unit 选区范围
  该方法的各个参数的作用如下：
  • 第一个参数 alter 可以是 "move" | "extend" 这两个值之一，以表示修改的类型
  • 第二个参数 isBackward 是一个布尔值，以表示移动的方向是否向后
  • 第三个参数 granularity 可以是 "character" | "word" | "lineboundary" 这三个值之一，以表示调整的颗粒度/单位，按照 "character" 字符、"word" 单词还是 "lineboundary" 一行作为一个「逻辑」单位
  提示

  使用该方法可以安全地调整选区（一个「逻辑」单位），因为该方法会针对各种不同类型的节点执行相应的处理，不需要担心可能出现的边缘情况

• nodeSelection.extract() 提取选区中的节点（返回一个数组，包含一系列的节点），实际上是方法 nodeSelection.getNodes() 的别名
• nodeSelection.getNodes() 获取选区中的节点（返回一个数组，包含一系列的节点）
• nodeSelection.getTextContent() 获取选区中的（纯）文本内容
• nodeSelection.has(key) 返回一个布尔值，以表示当前选区中是否含有给定的节点 key（该参数是节点的唯一标识符）
• nodeSelection.is(selection) 返回一个布尔值，以表示给定的选区 selection 与当前选区是否相同

• nodeSelection.add(key) 将给定的节点 key（该参数是节点的唯一标识符）添加到当前的节点选区中
• nodeSelection.insertNodes(nodes, selectStart) 在光标位置插入插入给定的一系列节点（数组） nodes。（可选）参数 selectStart 是一个布尔值，以表示是否在插入完成时调整光标位置，将光标调整回插入节点之前（从视觉上就相当于将光标不动）
  返回 true 以表示插入成功
  提示

  如果当前范围选区并不是光标状态，则先删除选中的文本，再插入给定的一系列节点

• nodeSelection.insertRawText(text) 原本该方法的目的是插入文本（而且会对给定的文本 text 中的一些特殊字符进行转换处理），但是对于节点选区，该方法并不会执行任何操作
• nodeSelection.insertText() 原本该方法的目的是插入文本，但是对于节点选区，该方法并不会执行任何操作
• nodeSelection.delete(key) 将给定的节点 key（该参数是节点的唯一标识符）从当前节点选区中删去
• nodeSelection.clear() 清空节点选区（所选中的节点）
• nodeSelection.clone() 创建一个该选区的克隆，而且所选中的节点与原选区相同