@lexical/html 0.45.0 → 0.45.1-dev.0

package/dist/LexicalHtml.dev.js

@@ -1671,6 +1671,249 @@ function $getImportContextValue(cfg, editor = lexical.$getEditor()) {
  */
 const $withImportContext = $withContext(DOMImportContextSymbol, getDefaultImportContext);
 
+/**
+ * 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.
+ *
+ */
+
+
+/**
+ * True if the node fills a block slot at the root or inside another
+ * block — covers both ElementNode-style blocks (paragraph, heading,
+ * quote) and block-level DecoratorNodes (HorizontalRuleNode,
+ * ImageNode-as-block, etc.). Used by {@link BlockSchema},
+ * {@link RootSchema}, and {@link NestedBlockSchema}.
+ *
+ * @experimental
+ */
+function $isBlockLevel(node) {
+  return lexical.$isBlockElementNode(node) || lexical.$isDecoratorNode(node) && !node.isInline();
+}
+
+/**
+ * Distribute an inline wrapper (`LinkNode`, `MarkNode`, …) across a
+ * heterogeneous run of children produced by `$importChildren`, lifting
+ * any block children to the top level while keeping the wrapper around
+ * the leaf inline content.
+ *
+ * Use from a rule whose DOM source is an inline element that the
+ * browser permitted to enclose block elements — the canonical case is
+ * `<a href="…"><h1>title</h1><div>body</div></a>`, which a link rule
+ * wants to surface as two block siblings (heading + paragraph), each
+ * with its own link wrapping the original inline content. Schemas
+ * can't express this because they reason about a parent's children
+ * only — they cannot lift the parent out of itself.
+ *
+ * For each top-level child:
+ * - **Inline children** are collected into runs; each run is wrapped
+ *   in a single fresh wrapper (from `$makeWrapper()`).
+ * - **Block children** are descended into: their own children are
+ *   recursively distributed with `$makeWrapper`, then re-attached so
+ *   the block keeps its position at the top level.
+ *
+ * The returned list will contain a mix of blocks and wrapped inline
+ * runs. The enclosing schema (typically {@link BlockSchema}) will
+ * then package those inline wrappers into paragraphs as usual.
+ *
+ * @experimental
+ */
+function $distributeInlineWrapper(children, $makeWrapper) {
+  const out = [];
+  let inlineRun = [];
+  const flushInline = () => {
+    if (inlineRun.length === 0) {
+      return;
+    }
+    out.push($makeWrapper().splice(0, 0, inlineRun));
+    inlineRun = [];
+  };
+  for (const child of children) {
+    if ($isBlockLevel(child)) {
+      flushInline();
+      // Recursively distribute the wrapper into the block's own
+      // children. A block DecoratorNode (no children) is left alone.
+      if (lexical.$isElementNode(child)) {
+        const wrapped = $distributeInlineWrapper(child.getChildren(), $makeWrapper);
+        child.splice(0, child.getChildrenSize(), wrapped);
+      }
+      out.push(child);
+    } else {
+      inlineRun.push(child);
+    }
+  }
+  flushInline();
+  return out;
+}
+
+/**
+ * Apply a {@link ChildSchema} to a flat list of children produced by
+ * `$importChildren`. Walks the list once, partitions into accepted vs.
+ * rejected runs, packages or drops rejected runs, then runs `$finalize`.
+ *
+ * @internal
+ */
+function $applySchema(schema, children, parent, domParent) {
+  const out = [];
+  let run = null;
+  const flushRun = () => {
+    if (run === null) {
+      return;
+    }
+    const rejected = run;
+    run = null;
+    if (schema.$packageRun) {
+      const packaged = schema.$packageRun(rejected, parent, domParent);
+      if (packaged.length > 0) {
+        for (const n of packaged) {
+          out.push(n);
+        }
+        return;
+      }
+    }
+    // No $packageRun (or it returned []) — apply onReject. 'drop' (default)
+    // discards the run. 'hoist' lets it through unchanged at this level.
+    if (schema.onReject === 'hoist') {
+      for (const n of rejected) {
+        out.push(n);
+      }
+    }
+  };
+  for (const child of children) {
+    if (schema.$accepts(child, parent)) {
+      flushRun();
+      out.push(child);
+    } else {
+      if (run === null) {
+        run = [];
+      }
+      run.push(child);
+    }
+  }
+  flushRun();
+  return schema.$finalize ? schema.$finalize(out, parent) : out;
+}
+
+/**
+ * Apply a parent DOM element's `text-align` (when set to one of the
+ * supported {@link ElementFormatType} values) to each block-level child
+ * Lexical node that does not yet have its own format.
+ *
+ * Mirrors the part of the legacy `wrapContinuousInlines` that wrote
+ * `node.setFormat(textAlign)` onto pre-existing block children when the
+ * DOM parent carried `style.textAlign`. Pair with
+ * {@link $paragraphPackageRun} (which carries the same propagation onto
+ * paragraphs synthesized around inline runs) to fully replicate the
+ * legacy behavior on a run of mixed children.
+ *
+ * @experimental
+ */
+function $propagateTextAlignToBlockChildren(children, domParent) {
+  if (!lexical.isHTMLElement(domParent)) {
+    return children;
+  }
+  const textAlign = domParent.style.textAlign;
+  if (!isAlignmentValue(textAlign)) {
+    return children;
+  }
+  for (const child of children) {
+    if (lexical.$isBlockElementNode(child) && child.getFormatType() === '') {
+      child.setFormat(textAlign);
+    }
+  }
+  return children;
+}
+
+/**
+ * Wrap a run of inline lexical nodes in a fresh paragraph, propagating the
+ * `text-align` of `domParent` as the paragraph's format type (matching the
+ * legacy `wrapContinuousInlines` behavior).
+ */
+function $paragraphPackageRun(run, _parent, domParent) {
+  // Mirror the legacy `$wrapInlineNodes` (driven by
+  // `selection.insertNodes`) shortcut where a lone `<br>` at this
+  // level (a `LineBreakNode` is the only thing in the rejected run)
+  // becomes an *empty* paragraph rather than a paragraph wrapping a
+  // visible line break — that's the form clipboard pastes ending in a
+  // trailing `<br>` (Google Docs, Gmail, …) rely on for the editor's
+  // "extra trailing empty line" expectation.
+  if (run.length === 1 && lexical.$isLineBreakNode(run[0])) {
+    run = [];
+  }
+  const paragraph = lexical.$createParagraphNode();
+  if (lexical.isHTMLElement(domParent)) {
+    const textAlign = domParent.style.textAlign;
+    if (isAlignmentValue(textAlign)) {
+      paragraph.setFormat(textAlign);
+    }
+  }
+  return [paragraph.splice(0, 0, run)];
+}
+
+/**
+ * Default schema for block-level positions (root of the document, the body
+ * of a block element node). Accepts block lexical nodes; packages runs of
+ * inline children into fresh paragraph nodes.
+ *
+ * @experimental
+ */
+const BlockSchema = {
+  $accepts: $isBlockLevel,
+  $packageRun: $paragraphPackageRun,
+  name: 'BlockSchema'
+};
+
+/**
+ * Schema for inline-only positions (the body of an inline lexical node such
+ * as a link). Accepts non-block lexical nodes; runs of block children are
+ * dropped (`onReject: 'drop'` is the default).
+ *
+ * @experimental
+ */
+const InlineSchema = {
+  $accepts: child => !$isBlockLevel(child),
+  name: 'InlineSchema'
+};
+
+/**
+ * Schema for nested block positions — the equivalent of the legacy
+ * `ArtificialNode__DO_NOT_USE` flow used when a block DOM element appears
+ * inside another block lexical ancestor. Accepts block nodes; runs of inline
+ * children are emitted with a line break between consecutive runs (instead
+ * of being wrapped in a paragraph, which would introduce an extra level of
+ * nesting).
+ *
+ * @experimental
+ */
+const NestedBlockSchema = {
+  $accepts: $isBlockLevel,
+  /**
+   * Pass an inline run through unchanged. Because the schema iterator only
+   * groups *maximal* rejected runs (each separated from the next by an
+   * accepted block child), the legacy "linebreak between adjacent inline
+   * groups" case never arises — adjacent inline siblings are already
+   * coalesced into one run.
+   */
+  $packageRun: run => run,
+  name: 'NestedBlockSchema'
+};
+
+/**
+ * Schema for the topmost level of `$generateNodesFromDOM`. Identical to
+ * {@link BlockSchema}; aliased for clarity at the entry point and so it can
+ * be overridden separately in the future (e.g. to synthesize a `ListNode`
+ * around runs of orphan `ListItemNode`s).
+ *
+ * @experimental
+ */
+const RootSchema = {
+  $accepts: $isBlockLevel,
+  $packageRun: $paragraphPackageRun,
+  name: 'RootSchema'
+};
+
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
@@ -2024,7 +2267,13 @@ const IgnoreScriptStyleRule = defineImportRule({
   name: '@lexical/html/script-style-ignore'
 });
 const LineBreakRule = defineImportRule({
-  $import: () => [lexical.$createLineBreakNode()],
+  // Mirror the legacy LineBreakNode.importDOM filter: stray `<br>` that
+  // are the sole or trailing child of a block parent (e.g. Apple's
+  // `<br class="Apple-interchange-newline">` clipboard sentinel, or the
+  // trailing `<br>` browsers insert after the last text in a `<div>`)
+  // would otherwise survive as a LineBreakNode and tack an extra blank
+  // line onto the imported content.
+  $import: (_ctx, el) => lexical.isOnlyChildInBlockNode(el) || lexical.isLastChildInBlockNode(el) ? [] : [lexical.$createLineBreakNode()],
   match: sel$1.tag('br'),
   name: '@lexical/html/br'
 });
@@ -2054,6 +2303,51 @@ const ParagraphRule = defineImportRule({
   name: '@lexical/html/p'
 });
 
+/**
+ * Transparent block-container rule for any unconverted block-level DOM
+ * element — `<div>`, but also `<section>`, `<article>`, `<header>`,
+ * `<figure>`, … (everything {@link isBlockDomNode} recognizes via the
+ * legacy `BLOCK_TAG_RE`). Without it these would fall through to the
+ * dispatcher's `$hoistChildrenOf` / `DefaultHoistRule` fallback, which
+ * transparently lifts children up to the enclosing context. That works
+ * structurally, but (a) two sibling `<section>`s collapse into a single
+ * paragraph instead of two, and (b) any `text-align` set on the element
+ * is lost because the synthesized paragraph (built by the enclosing
+ * schema) sees the *grandparent* as `domParent`.
+ *
+ * The rule is registered as a `sel.any()` wildcard and defers (via
+ * `$next()`) for non-block elements so inline tags still reach the inline
+ * rules. Higher-priority tag rules (`<p>`, `<li>`, `<td>`, headings, …)
+ * are dispatched first and never reach here.
+ *
+ * The element's children run through {@link BlockSchema} so each inline
+ * run becomes its own `ParagraphNode` (with the element's `text-align`
+ * picked up via {@link $paragraphPackageRun}'s `domParent`), and any
+ * pre-existing block children get the same alignment applied via
+ * {@link $propagateTextAlignToBlockChildren}. The resulting block-level
+ * nodes are what the enclosing context sees — at the root a sibling
+ * paragraph is the natural shape; inside a block lexical container the
+ * container rule (e.g. {@link ListItemRule}) collapses paragraph
+ * children back into inline-with-line-break form. That way both `<p>`
+ * and transparent blocks (`<div>`, `<section>`, …) project to the same
+ * `ParagraphNode` intermediate, and there is no need for a marker node
+ * to distinguish them.
+ */
+const TransparentBlockRule = defineImportRule({
+  $import: (ctx, el, $next) => {
+    if (!lexical.isBlockDomNode(el)) {
+      // Inline element with no dedicated rule — let the inline rules (or
+      // the default hoist) handle it.
+      return $next();
+    }
+    return $propagateTextAlignToBlockChildren(ctx.$importChildren(el, {
+      schema: BlockSchema
+    }), el);
+  },
+  match: sel$1.any(),
+  name: '@lexical/html/transparent-block'
+});
+
 /**
  * Rules covering the {@link ParagraphNode}, {@link TextNode},
  * {@link LineBreakNode}, and {@link TabNode} cases that the legacy
@@ -2063,7 +2357,7 @@ const ParagraphRule = defineImportRule({
  *
  * @experimental
  */
-const CoreImportRules = [IgnoreScriptStyleRule, ParagraphRule, TextRule, LineBreakRule, InlineFormatRule];
+const CoreImportRules = [IgnoreScriptStyleRule, ParagraphRule, TransparentBlockRule, TextRule, LineBreakRule, InlineFormatRule];
 
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
@@ -2282,209 +2576,6 @@ function defineOverlayRules(entries) {
   };
 }
 
