@payloadcms/richtext-lexical 3.91.0-internal.c1569dc → 4.0.0-beta.0

package/dist/packages/@lexical/markdown/LexicalMarkdownHardLineBreak.spec.js

@@ -1,160 +0,0 @@
-import { createHeadlessEditor } from '@lexical/headless';
-import { LinkNode } from '@lexical/link';
-import { ListItemNode, ListNode } from '@lexical/list';
-import { HeadingNode, QuoteNode } from '@lexical/rich-text';
-import { $getRoot, $getState, $isElementNode, $isLineBreakNode, $isTextNode } from 'lexical';
-import { describe, expect, it } from 'vitest';
-import { $convertFromMarkdownString, $convertToMarkdownString } from './index.js';
-import { hardLineBreakState, normalizeMarkdown } from './MarkdownTransformers.js';
-function createEditor() {
-  return createHeadlessEditor({
-    nodes: [HeadingNode, QuoteNode, ListNode, ListItemNode, LinkNode]
-  });
-}
-function importMarkdown(markdown) {
-  const editor = createEditor();
-  editor.update(() => $convertFromMarkdownString(markdown), {
-    discrete: true
-  });
-  let result = {
-    hasLineBreak: false,
-    textContent: ''
-  };
-  editor.getEditorState().read(() => {
-    const firstChild = $getRoot().getFirstChild();
-    if (!$isElementNode(firstChild)) {
-      throw new Error('Expected an element block');
-    }
-    result = {
-      hasLineBreak: firstChild.getChildren().some(child => $isLineBreakNode(child)),
-      textContent: firstChild.getTextContent()
-    };
-  });
-  return result;
-}
-// Returns the hard line break marker stored on the first LineBreakNode of the
-// first block, plus the text content of every text node in that block. Used to
-// assert the marker was moved off the text and onto the line break node, even
-// when the trailing whitespace was split into its own text node by an inline
-// transformer (e.g. after bold or a link).
-function getStoredHardLineBreak(markdown) {
-  const editor = createEditor();
-  editor.update(() => $convertFromMarkdownString(markdown), {
-    discrete: true
-  });
-  let result = {
-    marker: '',
-    textNodeTexts: []
-  };
-  editor.getEditorState().read(() => {
-    const block = $getRoot().getFirstChild();
-    if (!$isElementNode(block)) {
-      throw new Error('Expected an element block');
-    }
-    const lineBreakNode = block.getChildren().find(child => $isLineBreakNode(child));
-    if (lineBreakNode === undefined) {
-      throw new Error('Expected a line break node');
-    }
-    result = {
-      marker: $getState(lineBreakNode, hardLineBreakState),
-      textNodeTexts: block.getChildren().filter($isTextNode).map(child => child.getTextContent())
-    };
-  });
-  return result;
-}
-function roundTrip(markdown) {
-  const editor = createEditor();
-  editor.update(() => $convertFromMarkdownString(markdown), {
-    discrete: true
-  });
-  let output = '';
-  editor.getEditorState().read(() => {
-    output = $convertToMarkdownString();
-  });
-  return output;
-}
-describe('markdown hard line break normalization', () => {
-  it('should preserve trailing-space hard breaks when merging adjacent lines', () => {
-    const md = ['foo  ', 'bar'].join('\n');
-    expect(normalizeMarkdown(md, true)).toBe(md);
-  });
-  it('should preserve the exact number of trailing spaces', () => {
-    const md = ['foo   ', 'bar'].join('\n');
-    expect(normalizeMarkdown(md, true)).toBe(md);
-  });
-  it('should preserve backslash hard breaks when merging adjacent lines', () => {
-    const md = 'foo\\\nbar';
-    expect(normalizeMarkdown(md, true)).toBe(md);
-  });
-  it('should still merge a soft break into the previous line', () => {
-    const md = ['foo', 'bar'].join('\n');
-    expect(normalizeMarkdown(md, true)).toBe('foo bar');
-  });
-  it('should merge a soft break before a hard-breaking line', () => {
-    const md = ['foo', 'bar  ', 'baz'].join('\n');
-    expect(normalizeMarkdown(md, true)).toBe(['foo bar  ', 'baz'].join('\n'));
-  });
-});
-describe('markdown hard line break import', () => {
-  it('should import a trailing-space hard break as a line break node with the marker stripped', () => {
-    const {
-      hasLineBreak,
-      textContent
-    } = importMarkdown(['foo  ', 'bar'].join('\n'));
-    expect(hasLineBreak).toBe(true);
-    // The marker is stripped from the text and represented by the line break node.
-    expect(textContent).toBe('foo\nbar');
-  });
-  it('should import a backslash hard break as a line break node with the marker stripped', () => {
-    const {
-      hasLineBreak,
-      textContent
-    } = importMarkdown('foo\\\nbar');
-    expect(hasLineBreak).toBe(true);
-    expect(textContent).toBe('foo\nbar');
-  });
-  it('should store the marker on the line break when the hard break follows formatted text', () => {
-    const {
-      marker,
-      textNodeTexts
-    } = getStoredHardLineBreak('**foo**  \nbar');
-    expect(marker).toBe('  ');
-    // The trailing-space marker is split into its own text node by the bold
-    // transformer; it must be moved onto the line break node, not left as text.
-    expect(textNodeTexts).not.toContain('  ');
-  });
-  it('should store the exact number of trailing spaces when the hard break follows formatted text', () => {
-    const {
-      marker
-    } = getStoredHardLineBreak('**foo**   \nbar');
-    expect(marker).toBe('   ');
-  });
-  it('should store the marker on the line break when the hard break follows a link', () => {
-    const {
-      marker
-    } = getStoredHardLineBreak('[foo](https://payloadcms.com)  \nbar');
-    expect(marker).toBe('  ');
-  });
-});
-describe('markdown hard line break round trip', () => {
-  it('should round trip a trailing-space hard break', () => {
-    const md = ['foo  ', 'bar'].join('\n');
-    expect(roundTrip(md)).toBe(md);
-  });
-  it('should round trip a backslash hard break', () => {
-    const md = 'foo\\\nbar';
-    expect(roundTrip(md)).toBe(md);
-  });
-  it('should not introduce a hard break for a soft wrap', () => {
-    expect(roundTrip(['foo', 'bar'].join('\n'))).toBe('foo bar');
-  });
-  it('should round trip a hard break after formatted text', () => {
-    const md = '**foo**  \nbar';
-    expect(roundTrip(md)).toBe(md);
-  });
-  it('should round trip a hard break after a link', () => {
-    const md = '[foo](https://payloadcms.com)  \nbar';
-    expect(roundTrip(md)).toBe(md);
-  });
-});
-//# sourceMappingURL=LexicalMarkdownHardLineBreak.spec.js.map

