@lexical/list 0.50.1-nightly.20260916.0 → 0.51.0

package/dist/LexicalList.dev.js

@@ -7,7 +7,7 @@
  */
 
 import { $getNearestNodeOfType, calculateZoomLevel } from '@lexical/utils';
-import { $getSelection, $isRangeSelection, $isTextNode, $isRootOrShadowRoot, $createParagraphNode, $copyNode, $isElementNode, $getSlotHost, $isLeafNode, $setPointFromCaret, $normalizeCaret, $getChildCaret, $applyNodeReplacement, ElementNode, buildImportMap, $getSiblingCaret, $insertNodeToNearestRootAtCaret, $rewindSiblingCaret, $getDocument, setDOMStyleFromCSS, isHTMLElement, $isParagraphNode, $setFormatFromDOM, $setDirectionFromDOM, normalizeClassNames, removeClassNamesFromElement, addClassNamesToElement, getStyleObjectFromCSS, createCommand, mergeRegister, COMMAND_PRIORITY_LOW, KEY_ARROW_DOWN_COMMAND, KEY_ARROW_UP_COMMAND, KEY_ESCAPE_COMMAND, KEY_SPACE_COMMAND, $getNearestNodeFromDOMNode, KEY_ARROW_LEFT_COMMAND, $findMatchingParent, getActiveElement, registerEventListeners, IS_FIREFOX, registerEventListener, getNearestEditorFromDOMNode, $addUpdateTag, SKIP_SELECTION_FOCUS_TAG, SKIP_DOM_SELECTION_TAG, $createLineBreakNode, $getNodeByKey, INSERT_PARAGRAPH_COMMAND, KEY_BACKSPACE_COMMAND, COMMAND_PRIORITY_BEFORE_EDITOR, TextNode } from 'lexical';
+import { $getSelection, $isRangeSelection, $isTextNode, $isRootOrShadowRoot, $createParagraphNode, $copyNode, $isElementNode, $getSlotHost, $isLeafNode, $setPointFromCaret, $normalizeCaret, $getChildCaret, getterTableOf, setterTableOf, setterDefaultOf, aliasTableOf, $applyNodeReplacement, ElementNode, buildImportMap, $getSiblingCaret, $insertNodeToNearestRootAtCaret, $rewindSiblingCaret, $getDocument, setDOMStyleFromCSS, isHTMLElement, $isParagraphNode, nodeSchema, withField, numberValue, withAccessors, optional, booleanValue, $setFormatFromDOM, $setDirectionFromDOM, normalizeClassNames, removeClassNamesFromElement, addClassNamesToElement, getStyleObjectFromCSS, enumValue, aliasedValue, createCommand, mergeRegister, COMMAND_PRIORITY_LOW, KEY_ARROW_DOWN_COMMAND, KEY_ARROW_UP_COMMAND, KEY_ESCAPE_COMMAND, KEY_SPACE_COMMAND, $getNearestNodeFromDOMNode, KEY_ARROW_LEFT_COMMAND, $findMatchingParent, getActiveElement, registerEventListeners, IS_FIREFOX, registerEventListener, getNearestEditorFromDOMNode, $addUpdateTag, SKIP_SELECTION_FOCUS_TAG, SKIP_DOM_SELECTION_TAG, $createLineBreakNode, $getNodeByKey, INSERT_PARAGRAPH_COMMAND, KEY_BACKSPACE_COMMAND, COMMAND_PRIORITY_BEFORE_EDITOR, TextNode } from 'lexical';
 import { effect } from '@lexical/extension/signals';
 import { namedSignals } from '@lexical/extension/namedSignals';
 import { sel, isElementOfTag, $propagateTextAlignToBlockChildren, $isBlockLevel, CoreImportExtension, DOMImportExtension, ImportOverlays, defineOverlayRules, createImportState, InlineSchema } from '@lexical/html';
@@ -604,6 +604,269 @@ function $handleListInsertParagraph(restoreNumbering = false) {
   return true;
 }
 