-/**
- * 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.
- *
- */
-
-
-/**
- * True if the node fills a block slot at the root or inside another
- * block — covers both ElementNode-style blocks (paragraph, heading,
- * quote) and block-level DecoratorNodes (HorizontalRuleNode,
- * ImageNode-as-block, etc.). Used by {@link BlockSchema},
- * {@link RootSchema}, and {@link NestedBlockSchema}.
- *
- * @experimental
- */
-function $isBlockLevel(node) {
-  return lexical.$isBlockElementNode(node) || lexical.$isDecoratorNode(node) && !node.isInline();
-}
-
-/**
- * Distribute an inline wrapper (`LinkNode`, `MarkNode`, …) across a
- * heterogeneous run of children produced by `$importChildren`, lifting
- * any block children to the top level while keeping the wrapper around
- * the leaf inline content.
- *
- * Use from a rule whose DOM source is an inline element that the
- * browser permitted to enclose block elements — the canonical case is
- * `<a href="…"><h1>title</h1><div>body</div></a>`, which a link rule
- * wants to surface as two block siblings (heading + paragraph), each
- * with its own link wrapping the original inline content. Schemas
- * can't express this because they reason about a parent's children
- * only — they cannot lift the parent out of itself.
- *
- * For each top-level child:
- * - **Inline children** are collected into runs; each run is wrapped
- *   in a single fresh wrapper (from `$makeWrapper()`).
- * - **Block children** are descended into: their own children are
- *   recursively distributed with `$makeWrapper`, then re-attached so
- *   the block keeps its position at the top level.
- *
- * The returned list will contain a mix of blocks and wrapped inline
- * runs. The enclosing schema (typically {@link BlockSchema}) will
- * then package those inline wrappers into paragraphs as usual.
- *
- * @experimental
- */
-function $distributeInlineWrapper(children, $makeWrapper) {
-  const out = [];
-  let inlineRun = [];
-  const flushInline = () => {
-    if (inlineRun.length === 0) {
-      return;
-    }
-    out.push($makeWrapper().splice(0, 0, inlineRun));
-    inlineRun = [];
-  };
-  for (const child of children) {
-    if ($isBlockLevel(child)) {
-      flushInline();
-      // Recursively distribute the wrapper into the block's own
-      // children. A block DecoratorNode (no children) is left alone.
-      if (lexical.$isElementNode(child)) {
-        const wrapped = $distributeInlineWrapper(child.getChildren(), $makeWrapper);
-        child.splice(0, child.getChildrenSize(), wrapped);
-      }
-      out.push(child);
-    } else {
-      inlineRun.push(child);
-    }
-  }
-  flushInline();
-  return out;
-}
-
-/**
- * Apply a {@link ChildSchema} to a flat list of children produced by
- * `$importChildren`. Walks the list once, partitions into accepted vs.
- * rejected runs, packages or drops rejected runs, then runs `$finalize`.
- *
- * @internal
- */
-function $applySchema(schema, children, parent, domParent) {
-  const out = [];
-  let run = null;
-  const flushRun = () => {
-    if (run === null) {
-      return;
-    }
-    const rejected = run;
-    run = null;
-    if (schema.$packageRun) {
-      const packaged = schema.$packageRun(rejected, parent, domParent);
-      if (packaged.length > 0) {
-        for (const n of packaged) {
-          out.push(n);
-        }
-        return;
-      }
-    }
-    // No $packageRun (or it returned []) — apply onReject. 'drop' (default)
-    // discards the run. 'hoist' lets it through unchanged at this level.
-    if (schema.onReject === 'hoist') {
-      for (const n of rejected) {
-        out.push(n);
-      }
-    }
-  };
-  for (const child of children) {
-    if (schema.$accepts(child, parent)) {
-      flushRun();
-      out.push(child);
-    } else {
-      if (run === null) {
-        run = [];
-      }
-      run.push(child);
-    }
-  }
-  flushRun();
-  return schema.$finalize ? schema.$finalize(out, parent) : out;
-}
-
-/**
- * Wrap a run of inline lexical nodes in a fresh paragraph, propagating the
- * `text-align` of `domParent` as the paragraph's format type (matching the
- * legacy `wrapContinuousInlines` behavior).
- */
-function $paragraphPackageRun(run, _parent, domParent) {
-  const paragraph = lexical.$createParagraphNode();
-  if (lexical.isHTMLElement(domParent)) {
-    const textAlign = domParent.style.textAlign;
-    if (isAlignmentValue(textAlign)) {
-      paragraph.setFormat(textAlign);
-    }
-  }
-  return [paragraph.splice(0, 0, run)];
-}
-
-/**
- * Default schema for block-level positions (root of the document, the body
- * of a block element node). Accepts block lexical nodes; packages runs of
- * inline children into fresh paragraph nodes.
- *
- * @experimental
- */
-const BlockSchema = {
-  $accepts: $isBlockLevel,
-  $packageRun: $paragraphPackageRun,
-  name: 'BlockSchema'
-};
-
-/**
- * Schema for inline-only positions (the body of an inline lexical node such
- * as a link). Accepts non-block lexical nodes; runs of block children are
- * dropped (`onReject: 'drop'` is the default).
- *
- * @experimental
- */
-const InlineSchema = {
-  $accepts: child => !$isBlockLevel(child),
-  name: 'InlineSchema'
-};
-
-/**
- * Schema for nested block positions — the equivalent of the legacy
- * `ArtificialNode__DO_NOT_USE` flow used when a block DOM element appears
- * inside another block lexical ancestor. Accepts block nodes; runs of inline
- * children are emitted with a line break between consecutive runs (instead
- * of being wrapped in a paragraph, which would introduce an extra level of
- * nesting).
- *
- * @experimental
- */
-const NestedBlockSchema = {
-  $accepts: $isBlockLevel,
-  /**
-   * Pass an inline run through unchanged. Because the schema iterator only
-   * groups *maximal* rejected runs (each separated from the next by an
-   * accepted block child), the legacy "linebreak between adjacent inline
-   * groups" case never arises — adjacent inline siblings are already
-   * coalesced into one run.
-   */
-  $packageRun: run => run,
-  name: 'NestedBlockSchema'
-};
-
-/**
- * Schema for the topmost level of `$generateNodesFromDOM`. Identical to
- * {@link BlockSchema}; aliased for clarity at the entry point and so it can
- * be overridden separately in the future (e.g. to synthesize a `ListNode`
- * around runs of orphan `ListItemNode`s).
- *
- * @experimental
- */
-const RootSchema = {
-  $accepts: $isBlockLevel,
-  $packageRun: $paragraphPackageRun,
-  name: 'RootSchema'
-};
-
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
@@ -2833,20 +2924,21 @@ const HorizontalRuleRule = defineImportRule({
 const HorizontalRuleImportRules = [HorizontalRuleRule];
 
 /**
- * Bundles {@link HorizontalRuleImportRules} (plus
- * {@link CoreImportExtension}) into a single dependency. The legacy
- * {@link HorizontalRuleExtension.importDOM} continues to work in parallel;
- * depend on this extension to opt into the new pipeline.
+ * Bundles {@link HorizontalRuleImportRules} together with the runtime
+ * {@link HorizontalRuleExtension}. 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.
  *
  * Lives in `@lexical/html` (not `@lexical/extension`) because
  * {@link DOMImportExtension} itself is in `@lexical/html`, and
  * `@lexical/extension` is upstream of `@lexical/html` in the dependency
- * graph — same arrangement as {@link CoreImportExtension}.
+ * graph.
  *
  * @experimental
  */
 const HorizontalRuleImportExtension = lexical.defineExtension({
-  dependencies: [CoreImportExtension, extension.HorizontalRuleExtension, lexical.configExtension(DOMImportExtension, {
+  dependencies: [extension.HorizontalRuleExtension, lexical.configExtension(DOMImportExtension, {
     rules: HorizontalRuleImportRules
   })],
   name: '@lexical/html/HorizontalRuleImport'
@@ -2954,6 +3046,10 @@ function $generateHtmlFromNodes(editor, selection = null) {
       formatDevErrorMessage(`To use $generateHtmlFromNodes in headless mode please initialize a headless browser implementation such as JSDom or use withDOM from @lexical/headless/dom before calling this function.`);
     }
   }
+  // BC: $setTextContent now requires an active-editor scope (added in #8519).
+  // If the caller is in a legacy `editorState.read(cb)` scope (no active editor),
+  // establish one via internal API.
+  lexical.$assumeActiveEditor(editor);
   return $generateDOMFromNodes(document.createElement('div'), selection, editor).innerHTML;
 }
 function $appendNodesToHTML(editor, currentNode, parentElementAppend, selection$1 = null, domConfig = lexical.$getEditorDOMRenderConfig(editor)) {
@@ -3156,6 +3252,7 @@ exports.$getRenderContextValue = $getRenderContextValue;
 exports.$getSessionDOMRenderConfig = $getSessionDOMRenderConfig;
 exports.$inlineStylesFromStyleSheets = $inlineStylesFromStyleSheets;
 exports.$isBlockLevel = $isBlockLevel;
+exports.$propagateTextAlignToBlockChildren = $propagateTextAlignToBlockChildren;
 exports.$setRenderContextValue = $setRenderContextValue;
 exports.$updateRenderContextValue = $updateRenderContextValue;
 exports.$withImportContext = $withImportContext;