package/dist/packages/@lexical/markdown/LexicalMarkdownHardLineBreak.spec.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"LexicalMarkdownHardLineBreak.spec.js","names":["createHeadlessEditor","LinkNode","ListItemNode","ListNode","HeadingNode","QuoteNode","$getRoot","$getState","$isElementNode","$isLineBreakNode","$isTextNode","describe","expect","it","$convertFromMarkdownString","$convertToMarkdownString","hardLineBreakState","normalizeMarkdown","createEditor","nodes","importMarkdown","markdown","editor","update","discrete","result","hasLineBreak","textContent","getEditorState","read","firstChild","getFirstChild","Error","getChildren","some","child","getTextContent","getStoredHardLineBreak","marker","textNodeTexts","block","lineBreakNode","find","undefined","filter","map","roundTrip","output","md","join","toBe","not","toContain"],"sources":["../../../../src/packages/@lexical/markdown/LexicalMarkdownHardLineBreak.spec.ts"],"sourcesContent":["import { createHeadlessEditor } from '@lexical/headless'\nimport { LinkNode } from '@lexical/link'\nimport { ListItemNode, ListNode } from '@lexical/list'\nimport { HeadingNode, QuoteNode } from '@lexical/rich-text'\nimport { $getRoot, $getState, $isElementNode, $isLineBreakNode, $isTextNode } from 'lexical'\nimport { describe, expect, it } from 'vitest'\n\nimport { $convertFromMarkdownString, $convertToMarkdownString } from './index.js'\nimport { hardLineBreakState, normalizeMarkdown } from './MarkdownTransformers.js'\n\nfunction createEditor() {\n  return createHeadlessEditor({\n    nodes: [HeadingNode, QuoteNode, ListNode, ListItemNode, LinkNode],\n  })\n}\n\nfunction importMarkdown(markdown: string): { hasLineBreak: boolean; textContent: string } {\n  const editor = createEditor()\n  editor.update(() => $convertFromMarkdownString(markdown), { discrete: true })\n  let result = { hasLineBreak: false, textContent: '' }\n  editor.getEditorState().read(() => {\n    const firstChild = $getRoot().getFirstChild()\n    if (!$isElementNode(firstChild)) {\n      throw new Error('Expected an element block')\n    }\n    result = {\n      hasLineBreak: firstChild.getChildren().some((child) => $isLineBreakNode(child)),\n      textContent: firstChild.getTextContent(),\n    }\n  })\n  return result\n}\n\n// Returns the hard line break marker stored on the first LineBreakNode of the\n// first block, plus the text content of every text node in that block. Used to\n// assert the marker was moved off the text and onto the line break node, even\n// when the trailing whitespace was split into its own text node by an inline\n// transformer (e.g. after bold or a link).\nfunction getStoredHardLineBreak(markdown: string): {\n  marker: string\n  textNodeTexts: string[]\n} {\n  const editor = createEditor()\n  editor.update(() => $convertFromMarkdownString(markdown), { discrete: true })\n  let result = { marker: '', textNodeTexts: [] as string[] }\n  editor.getEditorState().read(() => {\n    const block = $getRoot().getFirstChild()\n    if (!$isElementNode(block)) {\n      throw new Error('Expected an element block')\n    }\n    const lineBreakNode = block.getChildren().find((child) => $isLineBreakNode(child))\n    if (lineBreakNode === undefined) {\n      throw new Error('Expected a line break node')\n    }\n    result = {\n      marker: $getState(lineBreakNode, hardLineBreakState),\n      textNodeTexts: block\n        .getChildren()\n        .filter($isTextNode)\n        .map((child) => child.getTextContent()),\n    }\n  })\n  return result\n}\n\nfunction roundTrip(markdown: string): string {\n  const editor = createEditor()\n  editor.update(() => $convertFromMarkdownString(markdown), { discrete: true })\n  let output = ''\n  editor.getEditorState().read(() => {\n    output = $convertToMarkdownString()\n  })\n  return output\n}\n\ndescribe('markdown hard line break normalization', () => {\n  it('should preserve trailing-space hard breaks when merging adjacent lines', () => {\n    const md = ['foo  ', 'bar'].join('\\n')\n    expect(normalizeMarkdown(md, true)).toBe(md)\n  })\n\n  it('should preserve the exact number of trailing spaces', () => {\n    const md = ['foo   ', 'bar'].join('\\n')\n    expect(normalizeMarkdown(md, true)).toBe(md)\n  })\n\n  it('should preserve backslash hard breaks when merging adjacent lines', () => {\n    const md = 'foo\\\\\\nbar'\n    expect(normalizeMarkdown(md, true)).toBe(md)\n  })\n\n  it('should still merge a soft break into the previous line', () => {\n    const md = ['foo', 'bar'].join('\\n')\n    expect(normalizeMarkdown(md, true)).toBe('foo bar')\n  })\n\n  it('should merge a soft break before a hard-breaking line', () => {\n    const md = ['foo', 'bar  ', 'baz'].join('\\n')\n    expect(normalizeMarkdown(md, true)).toBe(['foo bar  ', 'baz'].join('\\n'))\n  })\n})\n\ndescribe('markdown hard line break import', () => {\n  it('should import a trailing-space hard break as a line break node with the marker stripped', () => {\n    const { hasLineBreak, textContent } = importMarkdown(['foo  ', 'bar'].join('\\n'))\n\n    expect(hasLineBreak).toBe(true)\n    // The marker is stripped from the text and represented by the line break node.\n    expect(textContent).toBe('foo\\nbar')\n  })\n\n  it('should import a backslash hard break as a line break node with the marker stripped', () => {\n    const { hasLineBreak, textContent } = importMarkdown('foo\\\\\\nbar')\n\n    expect(hasLineBreak).toBe(true)\n    expect(textContent).toBe('foo\\nbar')\n  })\n\n  it('should store the marker on the line break when the hard break follows formatted text', () => {\n    const { marker, textNodeTexts } = getStoredHardLineBreak('**foo**  \\nbar')\n\n    expect(marker).toBe('  ')\n    // The trailing-space marker is split into its own text node by the bold\n    // transformer; it must be moved onto the line break node, not left as text.\n    expect(textNodeTexts).not.toContain('  ')\n  })\n\n  it('should store the exact number of trailing spaces when the hard break follows formatted text', () => {\n    const { marker } = getStoredHardLineBreak('**foo**   \\nbar')\n\n    expect(marker).toBe('   ')\n  })\n\n  it('should store the marker on the line break when the hard break follows a link', () => {\n    const { marker } = getStoredHardLineBreak('[foo](https://payloadcms.com)  \\nbar')\n\n    expect(marker).toBe('  ')\n  })\n})\n\ndescribe('markdown hard line break round trip', () => {\n  it('should round trip a trailing-space hard break', () => {\n    const md = ['foo  ', 'bar'].join('\\n')\n    expect(roundTrip(md)).toBe(md)\n  })\n\n  it('should round trip a backslash hard break', () => {\n    const md = 'foo\\\\\\nbar'\n    expect(roundTrip(md)).toBe(md)\n  })\n\n  it('should not introduce a hard break for a soft wrap', () => {\n    expect(roundTrip(['foo', 'bar'].join('\\n'))).toBe('foo bar')\n  })\n\n  it('should round trip a hard break after formatted text', () => {\n    const md = '**foo**  \\nbar'\n    expect(roundTrip(md)).toBe(md)\n  })\n\n  it('should round trip a hard break after a link', () => {\n    const md = '[foo](https://payloadcms.com)  \\nbar'\n    expect(roundTrip(md)).toBe(md)\n  })\n})\n"],"mappings":"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","ignoreList":[]}

