@lexical/markdown 0.50.1-nightly.20260916.0 → 0.51.0

package/dist/utils.d.ts

@@ -6,21 +6,7 @@
  *
  */
 import type { ElementTransformer, MultilineElementTransformer, TextFormatTransformer, TextMatchTransformer, Transformer } from './MarkdownTransformers.js';
-import { type ElementNode, type LexicalNode, type TextFormatType } from 'lexical';
-type MarkdownFormatKind = 'noTransformation' | 'paragraphH1' | 'paragraphH2' | 'paragraphH3' | 'paragraphH4' | 'paragraphH5' | 'paragraphH6' | 'paragraphBlockQuote' | 'paragraphUnorderedList' | 'paragraphOrderedList' | 'paragraphCodeBlock' | 'horizontalRule' | 'bold' | 'code' | 'italic' | 'underline' | 'strikethrough' | 'italic_bold' | 'strikethrough_italic' | 'strikethrough_bold' | 'strikethrough_italic_bold' | 'link';
-type MarkdownCriteria = Readonly<{
-    export?: (node: LexicalNode, traverseChildren: (elementNode: ElementNode) => string) => string | null;
-    exportFormat?: TextFormatType;
-    exportTag?: string;
-    exportTagClose?: string;
-    markdownFormatKind: MarkdownFormatKind | null | undefined;
-    regEx: RegExp;
-    regExForAutoFormatting: RegExp;
-    requiresParagraphStart: boolean | null | undefined;
-}>;
-type MarkdownCriteriaArray = MarkdownCriteria[];
-export declare function getAllMarkdownCriteriaForParagraphs(): MarkdownCriteriaArray;
-export declare function getAllMarkdownCriteriaForTextNodes(): MarkdownCriteriaArray;
+import { type LexicalNode } from 'lexical';
 export declare function indexBy<T>(list: T[], callback: (arg0: T) => string | undefined): Readonly<Record<string, T[]>>;
 export declare function transformersByType(transformers: Transformer[]): Readonly<{
     element: ElementTransformer[];
@@ -33,4 +19,3 @@ export declare const WHITESPACE: RegExp;
 export declare const PUNCTUATION: RegExp;
 export declare function isEmptyParagraph(node: LexicalNode): boolean;
 export declare function unescapeText(value: string): string;
-export {};

package/package.json

@@ -8,19 +8,19 @@
     "markdown"
   ],
   "license": "MIT",
