@lexical/list 0.44.1-nightly.20260519.0 → 0.45.1-dev.0

package/{LexicalList.dev.js → dist/LexicalList.dev.js}

@@ -8,9 +8,10 @@
 
 'use strict';
 
-var extension = require('@lexical/extension');
 var utils = require('@lexical/utils');
 var lexical = require('lexical');
+var extension = require('@lexical/extension');
+var html = require('@lexical/html');
 
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
@@ -1295,7 +1296,7 @@ function $normalizeChildren(nodes, listNode) {
   }
   return normalizedListItems;
 }
-function isDomChecklist(domNode) {
+function isDomChecklist$1(domNode) {
   if (domNode.getAttribute('__lexicallisttype') === 'check' ||
   // is github checklist
   domNode.classList.contains('contains-task-list') ||
@@ -1319,7 +1320,7 @@ function $convertListNode(domNode) {
   if (isHTMLOListElement(domNode)) {
     const start = domNode.start;
     node = $createListNode('number', start);
-  } else if (isDomChecklist(domNode)) {
+  } else if (isDomChecklist$1(domNode)) {
     node = $createListNode('check');
   } else {
     node = $createListNode('bullet');
@@ -1787,33 +1788,13 @@ function $findChildrenEndListItemNode(listItemNode) {
 }
 
 /**
- * @deprecated use {@link $insertList} from an update or command listener.
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
- * Inserts a new ListNode. If the selection's anchor node is an empty ListItemNode and is a child of
- * the root/shadow root, it will replace the ListItemNode with a ListNode and the old ListItemNode.
- * Otherwise it will replace its parent with a new ListNode and re-insert the ListItemNode and any previous children.
- * If the selection's anchor node is not an empty ListItemNode, it will add a new ListNode or merge an existing ListNode,
- * unless the the node is a leaf node, in which case it will attempt to find a ListNode up the branch and replace it with
- * a new ListNode, or create a new ListNode at the nearest root/shadow root.
- * @param editor - The lexical editor.
- * @param listType - The type of list, "number" | "bullet" | "check".
- */
-function insertList(editor, listType) {
-  editor.update(() => $insertList(listType));
-}
-
-/**
- * @deprecated use {@link $removeList} from an update or command listener.
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
  *
- * Searches for the nearest ancestral ListNode and removes it. If selection is an empty ListItemNode
- * it will remove the whole list, including the ListItemNode. For each ListItemNode in the ListNode,
- * removeList will also generate new ParagraphNodes in the removed ListNode's place. Any child node
- * inside a ListItemNode will be appended to the new ParagraphNodes.
- * @param editor - The lexical editor.
  */
-function removeList(editor) {
-  editor.update(() => $removeList());
-}
+
 /**
  * Configures {@link ListNode}, {@link ListItemNode} and registers
  * the strict indent transform if `hasStrictIndent` is true (default false).
@@ -1839,10 +1820,8 @@ const ListExtension = lexical.defineExtension({
 });
 /**
  * Registers checklist functionality for {@link ListNode} and
- * {@link ListItemNode} with a
- * {@link INSERT_CHECK_LIST_COMMAND} listener and
- * the expected keyboard and mouse interactions for
- * checkboxes.
+ * {@link ListItemNode} with a `INSERT_CHECK_LIST_COMMAND` listener and
+ * the expected keyboard and mouse interactions for checkboxes.
  */
 const CheckListExtension = lexical.defineExtension({
   build: (editor, config) => extension.namedSignals(config),
@@ -1854,6 +1833,279 @@ const CheckListExtension = lexical.defineExtension({
   register: (editor, config, state) => registerCheckList(editor, state.getOutput())
 });
 
+/**
+ * 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.
+ *
+ */
+
+
+/**
+ * Mirrors the legacy `isDomChecklist` heuristic from
+ * `@lexical/list`.
+ */
+function isDomChecklist(domNode) {
+  return domNode.matches('[__lexicallisttype="check"], .contains-task-list, [data-is-checklist="1"]') || domNode.querySelector(':scope > [aria-checked]') !== null;
+}
+
+/**
+ * Lift nested `ListNode`s out of `ListItemNode`s into sibling
+ * `ListItemNode`s (the legacy `$normalizeChildren` shape). Also wraps any
+ * non-`ListItemNode` children in a new `ListItemNode`.
+ */
+function $normalizeListChildren(children) {
+  const out = [];
+  for (const child of children) {
+    if ($isListItemNode(child)) {
+      out.push(child);
+      const innerChildren = child.getChildren();
+      if (innerChildren.length > 1) {
+        for (const inner of innerChildren) {
+          if ($isListNode(inner)) {
+            out.push($createListItemNode().append(inner));
+          }
+        }
+      }
+    } else {
+      out.push($createListItemNode().append(child));
+    }
+  }
+  return out;
+}
+const ListRule = html.defineImportRule({
+  $import: (ctx, el) => {
+    let node;
+    if (html.isElementOfTag(el, 'ol')) {
+      node = $createListNode('number', el.start);
+    } else if (isDomChecklist(el)) {
+      node = $createListNode('check');
+    } else {
+      node = $createListNode('bullet');
+    }
+    lexical.$setDirectionFromDOM(node, el);
+    // Propagate the list's `text-align` onto each `ListItemNode` child
+    // (legacy `wrapContinuousInlines` did the same), so pasting
+    // `<ul style="text-align: left"><li>…</li></ul>` ends up with the
+    // alignment on the list items where the reconciler renders it as
+    // `style="text-align: left"`.
+    return [node.splice(0, 0, html.$propagateTextAlignToBlockChildren($normalizeListChildren(ctx.$importChildren(el)), el))];
+  },
+  match: html.sel.tag('ol', 'ul'),
+  name: '@lexical/list/list'
+});
+
+/**
+ * Apply formatting from the first child paragraph of `<li>` to the list
+ * item itself, then unwrap that paragraph (Google Docs sets the alignment
+ * of the `<p>` inside the `<li>`). Mirrors the legacy
+ * `setFormatFromChildren`.
+ */
+function $liftFormatFromSingleParagraph(listItemNode, children) {
+  if (children.length !== 1) {
+    return children;
+  }
+  const firstChild = children[0];
+  if (lexical.$isParagraphNode(firstChild) && !listItemNode.getFormatType() && firstChild.getFormatType()) {
+    listItemNode.setFormat(firstChild.getFormatType());
+    return firstChild.getChildren();
+  }
+  return children;
+}
+
+/**
+ * Collapse block children of a `<li>` into inline-with-line-break form: a
+ * `ListItemNode` is an inline-level container, so any block child marks a
+ * boundary. Contiguous inline siblings are kept together as a single run and
+ * one {@link $createLineBreakNode} is inserted between runs — reproducing the
+ * legacy `wrapContinuousInlines` + `$unwrapArtificialNodes` shape
+ * (`<li>1<div>2</div>3</li>` → `1<br>2<br>3`) without the
+ * `ArtificialNode__DO_NOT_USE` marker.
+ *
+ * Boundaries are detected with {@link $isBlockLevel}, NOT `$isParagraphNode`:
+ * the `<div>`/`<section>`/… `TransparentBlockRule` happens to emit
+ * `ParagraphNode`s, but a `<blockquote>` (`QuoteNode`), heading
+ * (`HeadingNode`), or block decorator (`HorizontalRuleNode`, …) is just as
+ * much a block boundary and must not be silently spliced into the list item
+ * as-is. A nested `ListNode` is the one deliberate exception — it is a valid
+ * list-item child that {@link $normalizeListChildren} lifts into a sibling,
+ * so it is preserved here rather than unwrapped.
+ */
+function $flattenListItemBlocks(children) {
+  const $isBoundary = node => html.$isBlockLevel(node) && !$isListNode(node);
+  if (!children.some($isBoundary)) {
+    return children;
+  }
+  // Partition into segments — each maximal run of inline siblings, and each
+  // boundary's own content — then join the segments with a single line break.
+  const segments = [];
+  let inlineRun = [];
+  const flushInlineRun = () => {
+    if (inlineRun.length > 0) {
+      segments.push(inlineRun);
+      inlineRun = [];
+    }
+  };
+  for (const child of children) {
+    if ($isBoundary(child)) {
+      flushInlineRun();
+      // Unwrap a block ElementNode to its inline content; a childless block
+      // DecoratorNode stands on its own line.
+      segments.push(lexical.$isElementNode(child) ? child.getChildren() : [child]);
+    } else {
+      inlineRun.push(child);
+    }
+  }
+  flushInlineRun();
+  const out = [];
+  for (const segment of segments) {
+    if (out.length > 0) {
+      out.push(lexical.$createLineBreakNode());
+    }
+    out.push(...segment);
+  }
+  return out;
+}
+const ListItemRule = html.defineImportRule({
+  $import: (ctx, el) => {
+    const ariaChecked = el.getAttribute('aria-checked');
+    const checked = ariaChecked === 'true' ? true : ariaChecked === 'false' ? false : undefined;
+    const node = $createListItemNode(checked);
+    lexical.$setFormatFromDOM(node, el);
+    lexical.$setDirectionFromDOM(node, el);
+    return [node.splice(0, 0,
+    // Lift a sole wrapping paragraph's format onto the item *before*
+    // flattening, otherwise the paragraph would already be unwrapped and
+    // its alignment lost.
+    $flattenListItemBlocks($liftFormatFromSingleParagraph(node, ctx.$importChildren(el))))];
+  },
+  match: html.sel.tag('li'),
+  name: '@lexical/list/li'
+});
+function $buildChecklistItem(ctx, el, checkboxOwner) {
+  const checkboxInput = html.isElementOfTag(checkboxOwner, 'input') ? checkboxOwner : checkboxOwner.querySelector('input[type="checkbox"]');
+  if (!checkboxInput || checkboxInput.getAttribute('type') !== 'checkbox') {
+    return [];
+  }
+  const checked = checkboxInput.hasAttribute('checked');
+  const node = $createListItemNode(checked);
+  lexical.$setFormatFromDOM(node, el);
+  lexical.$setDirectionFromDOM(node, el);
+  return [node.splice(0, 0, $flattenListItemBlocks($liftFormatFromSingleParagraph(node, ctx.$importChildren(el))))];
+}
+const TaskListItemRule = html.defineImportRule({
+  $import: (ctx, el, $next) => {
+    const input = el.querySelector(':scope > input[type="checkbox"]');
+    if (!input) {
+      return $next();
+    }
+    return $buildChecklistItem(ctx, el, input);
+  },
+  match: html.sel.tag('li').classAll('task-list-item'),
+  name: '@lexical/list/li-task-list-item'
+});
+const JoplinChecklistItemRule = html.defineImportRule({
+  $import: (ctx, el, $next) => {
+    const wrapper = el.querySelector(':scope > .checkbox-wrapper');
+    if (!wrapper) {
+      return $next();
+    }
+    const input = wrapper.querySelector(':scope > input[type="checkbox"]');
+    if (!input) {
+      return $next();
+    }
+    return $buildChecklistItem(ctx, el, input);
+  },
+  match: html.sel.tag('li').classAll('joplin-checkbox'),
+  name: '@lexical/list/li-joplin-checkbox'
+});
+
+/**
+ * A {@link ChildSchema} that enforces ListNode invariants: only
+ * `ListItemNode` and (immediately-nested) `ListNode` children are
+ * accepted; runs of other children get wrapped in a fresh
+ * `ListItemNode`.
+ *
+ * @experimental
+ */
+const ListSchema = {
+  $accepts: child => $isListItemNode(child) || $isListNode(child),
+  // Inline runs inside a `<ul>`/`<ol>` (e.g. text between two `<li>`s)
+  // become the children of a synthetic `ListItemNode`. `ListItemNode`
+  // is itself a block-level container of inlines, so no intermediate
+  // `ParagraphNode` is needed (and the demoted-paragraph normalization
+  // would strip one anyway).
+  $packageRun: run => [$createListItemNode().splice(0, 0, run)],
+  name: 'ListSchema'
+};
+
+/**
+ * Import rules for {@link ListNode} and {@link ListItemNode}, including
+ * GitHub task-list and Joplin checkbox heuristics.
+ *
+ * @experimental
+ */
+const ListImportRules = [
+// More specific rules (class-restricted) must precede the generic `li`
+// rule so they win the dispatch race (lower array index = higher
+// priority).
+TaskListItemRule, JoplinChecklistItemRule, ListRule, ListItemRule];
+
+/**
+ * Bundles {@link ListImportRules} together with the runtime
+ * {@link ListExtension}. The application is expected to already have
+ * `CoreImportExtension` (or some equivalent) in its dependency graph —
+ * the core/text/paragraph/inline-format rules are a shared baseline,
+ * not something this leaf importer should re-declare.
+ *
+ * @experimental
+ */
+const ListImportExtension = lexical.defineExtension({
+  dependencies: [ListExtension, lexical.configExtension(html.DOMImportExtension, {
+    rules: ListImportRules
+  })],
+  name: '@lexical/list/Import'
+});
+
+/**
+ * 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.
+ *
+ */
+
+
+/**
+ * @deprecated use {@link $insertList} from an update or command listener.
+ *
+ * Inserts a new ListNode. If the selection's anchor node is an empty ListItemNode and is a child of
+ * the root/shadow root, it will replace the ListItemNode with a ListNode and the old ListItemNode.
+ * Otherwise it will replace its parent with a new ListNode and re-insert the ListItemNode and any previous children.
+ * If the selection's anchor node is not an empty ListItemNode, it will add a new ListNode or merge an existing ListNode,
+ * unless the the node is a leaf node, in which case it will attempt to find a ListNode up the branch and replace it with
+ * a new ListNode, or create a new ListNode at the nearest root/shadow root.
+ * @param editor - The lexical editor.
+ * @param listType - The type of list, "number" | "bullet" | "check".
+ */
+function insertList(editor, listType) {
+  editor.update(() => $insertList(listType));
+}
+
+/**
+ * @deprecated use {@link $removeList} from an update or command listener.
+ *
+ * Searches for the nearest ancestral ListNode and removes it. If selection is an empty ListItemNode
+ * it will remove the whole list, including the ListItemNode. For each ListItemNode in the ListNode,
+ * removeList will also generate new ParagraphNodes in the removed ListNode's place. Any child node
+ * inside a ListItemNode will be appended to the new ParagraphNodes.
+ * @param editor - The lexical editor.
+ */
+function removeList(editor) {
+  editor.update(() => $removeList());
+}
+
 exports.$createListItemNode = $createListItemNode;
 exports.$createListNode = $createListNode;
 exports.$getListDepth = $getListDepth;
@@ -1867,8 +2119,11 @@ exports.INSERT_CHECK_LIST_COMMAND = INSERT_CHECK_LIST_COMMAND;
 exports.INSERT_ORDERED_LIST_COMMAND = INSERT_ORDERED_LIST_COMMAND;
 exports.INSERT_UNORDERED_LIST_COMMAND = INSERT_UNORDERED_LIST_COMMAND;
 exports.ListExtension = ListExtension;
+exports.ListImportExtension = ListImportExtension;
+exports.ListImportRules = ListImportRules;
 exports.ListItemNode = ListItemNode;
 exports.ListNode = ListNode;
+exports.ListSchema = ListSchema;
 exports.REMOVE_LIST_COMMAND = REMOVE_LIST_COMMAND;
 exports.UPDATE_LIST_START_COMMAND = UPDATE_LIST_START_COMMAND;
 exports.insertList = insertList;