package/dist/packages/@lexical/markdown/MarkdownExport.d.ts

@@ -1,14 +0,0 @@
-/**
- * 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.
- *
- */
-import type { ElementNode } from 'lexical';
-import type { Transformer } from './MarkdownTransformers.js';
-/**
- * Renders string from markdown. The selection is moved to the start after the operation.
- */
-export declare function createMarkdownExport(transformers: Array<Transformer>, shouldPreserveNewLines?: boolean): (node?: ElementNode) => string;
-//# sourceMappingURL=MarkdownExport.d.ts.map

package/dist/packages/@lexical/markdown/MarkdownExport.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"MarkdownExport.d.ts","sourceRoot":"","sources":["../../../../src/packages/@lexical/markdown/MarkdownExport.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAwD,MAAM,SAAS,CAAA;AAWhG,OAAO,KAAK,EAKV,WAAW,EACZ,MAAM,2BAA2B,CAAA;AAKlC;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,YAAY,EAAE,KAAK,CAAC,WAAW,CAAC,EAChC,sBAAsB,GAAE,OAAe,GACtC,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,MAAM,CAkDhC"}

package/dist/packages/@lexical/markdown/MarkdownExport.js

@@ -1,220 +0,0 @@
-/**
- * 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.
- *
- */import { $getRoot, $getState, $isDecoratorNode, $isElementNode, $isLineBreakNode, $isTextNode } from 'lexical';
-import { hardLineBreakState } from './MarkdownTransformers.js';
-import { isEmptyParagraph, transformersByType } from './utils.js';
-/**
- * Renders string from markdown. The selection is moved to the start after the operation.
- */
-export function createMarkdownExport(transformers, shouldPreserveNewLines = false) {
-  const byType = transformersByType(transformers);
-  const elementTransformers = [...byType.multilineElement, ...byType.element];
-  const isNewlineDelimited = !shouldPreserveNewLines;
-  // Export only uses text formats that are responsible for single format
-  // e.g. it will filter out *** (bold, italic) and instead use separate ** and *
-  const textFormatTransformers = byType.textFormat.filter(transformer => transformer.format.length === 1) // Make sure all text transformers that contain 'code' in their format are at the end of the array. Otherwise, formatted code like
-  // <strong><code>code</code></strong> will be exported as `**Bold Code**`, as the code format will be applied first, and the bold format
-  // will be applied second and thus skipped entirely, as the code format will prevent any further formatting.
-  .sort((a, b) => {
-    if (a.format.includes('code') && !b.format.includes('code')) {
-      return 1;
-    } else if (!a.format.includes('code') && b.format.includes('code')) {
-      return -1;
-    } else {
-      return 0;
-    }
-  });
-  return node => {
-    const output = [];
-    const children = (node || $getRoot()).getChildren();
-    children.forEach((child, i) => {
-      const result = exportTopLevelElements(child, elementTransformers, textFormatTransformers, byType.textMatch);
-      if (result != null) {
-        output.push(
-        // separate consecutive group of texts with a line break: eg. ["hello", "world"] -> ["hello", "/nworld"]
-        isNewlineDelimited && i > 0 && !isEmptyParagraph(child) && !isEmptyParagraph(children[i - 1]) ? '\n'.concat(result) : result);
-      }
-    });
-    // Ensure consecutive groups of texts are at least \n\n apart while each empty paragraph render as a newline.
-    // Eg. ["hello", "", "", "hi", "\nworld"] -> "hello\n\n\nhi\n\nworld"
-    return output.join('\n');
-  };
-}
-function exportTopLevelElements(node, elementTransformers, textTransformersIndex, textMatchTransformers) {
-  for (const transformer of elementTransformers) {
-    if (!transformer.export) {
-      continue;
-    }
-    const result = transformer.export(node, _node => exportChildren(_node, textTransformersIndex, textMatchTransformers));
-    if (result != null) {
-      return result;
-    }
-  }
-  if ($isElementNode(node)) {
-    return exportChildren(node, textTransformersIndex, textMatchTransformers);
-  } else if ($isDecoratorNode(node)) {
-    return node.getTextContent();
-  } else {
-    return null;
-  }
-}
-function exportChildren(node, textTransformersIndex, textMatchTransformers, unclosedTags, unclosableTags) {
-  const output = [];
-  const children = node.getChildren();
-  // keep track of unclosed tags from the very beginning
-  if (!unclosedTags) {
-    unclosedTags = [];
-  }
-  if (!unclosableTags) {
-    unclosableTags = [];
-  }
-  mainLoop: for (const child of children) {
-    for (const transformer of textMatchTransformers) {
-      if (!transformer.export) {
-        continue;
-      }
-      const result = transformer.export(child, parentNode => exportChildren(parentNode, textTransformersIndex, textMatchTransformers, unclosedTags,
-      // Add current unclosed tags to the list of unclosable tags - we don't want nested tags from
-      // textmatch transformers to close the outer ones, as that may result in invalid markdown.
-      // E.g. **text [text**](https://lexical.io)
-      // is invalid markdown, as the closing ** is inside the link.
-      //
-      [...unclosableTags, ...unclosedTags]), (textNode, textContent) => exportTextFormat(textNode, textContent, textTransformersIndex, unclosedTags, unclosableTags));
-      if (result != null) {
-        output.push(result);
-        continue mainLoop;
-      }
-    }
-    if ($isLineBreakNode(child)) {
-      output.push($exportLineBreak(child));
-    } else if ($isTextNode(child)) {
-      output.push(exportTextFormat(child, child.getTextContent(), textTransformersIndex, unclosedTags, unclosableTags));
-    } else if ($isElementNode(child)) {
-      // empty paragraph returns ""
-      output.push(exportChildren(child, textTransformersIndex, textMatchTransformers, unclosedTags, unclosableTags));
-    } else if ($isDecoratorNode(child)) {
-      output.push(child.getTextContent());
-    }
-  }
-  return output.join('');
-}
-// Prefixes the newline with the original CommonMark hard line break marker
-// (`\` or trailing spaces) when one was preserved on import, otherwise exports a
-// plain soft line break.
-function $exportLineBreak(node) {
-  return $getState(node, hardLineBreakState) + '\n';
-}
-function exportTextFormat(node, textContent, textTransformers,
-// unclosed tags include the markdown tags that haven't been closed yet, and their associated formats
-unclosedTags, unclosableTags) {
-  // This function handles the case of a string looking like this: "   foo   "
-  // Where it would be invalid markdown to generate: "**   foo   **"
-  // We instead want to trim the whitespace out, apply formatting, and then
-  // bring the whitespace back. So our returned string looks like this: "   **foo**   "
-  const frozenString = textContent.trim();
-  let output = frozenString;
-  if (!node.hasFormat('code')) {
-    // Escape any markdown characters in the text content
-    output = output.replace(/([*_`~\\])/g, '\\$1');
-  }
-  // the opening tags to be added to the result
-  let openingTags = '';
-  // the closing tags to be added to the result
-  let closingTagsBefore = '';
-  let closingTagsAfter = '';
-  const prevNode = getTextSibling(node, true);
-  const nextNode = getTextSibling(node, false);
-  const applied = new Set();
-  for (const transformer of textTransformers) {
-    const format = transformer.format[0];
-    const tag = transformer.tag;
-    // dedup applied formats
-    if (hasFormat(node, format) && !applied.has(format)) {
-      // Multiple tags might be used for the same format (*, _)
-      applied.add(format);
-      // append the tag to openningTags, if it's not applied to the previous nodes,
-      // or the nodes before that (which would result in an unclosed tag)
-      if (!hasFormat(prevNode, format) || !unclosedTags.find(element => element.tag === tag)) {
-        unclosedTags.push({
-          format,
-          tag
-        });
-        openingTags += tag;
-      }
-    }
-  }
-  // close any tags in the same order they were applied, if necessary
-  for (let i = 0; i < unclosedTags.length; i++) {
-    const unclosedTag = unclosedTags[i];
-    const nodeHasFormat = hasFormat(node, unclosedTag.format);
-    const nextNodeHasFormat = hasFormat(nextNode, unclosedTag.format);
-    // prevent adding closing tag if next sibling will do it
-    if (nodeHasFormat && nextNodeHasFormat) {
-      continue;
-    }
-    const unhandledUnclosedTags = [...unclosedTags] // Shallow copy to avoid modifying the original array
-;
-    while (unhandledUnclosedTags.length > i) {
-      const unclosedTag = unhandledUnclosedTags.pop();
-      // If tag is unclosable, don't close it and leave it in the original array,
-      // So that it can be closed when it's no longer unclosable
-      if (unclosableTags && unclosedTag && unclosableTags.find(element => element.tag === unclosedTag.tag)) {
-        continue;
-      }
-      if (unclosedTag && typeof unclosedTag.tag === 'string') {
-        if (!nodeHasFormat) {
-          // Handles cases where the tag has not been closed before, e.g. if the previous node
-          // was a text match transformer that did not account for closing tags of the next node (e.g. a link)
-          closingTagsBefore += unclosedTag.tag;
-        } else if (!nextNodeHasFormat) {
-          closingTagsAfter += unclosedTag.tag;
-        }
-      }
-      // Mutate the original array to remove the closed tag
-      unclosedTags.pop();
-    }
-    break;
-  }
-  output = openingTags + output + closingTagsAfter;
-  // Replace trimmed version of textContent ensuring surrounding whitespace is not modified
-  return closingTagsBefore + textContent.replace(frozenString, () => output);
-}
-// Get next or previous text sibling a text node, including cases
-// when it's a child of inline element (e.g. link)
-function getTextSibling(node, backward) {
-  let sibling = backward ? node.getPreviousSibling() : node.getNextSibling();
-  if (!sibling) {
-    const parent = node.getParentOrThrow();
-    if (parent.isInline()) {
-      sibling = backward ? parent.getPreviousSibling() : parent.getNextSibling();
-    }
-  }
-  while (sibling) {
-    if ($isElementNode(sibling)) {
-      if (!sibling.isInline()) {
-        break;
-      }
-      const descendant = backward ? sibling.getLastDescendant() : sibling.getFirstDescendant();
-      if ($isTextNode(descendant)) {
-        return descendant;
-      } else {
-        sibling = backward ? sibling.getPreviousSibling() : sibling.getNextSibling();
-      }
-    }
-    if ($isTextNode(sibling)) {
-      return sibling;
-    }
-    if (!$isElementNode(sibling)) {
-      return null;
-    }
-  }
-  return null;
-}
-function hasFormat(node, format) {
-  return $isTextNode(node) && node.hasFormat(format);
-}
-//# sourceMappingURL=MarkdownExport.js.map

package/dist/packages/@lexical/markdown/MarkdownExport.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"MarkdownExport.js","names":["$getRoot","$getState","$isDecoratorNode","$isElementNode","$isLineBreakNode","$isTextNode","hardLineBreakState","isEmptyParagraph","transformersByType","createMarkdownExport","transformers","shouldPreserveNewLines","byType","elementTransformers","multilineElement","element","isNewlineDelimited","textFormatTransformers","textFormat","filter","transformer","format","length","sort","a","b","includes","node","output","children","getChildren","forEach","child","i","result","exportTopLevelElements","textMatch","push","concat","join","textTransformersIndex","textMatchTransformers","export","_node","exportChildren","getTextContent","unclosedTags","unclosableTags","mainLoop","parentNode","textNode","textContent","exportTextFormat","$exportLineBreak","textTransformers","frozenString","trim","hasFormat","replace","openingTags","closingTagsBefore","closingTagsAfter","prevNode","getTextSibling","nextNode","applied","Set","tag","has","add","find","unclosedTag","nodeHasFormat","nextNodeHasFormat","unhandledUnclosedTags","pop","backward","sibling","getPreviousSibling","getNextSibling","parent","getParentOrThrow","isInline","descendant","getLastDescendant","getFirstDescendant"],"sources":["../../../../src/packages/@lexical/markdown/MarkdownExport.ts"],"sourcesContent":["/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nimport type { ElementNode, LexicalNode, LineBreakNode, TextFormatType, TextNode } from 'lexical'\n\nimport {\n  $getRoot,\n  $getState,\n  $isDecoratorNode,\n  $isElementNode,\n  $isLineBreakNode,\n  $isTextNode,\n} from 'lexical'\n\nimport type {\n  ElementTransformer,\n  MultilineElementTransformer,\n  TextFormatTransformer,\n  TextMatchTransformer,\n  Transformer,\n} from './MarkdownTransformers.js'\n\nimport { hardLineBreakState } from './MarkdownTransformers.js'\nimport { isEmptyParagraph, transformersByType } from './utils.js'\n\n/**\n * Renders string from markdown. The selection is moved to the start after the operation.\n */\nexport function createMarkdownExport(\n  transformers: Array<Transformer>,\n  shouldPreserveNewLines: boolean = false,\n): (node?: ElementNode) => string {\n  const byType = transformersByType(transformers)\n  const elementTransformers = [...byType.multilineElement, ...byType.element]\n  const isNewlineDelimited = !shouldPreserveNewLines\n\n  // Export only uses text formats that are responsible for single format\n  // e.g. it will filter out *** (bold, italic) and instead use separate ** and *\n  const textFormatTransformers = byType.textFormat\n    .filter((transformer) => transformer.format.length === 1)\n    // Make sure all text transformers that contain 'code' in their format are at the end of the array. Otherwise, formatted code like\n    // <strong><code>code</code></strong> will be exported as `**Bold Code**`, as the code format will be applied first, and the bold format\n    // will be applied second and thus skipped entirely, as the code format will prevent any further formatting.\n    .sort((a, b) => {\n      if (a.format.includes('code') && !b.format.includes('code')) {\n        return 1\n      } else if (!a.format.includes('code') && b.format.includes('code')) {\n        return -1\n      } else {\n        return 0\n      }\n    })\n\n  return (node) => {\n    const output: string[] = []\n    const children = (node || $getRoot()).getChildren()\n\n    children.forEach((child, i) => {\n      const result = exportTopLevelElements(\n        child,\n        elementTransformers,\n        textFormatTransformers,\n        byType.textMatch,\n      )\n\n      if (result != null) {\n        output.push(\n          // separate consecutive group of texts with a line break: eg. [\"hello\", \"world\"] -> [\"hello\", \"/nworld\"]\n          isNewlineDelimited &&\n            i > 0 &&\n            !isEmptyParagraph(child) &&\n            !isEmptyParagraph(children[i - 1]!)\n            ? '\\n'.concat(result)\n            : result,\n        )\n      }\n    })\n    // Ensure consecutive groups of texts are at least \\n\\n apart while each empty paragraph render as a newline.\n    // Eg. [\"hello\", \"\", \"\", \"hi\", \"\\nworld\"] -> \"hello\\n\\n\\nhi\\n\\nworld\"\n    return output.join('\\n')\n  }\n}\n\nfunction exportTopLevelElements(\n  node: LexicalNode,\n  elementTransformers: Array<ElementTransformer | MultilineElementTransformer>,\n  textTransformersIndex: Array<TextFormatTransformer>,\n  textMatchTransformers: Array<TextMatchTransformer>,\n): null | string {\n  for (const transformer of elementTransformers) {\n    if (!transformer.export) {\n      continue\n    }\n    const result = transformer.export(node, (_node) =>\n      exportChildren(_node, textTransformersIndex, textMatchTransformers),\n    )\n\n    if (result != null) {\n      return result\n    }\n  }\n\n  if ($isElementNode(node)) {\n    return exportChildren(node, textTransformersIndex, textMatchTransformers)\n  } else if ($isDecoratorNode(node)) {\n    return node.getTextContent()\n  } else {\n    return null\n  }\n}\n\nfunction exportChildren(\n  node: ElementNode,\n  textTransformersIndex: Array<TextFormatTransformer>,\n  textMatchTransformers: Array<TextMatchTransformer>,\n  unclosedTags?: Array<{ format: TextFormatType; tag: string }>,\n  unclosableTags?: Array<{ format: TextFormatType; tag: string }>,\n): string {\n  const output = []\n  const children = node.getChildren()\n  // keep track of unclosed tags from the very beginning\n  if (!unclosedTags) {\n    unclosedTags = []\n  }\n  if (!unclosableTags) {\n    unclosableTags = []\n  }\n\n  mainLoop: for (const child of children) {\n    for (const transformer of textMatchTransformers) {\n      if (!transformer.export) {\n        continue\n      }\n\n      const result = transformer.export(\n        child,\n        (parentNode) =>\n          exportChildren(\n            parentNode,\n            textTransformersIndex,\n            textMatchTransformers,\n            unclosedTags,\n            // Add current unclosed tags to the list of unclosable tags - we don't want nested tags from\n            // textmatch transformers to close the outer ones, as that may result in invalid markdown.\n            // E.g. **text [text**](https://lexical.io)\n            // is invalid markdown, as the closing ** is inside the link.\n            //\n            [...unclosableTags, ...unclosedTags],\n          ),\n        (textNode, textContent) =>\n          exportTextFormat(\n            textNode,\n            textContent,\n            textTransformersIndex,\n            unclosedTags,\n            unclosableTags,\n          ),\n      )\n\n      if (result != null) {\n        output.push(result)\n        continue mainLoop\n      }\n    }\n\n    if ($isLineBreakNode(child)) {\n      output.push($exportLineBreak(child))\n    } else if ($isTextNode(child)) {\n      output.push(\n        exportTextFormat(\n          child,\n          child.getTextContent(),\n          textTransformersIndex,\n          unclosedTags,\n          unclosableTags,\n        ),\n      )\n    } else if ($isElementNode(child)) {\n      // empty paragraph returns \"\"\n      output.push(\n        exportChildren(\n          child,\n          textTransformersIndex,\n          textMatchTransformers,\n          unclosedTags,\n          unclosableTags,\n        ),\n      )\n    } else if ($isDecoratorNode(child)) {\n      output.push(child.getTextContent())\n    }\n  }\n\n  return output.join('')\n}\n\n// Prefixes the newline with the original CommonMark hard line break marker\n// (`\\` or trailing spaces) when one was preserved on import, otherwise exports a\n// plain soft line break.\nfunction $exportLineBreak(node: LineBreakNode): string {\n  return $getState(node, hardLineBreakState) + '\\n'\n}\n\nfunction exportTextFormat(\n  node: TextNode,\n  textContent: string,\n  textTransformers: Array<TextFormatTransformer>,\n  // unclosed tags include the markdown tags that haven't been closed yet, and their associated formats\n  unclosedTags: Array<{ format: TextFormatType; tag: string }>,\n  unclosableTags?: Array<{ format: TextFormatType; tag: string }>,\n): string {\n  // This function handles the case of a string looking like this: \"   foo   \"\n  // Where it would be invalid markdown to generate: \"**   foo   **\"\n  // We instead want to trim the whitespace out, apply formatting, and then\n  // bring the whitespace back. So our returned string looks like this: \"   **foo**   \"\n  const frozenString = textContent.trim()\n  let output = frozenString\n\n  if (!node.hasFormat('code')) {\n    // Escape any markdown characters in the text content\n    output = output.replace(/([*_`~\\\\])/g, '\\\\$1')\n  }\n\n  // the opening tags to be added to the result\n  let openingTags = ''\n  // the closing tags to be added to the result\n  let closingTagsBefore = ''\n  let closingTagsAfter = ''\n\n  const prevNode = getTextSibling(node, true)\n  const nextNode = getTextSibling(node, false)\n\n  const applied = new Set()\n\n  for (const transformer of textTransformers) {\n    const format = transformer.format[0]!\n    const tag = transformer.tag\n\n    // dedup applied formats\n    if (hasFormat(node, format) && !applied.has(format)) {\n      // Multiple tags might be used for the same format (*, _)\n      applied.add(format)\n\n      // append the tag to openningTags, if it's not applied to the previous nodes,\n      // or the nodes before that (which would result in an unclosed tag)\n      if (!hasFormat(prevNode, format) || !unclosedTags.find((element) => element.tag === tag)) {\n        unclosedTags.push({ format, tag })\n        openingTags += tag\n      }\n    }\n  }\n\n  // close any tags in the same order they were applied, if necessary\n  for (let i = 0; i < unclosedTags.length; i++) {\n    const unclosedTag = unclosedTags[i]!\n    const nodeHasFormat = hasFormat(node, unclosedTag.format)\n    const nextNodeHasFormat = hasFormat(nextNode, unclosedTag.format)\n\n    // prevent adding closing tag if next sibling will do it\n    if (nodeHasFormat && nextNodeHasFormat) {\n      continue\n    }\n\n    const unhandledUnclosedTags = [...unclosedTags] // Shallow copy to avoid modifying the original array\n\n    while (unhandledUnclosedTags.length > i) {\n      const unclosedTag = unhandledUnclosedTags.pop()\n\n      // If tag is unclosable, don't close it and leave it in the original array,\n      // So that it can be closed when it's no longer unclosable\n      if (\n        unclosableTags &&\n        unclosedTag &&\n        unclosableTags.find((element) => element.tag === unclosedTag.tag)\n      ) {\n        continue\n      }\n\n      if (unclosedTag && typeof unclosedTag.tag === 'string') {\n        if (!nodeHasFormat) {\n          // Handles cases where the tag has not been closed before, e.g. if the previous node\n          // was a text match transformer that did not account for closing tags of the next node (e.g. a link)\n          closingTagsBefore += unclosedTag.tag\n        } else if (!nextNodeHasFormat) {\n          closingTagsAfter += unclosedTag.tag\n        }\n      }\n      // Mutate the original array to remove the closed tag\n      unclosedTags.pop()\n    }\n    break\n  }\n\n  output = openingTags + output + closingTagsAfter\n  // Replace trimmed version of textContent ensuring surrounding whitespace is not modified\n  return closingTagsBefore + textContent.replace(frozenString, () => output)\n}\n\n// Get next or previous text sibling a text node, including cases\n// when it's a child of inline element (e.g. link)\nfunction getTextSibling(node: TextNode, backward: boolean): null | TextNode {\n  let sibling = backward ? node.getPreviousSibling() : node.getNextSibling()\n\n  if (!sibling) {\n    const parent = node.getParentOrThrow()\n\n    if (parent.isInline()) {\n      sibling = backward ? parent.getPreviousSibling() : parent.getNextSibling()\n    }\n  }\n\n  while (sibling) {\n    if ($isElementNode(sibling)) {\n      if (!sibling.isInline()) {\n        break\n      }\n\n      const descendant = backward ? sibling.getLastDescendant() : sibling.getFirstDescendant()\n\n      if ($isTextNode(descendant)) {\n        return descendant\n      } else {\n        sibling = backward ? sibling.getPreviousSibling() : sibling.getNextSibling()\n      }\n    }\n\n    if ($isTextNode(sibling)) {\n      return sibling\n    }\n\n    if (!$isElementNode(sibling)) {\n      return null\n    }\n  }\n\n  return null\n}\n\nfunction hasFormat(node: LexicalNode | null | undefined, format: TextFormatType): boolean {\n  return $isTextNode(node) && node.hasFormat(format)\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/packages/@lexical/markdown/MarkdownImport.d.ts

@@ -1,19 +0,0 @@
-/**
- * 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.
- *
- */
-import type { ElementNode } from 'lexical';
-import type { TextFormatTransformer, Transformer } from './MarkdownTransformers.js';
-export type TextFormatTransformersIndex = Readonly<{
-    fullMatchRegExpByTag: Readonly<Record<string, RegExp>>;
-    openTagsRegExp: RegExp;
-    transformersByTag: Readonly<Record<string, TextFormatTransformer>>;
-}>;
-/**
- * Renders markdown from a string. The selection is moved to the start after the operation.
- */
-export declare function createMarkdownImport(transformers: Array<Transformer>, shouldPreserveNewLines?: boolean): (markdownString: string, node?: ElementNode) => void;
-//# sourceMappingURL=MarkdownImport.d.ts.map

package/dist/packages/@lexical/markdown/MarkdownImport.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"MarkdownImport.d.ts","sourceRoot":"","sources":["../../../../src/packages/@lexical/markdown/MarkdownImport.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAa1C,OAAO,KAAK,EAGV,qBAAqB,EAErB,WAAW,EACZ,MAAM,2BAA2B,CAAA;AAMlC,MAAM,MAAM,2BAA2B,GAAG,QAAQ,CAAC;IACjD,oBAAoB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IACtD,cAAc,EAAE,MAAM,CAAA;IACtB,iBAAiB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAAC,CAAA;CACnE,CAAC,CAAA;AAEF;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,YAAY,EAAE,KAAK,CAAC,WAAW,CAAC,EAChC,sBAAsB,UAAQ,GAC7B,CAAC,cAAc,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,IAAI,CAyCtD"}