-  "version": "0.50.1-nightly.20260916.0",
+  "version": "0.51.0",
   "main": "./dist/LexicalMarkdown.js",
   "types": "./dist/typescript-too-old.d.ts",
   "dependencies": {
-    "@lexical/code-core": "0.50.1-nightly.20260916.0",
-    "@lexical/internal": "0.50.1-nightly.20260916.0",
-    "@lexical/link": "0.50.1-nightly.20260916.0",
-    "@lexical/list": "0.50.1-nightly.20260916.0",
-    "@lexical/rich-text": "0.50.1-nightly.20260916.0",
-    "@lexical/selection": "0.50.1-nightly.20260916.0",
-    "@lexical/text": "0.50.1-nightly.20260916.0",
-    "@lexical/utils": "0.50.1-nightly.20260916.0",
-    "lexical": "0.50.1-nightly.20260916.0"
+    "@lexical/code-core": "0.51.0",
+    "@lexical/internal": "0.51.0",
+    "@lexical/link": "0.51.0",
+    "@lexical/list": "0.51.0",
+    "@lexical/rich-text": "0.51.0",
+    "@lexical/selection": "0.51.0",
+    "@lexical/text": "0.51.0",
+    "@lexical/utils": "0.51.0",
+    "lexical": "0.51.0"
   },
   "repository": {
     "type": "git",

package/src/utils.ts

@@ -14,392 +14,7 @@ import type {
   Transformer,
 } from './MarkdownTransformers';
 
-import {$isCodeNode} from '@lexical/code-core';
-import {$isListItemNode, $isListNode, type ListNode} from '@lexical/list';
-import {$isHeadingNode, $isQuoteNode} from '@lexical/rich-text';
-import {
-  $isParagraphNode,
-  $isTextNode,
-  type ElementNode,
-  type LexicalNode,
-  type TextFormatType,
-} from 'lexical';
-
-type MarkdownFormatKind =
-  | 'noTransformation'
-  | 'paragraphH1'
-  | 'paragraphH2'
-  | 'paragraphH3'
-  | 'paragraphH4'
-  | 'paragraphH5'
-  | 'paragraphH6'
-  | 'paragraphBlockQuote'
-  | 'paragraphUnorderedList'
-  | 'paragraphOrderedList'
-  | 'paragraphCodeBlock'
-  | 'horizontalRule'
-  | 'bold'
-  | 'code'
-  | 'italic'
-  | 'underline'
-  | 'strikethrough'
-  | 'italic_bold'
-  | 'strikethrough_italic'
-  | 'strikethrough_bold'
-  | 'strikethrough_italic_bold'
-  | 'link';
-
-type MarkdownCriteria = Readonly<{
-  export?: (
-    node: LexicalNode,
-    traverseChildren: (elementNode: ElementNode) => string,
-  ) => string | null;
-  exportFormat?: TextFormatType;
-  exportTag?: string;
-  exportTagClose?: string;
-  markdownFormatKind: MarkdownFormatKind | null | undefined;
-  regEx: RegExp;
-  regExForAutoFormatting: RegExp;
-  requiresParagraphStart: boolean | null | undefined;
-}>;
-
-type MarkdownCriteriaArray = MarkdownCriteria[];
-
-const autoFormatBase: MarkdownCriteria = {
-  markdownFormatKind: null,
-  regEx: /(?:)/,
-  regExForAutoFormatting: /(?:)/,
-  requiresParagraphStart: false,
-};
-
-const paragraphStartBase: MarkdownCriteria = {
-  ...autoFormatBase,
-  requiresParagraphStart: true,
-};
-
-const markdownHeader1: MarkdownCriteria = {
-  ...paragraphStartBase,
-  export: createHeadingExport(1),
-  markdownFormatKind: 'paragraphH1',
-  regEx: /^(?:# )/,
-  regExForAutoFormatting: /^(?:# )/,
-};
-
-const markdownHeader2: MarkdownCriteria = {
-  ...paragraphStartBase,
-  export: createHeadingExport(2),
-  markdownFormatKind: 'paragraphH2',
-  regEx: /^(?:## )/,
-  regExForAutoFormatting: /^(?:## )/,
-};
-
-const markdownHeader3: MarkdownCriteria = {
-  ...paragraphStartBase,
-  export: createHeadingExport(3),
-  markdownFormatKind: 'paragraphH3',
-  regEx: /^(?:### )/,
-  regExForAutoFormatting: /^(?:### )/,
-};
-
-const markdownHeader4: MarkdownCriteria = {
-  ...paragraphStartBase,
-  export: createHeadingExport(4),
-  markdownFormatKind: 'paragraphH4',
-  regEx: /^(?:#### )/,
-  regExForAutoFormatting: /^(?:#### )/,
-};
-
-const markdownHeader5: MarkdownCriteria = {
-  ...paragraphStartBase,
-  export: createHeadingExport(5),
-  markdownFormatKind: 'paragraphH5',
-  regEx: /^(?:##### )/,
-  regExForAutoFormatting: /^(?:##### )/,
-};
-
-const markdownHeader6: MarkdownCriteria = {
-  ...paragraphStartBase,
-  export: createHeadingExport(6),
-  markdownFormatKind: 'paragraphH6',
-  regEx: /^(?:###### )/,
-  regExForAutoFormatting: /^(?:###### )/,
-};
-
-const markdownBlockQuote: MarkdownCriteria = {
-  ...paragraphStartBase,
-  export: blockQuoteExport,
-  markdownFormatKind: 'paragraphBlockQuote',
-  regEx: /^(?:> )/,
-  regExForAutoFormatting: /^(?:> )/,
-};
-
-const markdownUnorderedListDash: MarkdownCriteria = {
-  ...paragraphStartBase,
-  export: listExport,
-  markdownFormatKind: 'paragraphUnorderedList',
-  regEx: /^(\s{0,10})(?:- )/,
-  regExForAutoFormatting: /^(\s{0,10})(?:- )/,
-};
-
-const markdownUnorderedListAsterisk: MarkdownCriteria = {
-  ...paragraphStartBase,
-  export: listExport,
-  markdownFormatKind: 'paragraphUnorderedList',
-  regEx: /^(\s{0,10})(?:\* )/,
-  regExForAutoFormatting: /^(\s{0,10})(?:\* )/,
-};
-
-const markdownCodeBlock: MarkdownCriteria = {
-  ...paragraphStartBase,
-  export: codeBlockExport,
-  markdownFormatKind: 'paragraphCodeBlock',
-  regEx: /^(```)$/,
-  regExForAutoFormatting: /^(```)([a-z]*)( )/,
-};
-
-const markdownOrderedList: MarkdownCriteria = {
-  ...paragraphStartBase,
-  export: listExport,
-  markdownFormatKind: 'paragraphOrderedList',
-  regEx: /^(\s{0,10})(\d+)\.\s/,
-  regExForAutoFormatting: /^(\s{0,10})(\d+)\.\s/,
-};
-
-const markdownHorizontalRule: MarkdownCriteria = {
-  ...paragraphStartBase,
-  markdownFormatKind: 'horizontalRule',
-  regEx: /^(?:\*\*\*)$/,
-  regExForAutoFormatting: /^(?:\*\*\* )/,
-};
-
-const markdownHorizontalRuleUsingDashes: MarkdownCriteria = {
-  ...paragraphStartBase,
-  markdownFormatKind: 'horizontalRule',
-  regEx: /^(?:---)$/,
-  regExForAutoFormatting: /^(?:--- )/,
-};
-
-const markdownInlineCode: MarkdownCriteria = {
-  ...autoFormatBase,
-  exportFormat: 'code',
-  exportTag: '`',
-  markdownFormatKind: 'code',
-  regEx: /(`)(\s*)([^`]*)(\s*)(`)()/,
-  regExForAutoFormatting: /(`)(\s*\b)([^`]*)(\b\s*)(`)(\s)$/,
-};
-
-const markdownBold: MarkdownCriteria = {
-  ...autoFormatBase,
-  exportFormat: 'bold',
-  exportTag: '**',
-  markdownFormatKind: 'bold',
-  regEx: /(\*\*)(\s*)([^**]*)(\s*)(\*\*)()/,
-  regExForAutoFormatting: /(\*\*)(\s*\b)([^**]*)(\b\s*)(\*\*)(\s)$/,
-};
-
-const markdownItalic: MarkdownCriteria = {
-  ...autoFormatBase,
-  exportFormat: 'italic',
-  exportTag: '*',
-  markdownFormatKind: 'italic',
-  regEx: /(\*)(\s*)([^*]*)(\s*)(\*)()/,
-  regExForAutoFormatting: /(\*)(\s*\b)([^*]*)(\b\s*)(\*)(\s)$/,
-};
-
-const markdownBold2: MarkdownCriteria = {
-  ...autoFormatBase,
-  exportFormat: 'bold',
-  exportTag: '_',
-  markdownFormatKind: 'bold',
-  regEx: /(__)(\s*)([^__]*)(\s*)(__)()/,
-  regExForAutoFormatting: /(__)(\s*)([^__]*)(\s*)(__)(\s)$/,
-};
-
-const markdownItalic2: MarkdownCriteria = {
-  ...autoFormatBase,
-  exportFormat: 'italic',
-  exportTag: '_',
-  markdownFormatKind: 'italic',
-  regEx: /(_)()([^_]*)()(_)()/,
-  regExForAutoFormatting: /(_)()([^_]*)()(_)(\s)$/, // Maintain 7 groups.
-};
-
-const fakeMarkdownUnderline: MarkdownCriteria = {
-  ...autoFormatBase,
-  exportFormat: 'underline',
-  exportTag: '<u>',
-  exportTagClose: '</u>',
-  markdownFormatKind: 'underline',
-  regEx: /(<u>)(\s*)([^<]*)(\s*)(<\/u>)()/,
-  regExForAutoFormatting: /(<u>)(\s*\b)([^<]*)(\b\s*)(<\/u>)(\s)$/,
-};
-
-const markdownStrikethrough: MarkdownCriteria = {
-  ...autoFormatBase,
-  exportFormat: 'strikethrough',
-  exportTag: '~~',
-  markdownFormatKind: 'strikethrough',
-  regEx: /(~~)(\s*)([^~~]*)(\s*)(~~)()/,
-  regExForAutoFormatting: /(~~)(\s*\b)([^~~]*)(\b\s*)(~~)(\s)$/,
-};
-
-const markdownStrikethroughItalicBold: MarkdownCriteria = {
-  ...autoFormatBase,
-  markdownFormatKind: 'strikethrough_italic_bold',
-  regEx: /(~~_\*\*)(\s*\b)([^~~_**][^**_~~]*)(\b\s*)(\*\*_~~)()/,
-  regExForAutoFormatting:
-    /(~~_\*\*)(\s*\b)([^~~_**][^**_~~]*)(\b\s*)(\*\*_~~)(\s)$/,
-};
-
-const markdownItalicbold: MarkdownCriteria = {
-  ...autoFormatBase,
-  markdownFormatKind: 'italic_bold',
-  regEx: /(_\*\*)(\s*\b)([^_**][^**_]*)(\b\s*)(\*\*_)/,
-  regExForAutoFormatting: /(_\*\*)(\s*\b)([^_**][^**_]*)(\b\s*)(\*\*_)(\s)$/,
-};
-
-const markdownStrikethroughItalic: MarkdownCriteria = {
-  ...autoFormatBase,
-  markdownFormatKind: 'strikethrough_italic',
-  regEx: /(~~_)(\s*)([^~~_][^_~~]*)(\s*)(_~~)/,
-  regExForAutoFormatting: /(~~_)(\s*)([^~~_][^_~~]*)(\s*)(_~~)(\s)$/,
-};
-
-const markdownStrikethroughBold: MarkdownCriteria = {
-  ...autoFormatBase,
-  markdownFormatKind: 'strikethrough_bold',
-  regEx: /(~~\*\*)(\s*\b)([^~~**][^**~~]*)(\b\s*)(\*\*~~)/,
-  regExForAutoFormatting:
-    /(~~\*\*)(\s*\b)([^~~**][^**~~]*)(\b\s*)(\*\*~~)(\s)$/,
-};
-
-const markdownLink: MarkdownCriteria = {
-  ...autoFormatBase,
-  markdownFormatKind: 'link',
-  regEx: /(\[)([^\]]*)(\]\()([^)]*)(\)*)()/,
-  regExForAutoFormatting: /(\[)([^\]]*)(\]\()([^)]*)(\)*)(\s)$/,
-};
-
-const allMarkdownCriteriaForTextNodes: MarkdownCriteriaArray = [
-  // Place the combination formats ahead of the individual formats.
-  // Combos
-  markdownStrikethroughItalicBold,
-  markdownItalicbold,
-  markdownStrikethroughItalic,
-  markdownStrikethroughBold, // Individuals
-  markdownInlineCode,
-  markdownBold,
-  markdownItalic, // Must appear after markdownBold
-  markdownBold2,
-  markdownItalic2, // Must appear after markdownBold2.
-  fakeMarkdownUnderline,
-  markdownStrikethrough,
-  markdownLink,
-];
-
-const allMarkdownCriteriaForParagraphs: MarkdownCriteriaArray = [
-  markdownHeader1,
-  markdownHeader2,
-  markdownHeader3,
-  markdownHeader4,
-  markdownHeader5,
-  markdownHeader6,
-  markdownBlockQuote,
-  markdownUnorderedListDash,
-  markdownUnorderedListAsterisk,
-  markdownOrderedList,
-  markdownCodeBlock,
-  markdownHorizontalRule,
-  markdownHorizontalRuleUsingDashes,
-];
-
-export function getAllMarkdownCriteriaForParagraphs(): MarkdownCriteriaArray {
-  return allMarkdownCriteriaForParagraphs;
-}
-
-export function getAllMarkdownCriteriaForTextNodes(): MarkdownCriteriaArray {
-  return allMarkdownCriteriaForTextNodes;
-}
-
-type Block = (
-  node: LexicalNode,
-  exportChildren: (elementNode: ElementNode) => string,
-) => string | null;
-
-function createHeadingExport(level: number): Block {
-  return (node, exportChildren) => {
-    return $isHeadingNode(node) && node.getTag() === 'h' + level
-      ? '#'.repeat(level) + ' ' + exportChildren(node)
-      : null;
-  };
-}
-
-function listExport(
-  node: LexicalNode,
-  exportChildren: (_node: ElementNode) => string,
-) {
-  return $isListNode(node) ? processNestedLists(node, exportChildren, 0) : null;
-}
-
-// TODO: should be param
-const LIST_INDENT_SIZE = 4;
-
-function processNestedLists(
-  listNode: ListNode,
-  exportChildren: (node: ElementNode) => string,
-  depth: number,
-): string {
-  const output = [];
-  const children = listNode.getChildren();
-  let index = 0;
-
-  for (const listItemNode of children) {
-    if ($isListItemNode(listItemNode)) {
-      if (listItemNode.getChildrenSize() === 1) {
-        const firstChild = listItemNode.getFirstChild();
-
-        if ($isListNode(firstChild)) {
-          output.push(
-            processNestedLists(firstChild, exportChildren, depth + 1),
-          );
-          continue;
-        }
-      }
-
-      const indent = ' '.repeat(depth * LIST_INDENT_SIZE);
-      const prefix =
-        listNode.getListType() === 'bullet'
-          ? '- '
-          : `${listNode.getStart() + index}. `;
-      output.push(indent + prefix + exportChildren(listItemNode));
-      index++;
-    }
-  }
-
-  return output.join('\n');
-}
-
-function blockQuoteExport(
-  node: LexicalNode,
-  exportChildren: (_node: ElementNode) => string,
-) {
-  return $isQuoteNode(node) ? '> ' + exportChildren(node) : null;
-}
-
-function codeBlockExport(node: LexicalNode) {
-  if (!$isCodeNode(node)) {
-    return null;
-  }
-
-  const textContent = node.getTextContent();
-  return (
-    '```' +
-    (node.getLanguage() || '') +
-    (textContent ? '\n' + textContent : '') +
-    '\n' +
-    '```'
-  );
-}
+import {$isParagraphNode, $isTextNode, type LexicalNode} from 'lexical';
 
 export function indexBy<T>(
   list: T[],