+/**
+ * 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 JSON number grammar, anchored, matching numberValue: `Number()` alone
+// reads '0x10' as 16 and '' as 0, and neither is a shape a JSON encoder
+// produces. Emitted from the same source the codegen verified against, so the
+// two cannot be different functions.
+const JSON_NUMBER = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
+function num(v, d) {
+  if (typeof v === 'number') {
+    return Number.isFinite(v) ? v : d;
+  }
+  if (typeof v !== 'string' || !JSON_NUMBER.test(v)) {
+    return d;
+  }
+  const n = Number(v);
+  return Number.isFinite(n) ? n : d;
+}
+function numC(v, d, min, max, integer) {
+  const n = num(v, d);
+  return n >= min && n <= max && (false || Number.isInteger(n)) ? n : d;
+}
+function numK(v, d, min, max, integer) {
+  const n = num(v, NaN);
+  if (!Number.isFinite(n) || !Number.isInteger(n)) {
+    return d;
+  }
+  return n < min ? min : n > max ? max : n;
+}
+
+/**
+ * ListNode's schema-declared fields, for a clone. Generated from that
+ * schema; do not edit by hand.
+ *
+ * @internal
+ */
+function afterCloneListNode(node, prevNode) {
+  node.__listType = prevNode.__listType;
+  node.__start = prevNode.__start;
+  node.__tag = prevNode.__tag;
+}
+
+/** ListNode's generated implementations, for its `$config`. @internal */
+const GENERATED_LIST = fields => {
+  const LIST_FORMAT_GETTER = getterTableOf(fields, 'format');
+  const LIST_FORMAT_SETTER = setterTableOf(fields, 'format');
+  const LIST_FORMAT_SETTER_DEFAULT = setterDefaultOf(fields, 'format');
+  const LIST_LISTTYPE_ALIAS = aliasTableOf(fields, 'listType', 0);
+
+  /** Generated from ListNode's serialization schema. Do not edit by hand. */
+  function exportListNode(node) {
+    const textFormat = node.__textFormat;
+    const textStyle = node.__textStyle;
+    const shouldSerializeTextStyles = (textFormat !== 0 || textStyle !== '') && node.shouldSerializeTextStyles();
+    return {
+      children: [],
+      listType: node.__listType,
+      start: node.__start,
+      tag: node.__tag,
+      direction: node.__dir,
+      format: LIST_FORMAT_GETTER[node.__format],
+      indent: node.__indent,
+      textFormat: textFormat !== 0 && shouldSerializeTextStyles ? textFormat : undefined,
+      textStyle: textStyle !== '' && shouldSerializeTextStyles ? textStyle : undefined,
+      type: node.__type,
+      version: 1
+    };
+  }
+
+  /** Generated from ListNode's serialization schema. Do not edit by hand. */
+  function exportCompactListNode(node) {
+    const textFormat = node.__textFormat;
+    const textStyle = node.__textStyle;
+    const shouldSerializeTextStyles = (textFormat !== 0 || textStyle !== '') && node.shouldSerializeTextStyles();
+    const json = {
+      type: node.__type,
+      children: []
+    };
+    const listType = node.__listType;
+    if (listType !== undefined && listType !== 'number') {
+      json.listType = listType;
+    }
+    const start = node.__start;
+    if (start !== undefined && start !== 1) {
+      json.start = start;
+    }
+    const direction = node.__dir;
+    if (direction != null) {
+      json.direction = direction;
+    }
+    const format = LIST_FORMAT_GETTER[node.__format];
+    if (format !== undefined && format !== '') {
+      json.format = format;
+    }
+    const indent = node.__indent;
+    if (indent !== undefined && indent !== 0) {
+      json.indent = indent;
+    }
+    if (textFormat !== undefined && textFormat !== 0 && shouldSerializeTextStyles) {
+      json.textFormat = textFormat;
+    }
+    if (textStyle !== undefined && textStyle !== '' && shouldSerializeTextStyles) {
+      json.textStyle = textStyle;
+    }
+    return json;
+  }
+
+  /** Generated from ListNode's serialization schema. Do not edit by hand. */
+  function updateListNode(node, json) {
+    const direction = json.direction;
+    node.__dir = direction === null || direction === 'ltr' || direction === 'rtl' ? direction : null;
+    const format = json.format;
+    node.__format = typeof format === 'string' && format in LIST_FORMAT_SETTER ? LIST_FORMAT_SETTER[format] : LIST_FORMAT_SETTER_DEFAULT;
+    node.__indent = numC(json.indent, 0, 0, Infinity);
+    node.__textFormat = num(json.textFormat, 0);
+    const textStyle = json.textStyle;
+    node.__textStyle = typeof textStyle === 'string' ? textStyle : '';
+    const listType = json.listType;
+    node.setListType(typeof listType === 'string' && listType in LIST_LISTTYPE_ALIAS ? LIST_LISTTYPE_ALIAS[listType] : listType === 'number' || listType === 'bullet' || listType === 'check' ? listType : 'number');
+    node.__start = num(json.start, 1);
+    return node;
+  }
+  return {
+    exportJSON: exportListNode,
+    exportCompactJSON: exportCompactListNode,
+    updateFromJSON: updateListNode,
+    afterCloneFrom: afterCloneListNode
+  };
+};
+
+/**
+ * ListItemNode's schema-declared fields, for a clone. Generated from that
+ * schema; do not edit by hand.
+ *
+ * @internal
+ */
+function afterCloneListItemNode(node, prevNode) {
+  node.__checked = prevNode.__checked;
+  node.__value = prevNode.__value;
+}
+
+/** ListItemNode's generated implementations, for its `$config`. @internal */
+const GENERATED_LISTITEM = fields => {
+  const LISTITEM_FORMAT_GETTER = getterTableOf(fields, 'format');
+  const LISTITEM_FORMAT_SETTER = setterTableOf(fields, 'format');
+  const LISTITEM_FORMAT_SETTER_DEFAULT = setterDefaultOf(fields, 'format');
+
+  /** Generated from ListItemNode's serialization schema. Do not edit by hand. */
+  function exportListItemNode(node) {
+    const textFormat = node.__textFormat;
+    const textStyle = node.__textStyle;
+    const shouldSerializeTextStyles = (textFormat !== 0 || textStyle !== '') && node.shouldSerializeTextStyles();
+    return {
+      children: [],
+      checked: node.getChecked(),
+      indent: node.getIndent(),
+      value: node.__value,
+      direction: node.__dir,
+      format: LISTITEM_FORMAT_GETTER[node.__format],
+      textFormat: textFormat !== 0 && shouldSerializeTextStyles ? textFormat : undefined,
+      textStyle: textStyle !== '' && shouldSerializeTextStyles ? textStyle : undefined,
+      type: node.__type,
+      version: 1
+    };
+  }
+
+  /** Generated from ListItemNode's serialization schema. Do not edit by hand. */
+  function exportCompactListItemNode(node) {
+    const textFormat = node.__textFormat;
+    const textStyle = node.__textStyle;
+    const shouldSerializeTextStyles = (textFormat !== 0 || textStyle !== '') && node.shouldSerializeTextStyles();
+    const json = {
+      type: node.__type,
+      children: []
+    };
+    const checked = node.getChecked();
+    if (checked !== undefined) {
+      json.checked = checked;
+    }
+    const indent = node.getIndent();
+    if (indent !== undefined && indent !== 0) {
+      json.indent = indent;
+    }
+    const value = node.__value;
+    if (value !== undefined && value !== 1) {
+      json.value = value;
+    }
+    const direction = node.__dir;
+    if (direction != null) {
+      json.direction = direction;
+    }
+    const format = LISTITEM_FORMAT_GETTER[node.__format];
+    if (format !== undefined && format !== '') {
+      json.format = format;
+    }
+    if (textFormat !== undefined && textFormat !== 0 && shouldSerializeTextStyles) {
+      json.textFormat = textFormat;
+    }
+    if (textStyle !== undefined && textStyle !== '' && shouldSerializeTextStyles) {
+      json.textStyle = textStyle;
+    }
+    return json;
+  }
+
+  /** Generated from ListItemNode's serialization schema. Do not edit by hand. */
+  function updateListItemNode(node, json) {
+    const direction = json.direction;
+    node.__dir = direction === null || direction === 'ltr' || direction === 'rtl' ? direction : null;
+    const format = json.format;
+    node.__format = typeof format === 'string' && format in LISTITEM_FORMAT_SETTER ? LISTITEM_FORMAT_SETTER[format] : LISTITEM_FORMAT_SETTER_DEFAULT;
+    node.setIndent(numK(json.indent, 0, 0, 128));
+    node.__textFormat = num(json.textFormat, 0);
+    const textStyle = json.textStyle;
+    node.__textStyle = typeof textStyle === 'string' ? textStyle : '';
+    const checked = json.checked;
+    node.__checked = checked === undefined ? undefined : typeof checked === 'boolean' ? checked : false;
+    node.__value = num(json.value, 1);
+    return node;
+  }
+  return {
+    exportJSON: exportListItemNode,
+    exportCompactJSON: exportCompactListItemNode,
+    updateFromJSON: updateListItemNode,
+    afterCloneFrom: afterCloneListItemNode
+  };
+};
+
+/**
+ * The deepest list nesting `setIndent` will walk to. Each level it steps
+ * through nests or unwraps a whole list, so this bounds work an untrusted
+ * `indent` could otherwise make unbounded.
+ */
+const MAX_LIST_ITEM_INDENT = 128;
+const listItemNodeSchema = /* @__PURE__ */nodeSchema()({
+  // getChecked computes from the parent list's type, so the getter stays a
+  // method; setChecked is a bare field write.
+  checked: /* @__PURE__ */withAccessors(/* @__PURE__ */optional(/* @__PURE__ */booleanValue()), {
+    setter: {
+      field: '__checked'
+    }
+  }),
+  // Overrides the inherited ElementNode field to bound it. This indent is
+  // structural — applying it nests or unwraps one whole list per level — so an
+  // unbounded value out of untrusted JSON would build millions of nodes.
+  // `clamp`, because the plain bounds fall back to the *default* for a value
+  // outside them, which would read an over-deep item as indent 0 instead of as
+  // deeply nested.
+  indent: /* @__PURE__ */numberValue(0, {
+    clamp: true,
+    integer: true,
+    max: MAX_LIST_ITEM_INDENT,
+    min: 0
+  }),
+  value: /* @__PURE__ */withField(/* @__PURE__ */numberValue(1), {
+    field: '__value'
+  })
+});
 function applyMarkerStyles(dom, node, prevNode) {
   const nextTextStyle = node.__textStyle;
   const prevTextStyle = prevNode ? prevNode.__textStyle : '';
@@ -623,7 +886,10 @@ function applyMarkerStyles(dom, node, prevNode) {
   }
 }
 
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
+
 /** @noInheritDoc */
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
 class ListItemNode extends ElementNode {
   /** @internal */
   __value;
@@ -674,12 +940,14 @@ class ListItemNode extends ElementNode {
         }
       },
       extends: ElementNode,
+      generated: GENERATED_LISTITEM,
       importDOM: buildImportMap({
         li: () => ({
           conversion: $convertListItemElement,
           priority: 0
         })
-      })
+      }),
+      json: listItemNodeSchema
     });
   }
   constructor(value = 1, checked = undefined, key) {
@@ -687,11 +955,6 @@ class ListItemNode extends ElementNode {
     this.__value = value === undefined ? 1 : value;
     this.__checked = checked;
   }
-  afterCloneFrom(prevNode) {
-    super.afterCloneFrom(prevNode);
-    this.__value = prevNode.__value;
-    this.__checked = prevNode.__checked;
-  }
   createDOM(config) {
     const element = $getDocument().createElement('li');
     this.updateListItemDOM(null, element, config);
@@ -714,9 +977,6 @@ class ListItemNode extends ElementNode {
     this.updateListItemDOM(prevNode, element, config);
     return false;
   }
-  updateFromJSON(serializedNode) {
-    return super.updateFromJSON(serializedNode).setValue(serializedNode.value).setChecked(serializedNode.checked);
-  }
   exportDOM(editor) {
     const element = this.createDOM(editor._config);
     const formatType = this.getFormatType();
@@ -748,13 +1008,6 @@ class ListItemNode extends ElementNode {
       element
     };
   }
-  exportJSON() {
-    return {
-      ...super.exportJSON(),
-      checked: this.getChecked(),
-      value: this.getValue()
-    };
-  }
   append(...nodes) {
     for (let i = 0; i < nodes.length; i++) {
       const node = nodes[i];
@@ -949,10 +1202,15 @@ class ListItemNode extends ElementNode {
     indent = Math.floor(indent);
     if (!(indent >= 0)) {
       formatDevErrorMessage(`Indent value must be non-negative.`);
-    }
+    } // Deliberately not clamped here: the bound belongs on the parse path (see
+    // listItemNodeSchema), because clamping the target of a walk that starts
+    // from the node's *current* indent would outdent an item that is already
+    // nested deeper than the bound — making `item.setIndent(item.getIndent())`
+    // destroy structure rather than do nothing.
+    const target = indent;
     let currentIndent = this.getIndent();
-    while (currentIndent !== indent) {
-      if (currentIndent < indent) {
+    while (currentIndent !== target) {
+      if (currentIndent < target) {
         $handleIndent(this);
         currentIndent++;
       } else {
@@ -1130,7 +1388,42 @@ function $isListItemNode(node) {
  *
  */
 
+// A literal rather than a `Record<string, ListType>` so that the alias table
+// below keeps its keys: they are what the schema reports as the legacy
+// spellings it accepts.
+const TAG_TO_LIST_TYPE = {
+  ol: 'number',
+  ul: 'bullet'
+};
+const listNodeSchema = /* @__PURE__ */nodeSchema()({
+  // 'ul'/'ol' are the legacy tag-form listType some older documents carry,
+  // stated as an alias table rather than a transform: the mapping is data, so
+  // the codegen can compile this property's parse, where an arbitrary
+  // function would have taken the whole class out of the import half.
+  // Read straight off the field; applied through setListType, which also
+  // maintains the derived __tag, so the setter stays a method.
+  listType: /* @__PURE__ */withAccessors(/* @__PURE__ */aliasedValue(/* @__PURE__ */enumValue(['number', 'bullet', 'check']), TAG_TO_LIST_TYPE), {
+    getter: {
+      field: '__listType'
+    }
+  }),
+  start: /* @__PURE__ */withField(/* @__PURE__ */numberValue(1), {
+    field: '__start'
+  }),
+  // Derived from listType rather than stored: written on export, and
+  // deliberately not applied on import.
+  tag: /* @__PURE__ */withAccessors(/* @__PURE__ */enumValue(['ul', 'ol']), {
+    getter: {
+      field: '__tag'
+    },
+    setter: null
+  })
+});
+
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
+
 /** @noInheritDoc */
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
 class ListNode extends ElementNode {
   /** @internal */
   __tag;
@@ -1147,6 +1440,7 @@ class ListNode extends ElementNode {
         updateChildrenListItemValue(node);
       },
       extends: ElementNode,
+      generated: GENERATED_LIST,
       importDOM: buildImportMap({
         ol: () => ({
           conversion: $convertListNode,
@@ -1156,22 +1450,19 @@ class ListNode extends ElementNode {
           conversion: $convertListNode,
           priority: 0
         })
-      })
+      }),
+      json: listNodeSchema
     });
   }
   constructor(listType = 'number', start = 1, key) {
     super(key);
+    // Widened for the lookup: the parameter's type excludes the legacy tag
+    // spellings, and this normalizes them for a caller that passes one anyway.
     const _listType = TAG_TO_LIST_TYPE[listType] || listType;
     this.__listType = _listType;
     this.__tag = _listType === 'number' ? 'ol' : 'ul';
     this.__start = start;
   }
-  afterCloneFrom(prevNode) {
-    super.afterCloneFrom(prevNode);
-    this.__listType = prevNode.__listType;
-    this.__tag = prevNode.__tag;
-    this.__start = prevNode.__start;
-  }
   getTag() {
     return this.getLatest().__tag;
   }
@@ -1216,9 +1507,6 @@ class ListNode extends ElementNode {
     }
     return false;
   }
-  updateFromJSON(serializedNode) {
-    return super.updateFromJSON(serializedNode).setListType(serializedNode.listType).setStart(serializedNode.start);
-  }
   exportDOM(editor) {
     const element = this.createDOM(editor._config, editor);
     if (isHTMLElement(element)) {
@@ -1240,14 +1528,6 @@ class ListNode extends ElementNode {
       element
     };
   }
-  exportJSON() {
-    return {
-      ...super.exportJSON(),
-      listType: this.getListType(),
-      start: this.getStart(),
-      tag: this.getTag()
-    };
-  }
   canBeEmpty() {
     return false;
   }
@@ -1400,10 +1680,6 @@ function $convertListNode(domNode) {
     node
   };
 }
-const TAG_TO_LIST_TYPE = {
-  ol: 'number',
-  ul: 'bullet'
-};
 
 /**
  * Creates a ListNode of listType.

package/dist/LexicalList.js.flow

@@ -15,6 +15,7 @@ import type {
   RangeSelection,
   LexicalCommand,
   SerializedElementNode,
+  SerializedPartial,
   LexicalExtension,
   ExtensionConfigBase,
 } from 'lexical';
@@ -62,7 +63,17 @@ declare export class ListItemNode extends ElementNode {
   getChecked(): boolean | void;
   setChecked(boolean): this;
   toggleChecked(): void;
-  static importJSON(serializedNode: SerializedListItemNode): ListItemNode;
+  // Both forms, because a Flow object property is invariant: `SerializedPartial`
+  // makes each property optional, and an optional property is not a supertype
+  // of a required one there, so naming only the relaxed form made the *full*
+  // serialized type unassignable — `ListItemNode.importJSON(node.exportJSON())`
+  // stopped type-checking. TypeScript needs no union: a required property
+  // satisfies an optional one structurally.
+  static importJSON(
+    serializedNode:
+      | SerializedListItemNode
+      | SerializedPartial<SerializedListItemNode>,
+  ): ListItemNode;
 }
 declare export class ListNode extends ElementNode {
   __tag: ListNodeTagType;
@@ -72,7 +83,17 @@ declare export class ListNode extends ElementNode {
   getTag(): ListNodeTagType;
   getStart(): number;
   getListType(): ListType;
-  static importJSON(serializedNode: SerializedListNode): ListNode;
+  // Both forms, because a Flow object property is invariant: `SerializedPartial`
+  // makes each property optional, and an optional property is not a supertype
+  // of a required one there, so naming only the relaxed form made the *full*
+  // serialized type unassignable — `ListNode.importJSON(node.exportJSON())`
+  // stopped type-checking. TypeScript needs no union: a required property
+  // satisfies an optional one structurally.
+  static importJSON(
+    serializedNode:
+      | SerializedListNode
+      | SerializedPartial<SerializedListNode>,
+  ): ListNode;
 }
 declare export function outdentList(): void;
 declare export function $removeList(): void;