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

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

@@ -1,267 +0,0 @@
-/* eslint-disable regexp/no-obscure-range */ /* eslint-disable regexp/no-empty-group */ /* eslint-disable regexp/no-empty-capturing-group */ /* eslint-disable regexp/optimal-quantifier-concatenation */ /* eslint-disable regexp/no-misleading-capturing-group */ /* eslint-disable regexp/no-contradiction-with-assertion */ /* eslint-disable regexp/no-super-linear-backtracking */ /**
-                                                                                                                                                                                                                                                                                                                                                                                         * 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 { $isListItemNode, $isListNode } from '@lexical/list';
-import { $isHeadingNode, $isQuoteNode } from '@lexical/rich-text';
-import { $isParagraphNode, $isTextNode } from 'lexical';
-const autoFormatBase = {
-  markdownFormatKind: null,
-  regEx: /(?:)/,
-  regExForAutoFormatting: /(?:)/,
-  requiresParagraphStart: false
-};
-const paragraphStartBase = {
-  ...autoFormatBase,
-  requiresParagraphStart: true
-};
-const markdownHeader1 = {
-  ...paragraphStartBase,
-  export: createHeadingExport(1),
-  markdownFormatKind: 'paragraphH1',
-  regEx: /^# /,
-  regExForAutoFormatting: /^# /
-};
-const markdownHeader2 = {
-  ...paragraphStartBase,
-  export: createHeadingExport(2),
-  markdownFormatKind: 'paragraphH2',
-  regEx: /^## /,
-  regExForAutoFormatting: /^## /
-};
-const markdownHeader3 = {
-  ...paragraphStartBase,
-  export: createHeadingExport(3),
-  markdownFormatKind: 'paragraphH3',
-  regEx: /^### /,
-  regExForAutoFormatting: /^### /
-};
-const markdownHeader4 = {
-  ...paragraphStartBase,
-  export: createHeadingExport(4),
-  markdownFormatKind: 'paragraphH4',
-  regEx: /^#### /,
-  regExForAutoFormatting: /^#### /
-};
-const markdownHeader5 = {
-  ...paragraphStartBase,
-  export: createHeadingExport(5),
-  markdownFormatKind: 'paragraphH5',
-  regEx: /^##### /,
-  regExForAutoFormatting: /^##### /
-};
-const markdownHeader6 = {
-  ...paragraphStartBase,
-  export: createHeadingExport(6),
-  markdownFormatKind: 'paragraphH6',
-  regEx: /^###### /,
-  regExForAutoFormatting: /^###### /
-};
-const markdownBlockQuote = {
-  ...paragraphStartBase,
-  export: blockQuoteExport,
-  markdownFormatKind: 'paragraphBlockQuote',
-  regEx: /^> /,
-  regExForAutoFormatting: /^> /
-};
-const markdownUnorderedListDash = {
-  ...paragraphStartBase,
-  export: listExport,
-  markdownFormatKind: 'paragraphUnorderedList',
-  regEx: /^(\s{0,10})- /,
-  regExForAutoFormatting: /^(\s{0,10})- /
-};
-const markdownUnorderedListAsterisk = {
-  ...paragraphStartBase,
-  export: listExport,
-  markdownFormatKind: 'paragraphUnorderedList',
-  regEx: /^(\s{0,10})\* /,
-  regExForAutoFormatting: /^(\s{0,10})\* /
-};
-const markdownOrderedList = {
-  ...paragraphStartBase,
-  export: listExport,
-  markdownFormatKind: 'paragraphOrderedList',
-  regEx: /^(\s{0,10})(\d+)\.\s/,
-  regExForAutoFormatting: /^(\s{0,10})(\d+)\.\s/
-};
-const markdownHorizontalRule = {
-  ...paragraphStartBase,
-  markdownFormatKind: 'horizontalRule',
-  regEx: /^\*\*\*$/,
-  regExForAutoFormatting: /^\*\*\* /
-};
-const markdownHorizontalRuleUsingDashes = {
-  ...paragraphStartBase,
-  markdownFormatKind: 'horizontalRule',
-  regEx: /^---$/,
-  regExForAutoFormatting: /^--- /
-};
-const markdownInlineCode = {
-  ...autoFormatBase,
-  exportFormat: 'code',
-  exportTag: '`',
-  markdownFormatKind: 'code',
-  regEx: /(`)(\s*)([^`]*)(\s*)(`)()/,
-  regExForAutoFormatting: /(`)(\s*\b)([^`]*)(\b\s*)(`)(\s)$/
-};
-const markdownBold = {
-  ...autoFormatBase,
-  exportFormat: 'bold',
-  exportTag: '**',
-  markdownFormatKind: 'bold',
-  regEx: /(\*\*)(\s*)([^*]*)(\s*)(\*\*)()/,
-  regExForAutoFormatting: /(\*\*)(\s*\b)([^*]*)(\b\s*)(\*\*)(\s)$/
-};
-const markdownItalic = {
-  ...autoFormatBase,
-  exportFormat: 'italic',
-  exportTag: '*',
-  markdownFormatKind: 'italic',
-  regEx: /(\*)(\s*)([^*]*)(\s*)(\*)()/,
-  regExForAutoFormatting: /(\*)(\s*\b)([^*]*)(\b\s*)(\*)(\s)$/
-};
-const markdownBold2 = {
-  ...autoFormatBase,
-  exportFormat: 'bold',
-  exportTag: '_',
-  markdownFormatKind: 'bold',
-  regEx: /(__)(\s*)([^_]*)(\s*)(__)()/,
-  regExForAutoFormatting: /(__)(\s*)([^_]*)(\s*)(__)(\s)$/
-};
-const markdownItalic2 = {
-  ...autoFormatBase,
-  exportFormat: 'italic',
-  exportTag: '_',
-  markdownFormatKind: 'italic',
-  regEx: /(_)()([^_]*)()(_)()/,
-  regExForAutoFormatting: /(_)()([^_]*)()(_)(\s)$/
-};
-const fakeMarkdownUnderline = {
-  ...autoFormatBase,
-  exportFormat: 'underline',
-  exportTag: '<u>',
-  exportTagClose: '</u>',
-  markdownFormatKind: 'underline',
-  regEx: /(<u>)(\s*)([^<]*)(\s*)(<\/u>)()/,
-  regExForAutoFormatting: /(<u>)(\s*\b)([^<]*)(\b\s*)(<\/u>)(\s)$/
-};
-const markdownStrikethrough = {
-  ...autoFormatBase,
-  exportFormat: 'strikethrough',
-  exportTag: '~~',
-  markdownFormatKind: 'strikethrough',
-  regEx: /(~~)(\s*)([^~]*)(\s*)(~~)()/,
-  regExForAutoFormatting: /(~~)(\s*\b)([^~]*)(\b\s*)(~~)(\s)$/
-};
-const markdownStrikethroughItalicBold = {
-  ...autoFormatBase,
-  markdownFormatKind: 'strikethrough_italic_bold',
-  regEx: /(~~_\*\*)(\s*\b)([^*_~]+)(\b\s*)(\*\*_~~)()/,
-  regExForAutoFormatting: /(~~_\*\*)(\s*\b)([^*_~]+)(\b\s*)(\*\*_~~)(\s)$/
-};
-const markdownItalicbold = {
-  ...autoFormatBase,
-  markdownFormatKind: 'italic_bold',
-  regEx: /(_\*\*)(\s*\b)([^*_]+)(\b\s*)(\*\*_)/,
-  regExForAutoFormatting: /(_\*\*)(\s*\b)([^*_]+)(\b\s*)(\*\*_)(\s)$/
-};
-const markdownStrikethroughItalic = {
-  ...autoFormatBase,
-  markdownFormatKind: 'strikethrough_italic',
-  regEx: /(~~_)(\s*)([^_~]+)(\s*)(_~~)/,
-  regExForAutoFormatting: /(~~_)(\s*)([^_~]+)(\s*)(_~~)(\s)$/
-};
-const markdownStrikethroughBold = {
-  ...autoFormatBase,
-  markdownFormatKind: 'strikethrough_bold',
-  regEx: /(~~\*\*)(\s*\b)([^*~]+)(\b\s*)(\*\*~~)/,
-  regExForAutoFormatting: /(~~\*\*)(\s*\b)([^*~]+)(\b\s*)(\*\*~~)(\s)$/
-};
-const markdownLink = {
-  ...autoFormatBase,
-  markdownFormatKind: 'link',
-  regEx: /(\[)([^\]]*)(\]\()([^)]*)(\)*)()/,
-  regExForAutoFormatting: /(\[)([^\]]*)(\]\()([^)]*)(\)*)(\s)$/
-};
-const allMarkdownCriteriaForTextNodes = [
-// Place the combination formats ahead of the individual formats.
-// Combos
-markdownStrikethroughItalicBold, markdownItalicbold, markdownStrikethroughItalic, markdownStrikethroughBold, markdownInlineCode, markdownBold, markdownItalic, markdownBold2, markdownItalic2, fakeMarkdownUnderline, markdownStrikethrough, markdownLink];
-const allMarkdownCriteriaForParagraphs = [markdownHeader1, markdownHeader2, markdownHeader3, markdownHeader4, markdownHeader5, markdownHeader6, markdownBlockQuote, markdownUnorderedListDash, markdownUnorderedListAsterisk, markdownOrderedList, markdownHorizontalRule, markdownHorizontalRuleUsingDashes];
-export function getAllMarkdownCriteriaForParagraphs() {
-  return allMarkdownCriteriaForParagraphs;
-}
-export function getAllMarkdownCriteriaForTextNodes() {
-  return allMarkdownCriteriaForTextNodes;
-}
-function createHeadingExport(level) {
-  return (node, exportChildren) => {
-    return $isHeadingNode(node) && node.getTag() === 'h' + level ? '#'.repeat(level) + ' ' + exportChildren(node) : null;
-  };
-}
-function listExport(node, exportChildren) {
-  return $isListNode(node) ? processNestedLists(node, exportChildren, 0) : null;
-}
-// TODO: should be param
-const LIST_INDENT_SIZE = 4;
-function processNestedLists(listNode, exportChildren, depth) {
-  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, exportChildren) {
-  return $isQuoteNode(node) ? '> ' + exportChildren(node) : null;
-}
-export function indexBy(list, callback) {
-  const index = {};
-  for (const item of list) {
-    const key = callback(item);
-    if (!key) {
-      continue;
-    }
-    if (index[key]) {
-      index[key].push(item);
-    } else {
-      index[key] = [item];
-    }
-  }
-  return index;
-}
-export function transformersByType(transformers) {
-  const byType = indexBy(transformers, t => t.type);
-  return {
-    element: byType.element || [],
-    multilineElement: byType['multiline-element'] || [],
-    textFormat: byType['text-format'] || [],
-    textMatch: byType['text-match'] || []
-  };
-}
-export const PUNCTUATION_OR_SPACE = /[!-/:-@[-`{-~\s]/;
-const MARKDOWN_EMPTY_LINE_REG_EXP = /^\s{0,3}$/;
-export function isEmptyParagraph(node) {
-  if (!$isParagraphNode(node)) {
-    return false;
-  }
-  const firstChild = node.getFirstChild();
-  return firstChild == null || node.getChildrenSize() === 1 && $isTextNode(firstChild) && MARKDOWN_EMPTY_LINE_REG_EXP.test(firstChild.getTextContent());
-}
-//# sourceMappingURL=utils.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"utils.js","names":["$isListItemNode","$isListNode","$isHeadingNode","$isQuoteNode","$isParagraphNode","$isTextNode","autoFormatBase","markdownFormatKind","regEx","regExForAutoFormatting","requiresParagraphStart","paragraphStartBase","markdownHeader1","export","createHeadingExport","markdownHeader2","markdownHeader3","markdownHeader4","markdownHeader5","markdownHeader6","markdownBlockQuote","blockQuoteExport","markdownUnorderedListDash","listExport","markdownUnorderedListAsterisk","markdownOrderedList","markdownHorizontalRule","markdownHorizontalRuleUsingDashes","markdownInlineCode","exportFormat","exportTag","markdownBold","markdownItalic","markdownBold2","markdownItalic2","fakeMarkdownUnderline","exportTagClose","markdownStrikethrough","markdownStrikethroughItalicBold","markdownItalicbold","markdownStrikethroughItalic","markdownStrikethroughBold","markdownLink","allMarkdownCriteriaForTextNodes","allMarkdownCriteriaForParagraphs","getAllMarkdownCriteriaForParagraphs","getAllMarkdownCriteriaForTextNodes","level","node","exportChildren","getTag","repeat","processNestedLists","LIST_INDENT_SIZE","listNode","depth","output","children","getChildren","index","listItemNode","getChildrenSize","firstChild","getFirstChild","push","indent","prefix","getListType","getStart","join","indexBy","list","callback","item","key","transformersByType","transformers","byType","t","type","element","multilineElement","textFormat","textMatch","PUNCTUATION_OR_SPACE","MARKDOWN_EMPTY_LINE_REG_EXP","isEmptyParagraph","test","getTextContent"],"sources":["../../../../src/packages/@lexical/markdown/utils.ts"],"sourcesContent":["/* eslint-disable regexp/no-obscure-range */\n/* eslint-disable regexp/no-empty-group */\n/* eslint-disable regexp/no-empty-capturing-group */\n/* eslint-disable regexp/optimal-quantifier-concatenation */\n/* eslint-disable regexp/no-misleading-capturing-group */\n/* eslint-disable regexp/no-contradiction-with-assertion */\n/* eslint-disable regexp/no-super-linear-backtracking */\n/**\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 { ListNode } from '@lexical/list'\n\nimport { $isListItemNode, $isListNode } from '@lexical/list'\nimport { $isHeadingNode, $isQuoteNode } from '@lexical/rich-text'\nimport {\n  $isParagraphNode,\n  $isTextNode,\n  type ElementNode,\n  type LexicalNode,\n  type TextFormatType,\n} from 'lexical'\n\nimport type {\n  ElementTransformer,\n  MultilineElementTransformer,\n  TextFormatTransformer,\n  TextMatchTransformer,\n  Transformer,\n} from './MarkdownTransformers.js'\n\ntype MarkdownFormatKind =\n  | 'bold'\n  | 'code'\n  | 'horizontalRule'\n  | 'italic'\n  | 'italic_bold'\n  | 'link'\n  | 'noTransformation'\n  | 'paragraphBlockQuote'\n  | 'paragraphCodeBlock'\n  | 'paragraphH1'\n  | 'paragraphH2'\n  | 'paragraphH3'\n  | 'paragraphH4'\n  | 'paragraphH5'\n  | 'paragraphH6'\n  | 'paragraphOrderedList'\n  | 'paragraphUnorderedList'\n  | 'strikethrough'\n  | 'strikethrough_bold'\n  | 'strikethrough_italic'\n  | 'strikethrough_italic_bold'\n  | 'underline'\n\ntype MarkdownCriteria = Readonly<{\n  export?: (\n    node: LexicalNode,\n    traverseChildren: (elementNode: ElementNode) => string,\n  ) => null | string\n  exportFormat?: TextFormatType\n  exportTag?: string\n  exportTagClose?: string\n  markdownFormatKind: MarkdownFormatKind | null | undefined\n  regEx: RegExp\n  regExForAutoFormatting: RegExp\n  requiresParagraphStart: boolean | null | undefined\n}>\n\ntype MarkdownCriteriaArray = Array<MarkdownCriteria>\n\nconst autoFormatBase: MarkdownCriteria = {\n  markdownFormatKind: null,\n  regEx: /(?:)/,\n  regExForAutoFormatting: /(?:)/,\n  requiresParagraphStart: false,\n}\n\nconst paragraphStartBase: MarkdownCriteria = {\n  ...autoFormatBase,\n  requiresParagraphStart: true,\n}\n\nconst markdownHeader1: MarkdownCriteria = {\n  ...paragraphStartBase,\n  export: createHeadingExport(1),\n  markdownFormatKind: 'paragraphH1',\n  regEx: /^# /,\n  regExForAutoFormatting: /^# /,\n}\n\nconst markdownHeader2: MarkdownCriteria = {\n  ...paragraphStartBase,\n  export: createHeadingExport(2),\n  markdownFormatKind: 'paragraphH2',\n  regEx: /^## /,\n  regExForAutoFormatting: /^## /,\n}\n\nconst markdownHeader3: MarkdownCriteria = {\n  ...paragraphStartBase,\n  export: createHeadingExport(3),\n  markdownFormatKind: 'paragraphH3',\n  regEx: /^### /,\n  regExForAutoFormatting: /^### /,\n}\n\nconst markdownHeader4: MarkdownCriteria = {\n  ...paragraphStartBase,\n  export: createHeadingExport(4),\n  markdownFormatKind: 'paragraphH4',\n  regEx: /^#### /,\n  regExForAutoFormatting: /^#### /,\n}\n\nconst markdownHeader5: MarkdownCriteria = {\n  ...paragraphStartBase,\n  export: createHeadingExport(5),\n  markdownFormatKind: 'paragraphH5',\n  regEx: /^##### /,\n  regExForAutoFormatting: /^##### /,\n}\n\nconst markdownHeader6: MarkdownCriteria = {\n  ...paragraphStartBase,\n  export: createHeadingExport(6),\n  markdownFormatKind: 'paragraphH6',\n  regEx: /^###### /,\n  regExForAutoFormatting: /^###### /,\n}\n\nconst markdownBlockQuote: MarkdownCriteria = {\n  ...paragraphStartBase,\n  export: blockQuoteExport,\n  markdownFormatKind: 'paragraphBlockQuote',\n  regEx: /^> /,\n  regExForAutoFormatting: /^> /,\n}\n\nconst markdownUnorderedListDash: MarkdownCriteria = {\n  ...paragraphStartBase,\n  export: listExport,\n  markdownFormatKind: 'paragraphUnorderedList',\n  regEx: /^(\\s{0,10})- /,\n  regExForAutoFormatting: /^(\\s{0,10})- /,\n}\n\nconst markdownUnorderedListAsterisk: MarkdownCriteria = {\n  ...paragraphStartBase,\n  export: listExport,\n  markdownFormatKind: 'paragraphUnorderedList',\n  regEx: /^(\\s{0,10})\\* /,\n  regExForAutoFormatting: /^(\\s{0,10})\\* /,\n}\n\nconst markdownOrderedList: MarkdownCriteria = {\n  ...paragraphStartBase,\n  export: listExport,\n  markdownFormatKind: 'paragraphOrderedList',\n  regEx: /^(\\s{0,10})(\\d+)\\.\\s/,\n  regExForAutoFormatting: /^(\\s{0,10})(\\d+)\\.\\s/,\n}\n\nconst markdownHorizontalRule: MarkdownCriteria = {\n  ...paragraphStartBase,\n  markdownFormatKind: 'horizontalRule',\n  regEx: /^\\*\\*\\*$/,\n  regExForAutoFormatting: /^\\*\\*\\* /,\n}\n\nconst markdownHorizontalRuleUsingDashes: MarkdownCriteria = {\n  ...paragraphStartBase,\n  markdownFormatKind: 'horizontalRule',\n  regEx: /^---$/,\n  regExForAutoFormatting: /^--- /,\n}\n\nconst markdownInlineCode: MarkdownCriteria = {\n  ...autoFormatBase,\n  exportFormat: 'code',\n  exportTag: '`',\n  markdownFormatKind: 'code',\n  regEx: /(`)(\\s*)([^`]*)(\\s*)(`)()/,\n  regExForAutoFormatting: /(`)(\\s*\\b)([^`]*)(\\b\\s*)(`)(\\s)$/,\n}\n\nconst markdownBold: MarkdownCriteria = {\n  ...autoFormatBase,\n  exportFormat: 'bold',\n  exportTag: '**',\n  markdownFormatKind: 'bold',\n  regEx: /(\\*\\*)(\\s*)([^*]*)(\\s*)(\\*\\*)()/,\n  regExForAutoFormatting: /(\\*\\*)(\\s*\\b)([^*]*)(\\b\\s*)(\\*\\*)(\\s)$/,\n}\n\nconst markdownItalic: MarkdownCriteria = {\n  ...autoFormatBase,\n  exportFormat: 'italic',\n  exportTag: '*',\n  markdownFormatKind: 'italic',\n  regEx: /(\\*)(\\s*)([^*]*)(\\s*)(\\*)()/,\n  regExForAutoFormatting: /(\\*)(\\s*\\b)([^*]*)(\\b\\s*)(\\*)(\\s)$/,\n}\n\nconst markdownBold2: MarkdownCriteria = {\n  ...autoFormatBase,\n  exportFormat: 'bold',\n  exportTag: '_',\n  markdownFormatKind: 'bold',\n  regEx: /(__)(\\s*)([^_]*)(\\s*)(__)()/,\n  regExForAutoFormatting: /(__)(\\s*)([^_]*)(\\s*)(__)(\\s)$/,\n}\n\nconst markdownItalic2: MarkdownCriteria = {\n  ...autoFormatBase,\n  exportFormat: 'italic',\n  exportTag: '_',\n  markdownFormatKind: 'italic',\n  regEx: /(_)()([^_]*)()(_)()/,\n  regExForAutoFormatting: /(_)()([^_]*)()(_)(\\s)$/, // Maintain 7 groups.\n}\n\nconst fakeMarkdownUnderline: MarkdownCriteria = {\n  ...autoFormatBase,\n  exportFormat: 'underline',\n  exportTag: '<u>',\n  exportTagClose: '</u>',\n  markdownFormatKind: 'underline',\n  regEx: /(<u>)(\\s*)([^<]*)(\\s*)(<\\/u>)()/,\n  regExForAutoFormatting: /(<u>)(\\s*\\b)([^<]*)(\\b\\s*)(<\\/u>)(\\s)$/,\n}\n\nconst markdownStrikethrough: MarkdownCriteria = {\n  ...autoFormatBase,\n  exportFormat: 'strikethrough',\n  exportTag: '~~',\n  markdownFormatKind: 'strikethrough',\n  regEx: /(~~)(\\s*)([^~]*)(\\s*)(~~)()/,\n  regExForAutoFormatting: /(~~)(\\s*\\b)([^~]*)(\\b\\s*)(~~)(\\s)$/,\n}\n\nconst markdownStrikethroughItalicBold: MarkdownCriteria = {\n  ...autoFormatBase,\n  markdownFormatKind: 'strikethrough_italic_bold',\n  regEx: /(~~_\\*\\*)(\\s*\\b)([^*_~]+)(\\b\\s*)(\\*\\*_~~)()/,\n  regExForAutoFormatting: /(~~_\\*\\*)(\\s*\\b)([^*_~]+)(\\b\\s*)(\\*\\*_~~)(\\s)$/,\n}\n\nconst markdownItalicbold: MarkdownCriteria = {\n  ...autoFormatBase,\n  markdownFormatKind: 'italic_bold',\n  regEx: /(_\\*\\*)(\\s*\\b)([^*_]+)(\\b\\s*)(\\*\\*_)/,\n  regExForAutoFormatting: /(_\\*\\*)(\\s*\\b)([^*_]+)(\\b\\s*)(\\*\\*_)(\\s)$/,\n}\n\nconst markdownStrikethroughItalic: MarkdownCriteria = {\n  ...autoFormatBase,\n  markdownFormatKind: 'strikethrough_italic',\n  regEx: /(~~_)(\\s*)([^_~]+)(\\s*)(_~~)/,\n  regExForAutoFormatting: /(~~_)(\\s*)([^_~]+)(\\s*)(_~~)(\\s)$/,\n}\n\nconst markdownStrikethroughBold: MarkdownCriteria = {\n  ...autoFormatBase,\n  markdownFormatKind: 'strikethrough_bold',\n  regEx: /(~~\\*\\*)(\\s*\\b)([^*~]+)(\\b\\s*)(\\*\\*~~)/,\n  regExForAutoFormatting: /(~~\\*\\*)(\\s*\\b)([^*~]+)(\\b\\s*)(\\*\\*~~)(\\s)$/,\n}\n\nconst markdownLink: MarkdownCriteria = {\n  ...autoFormatBase,\n  markdownFormatKind: 'link',\n  regEx: /(\\[)([^\\]]*)(\\]\\()([^)]*)(\\)*)()/,\n  regExForAutoFormatting: /(\\[)([^\\]]*)(\\]\\()([^)]*)(\\)*)(\\s)$/,\n}\n\nconst allMarkdownCriteriaForTextNodes: MarkdownCriteriaArray = [\n  // Place the combination formats ahead of the individual formats.\n  // Combos\n  markdownStrikethroughItalicBold,\n  markdownItalicbold,\n  markdownStrikethroughItalic,\n  markdownStrikethroughBold, // Individuals\n  markdownInlineCode,\n  markdownBold,\n  markdownItalic, // Must appear after markdownBold\n  markdownBold2,\n  markdownItalic2, // Must appear after markdownBold2.\n  fakeMarkdownUnderline,\n  markdownStrikethrough,\n  markdownLink,\n]\n\nconst allMarkdownCriteriaForParagraphs: MarkdownCriteriaArray = [\n  markdownHeader1,\n  markdownHeader2,\n  markdownHeader3,\n  markdownHeader4,\n  markdownHeader5,\n  markdownHeader6,\n  markdownBlockQuote,\n  markdownUnorderedListDash,\n  markdownUnorderedListAsterisk,\n  markdownOrderedList,\n  markdownHorizontalRule,\n  markdownHorizontalRuleUsingDashes,\n]\n\nexport function getAllMarkdownCriteriaForParagraphs(): MarkdownCriteriaArray {\n  return allMarkdownCriteriaForParagraphs\n}\n\nexport function getAllMarkdownCriteriaForTextNodes(): MarkdownCriteriaArray {\n  return allMarkdownCriteriaForTextNodes\n}\n\ntype Block = (\n  node: LexicalNode,\n  exportChildren: (elementNode: ElementNode) => string,\n) => null | string\n\nfunction createHeadingExport(level: number): Block {\n  return (node, exportChildren) => {\n    return $isHeadingNode(node) && node.getTag() === 'h' + level\n      ? '#'.repeat(level) + ' ' + exportChildren(node)\n      : null\n  }\n}\n\nfunction listExport(node: LexicalNode, exportChildren: (_node: ElementNode) => string) {\n  return $isListNode(node) ? processNestedLists(node, exportChildren, 0) : null\n}\n\n// TODO: should be param\nconst LIST_INDENT_SIZE = 4\n\nfunction processNestedLists(\n  listNode: ListNode,\n  exportChildren: (node: ElementNode) => string,\n  depth: number,\n): string {\n  const output: string[] = []\n  const children = listNode.getChildren()\n  let index = 0\n\n  for (const listItemNode of children) {\n    if ($isListItemNode(listItemNode)) {\n      if (listItemNode.getChildrenSize() === 1) {\n        const firstChild = listItemNode.getFirstChild()\n\n        if ($isListNode(firstChild)) {\n          output.push(processNestedLists(firstChild, exportChildren, depth + 1))\n          continue\n        }\n      }\n\n      const indent = ' '.repeat(depth * LIST_INDENT_SIZE)\n      const prefix = listNode.getListType() === 'bullet' ? '- ' : `${listNode.getStart() + index}. `\n      output.push(indent + prefix + exportChildren(listItemNode))\n      index++\n    }\n  }\n\n  return output.join('\\n')\n}\n\nfunction blockQuoteExport(node: LexicalNode, exportChildren: (_node: ElementNode) => string) {\n  return $isQuoteNode(node) ? '> ' + exportChildren(node) : null\n}\n\nexport function indexBy<T>(\n  list: Array<T>,\n  callback: (arg0: T) => string | undefined,\n): Readonly<Record<string, Array<T>>> {\n  const index: Record<string, Array<T>> = {}\n\n  for (const item of list) {\n    const key = callback(item)\n\n    if (!key) {\n      continue\n    }\n\n    if (index[key]) {\n      index[key].push(item)\n    } else {\n      index[key] = [item]\n    }\n  }\n\n  return index\n}\n\nexport function transformersByType(transformers: Array<Transformer>): Readonly<{\n  element: Array<ElementTransformer>\n  multilineElement: Array<MultilineElementTransformer>\n  textFormat: Array<TextFormatTransformer>\n  textMatch: Array<TextMatchTransformer>\n}> {\n  const byType = indexBy(transformers, (t) => t.type)\n\n  return {\n    element: (byType.element || []) as Array<ElementTransformer>,\n    multilineElement: (byType['multiline-element'] || []) as Array<MultilineElementTransformer>,\n    textFormat: (byType['text-format'] || []) as Array<TextFormatTransformer>,\n    textMatch: (byType['text-match'] || []) as Array<TextMatchTransformer>,\n  }\n}\n\nexport const PUNCTUATION_OR_SPACE = /[!-/:-@[-`{-~\\s]/\n\nconst MARKDOWN_EMPTY_LINE_REG_EXP = /^\\s{0,3}$/\n\nexport function isEmptyParagraph(node: LexicalNode): boolean {\n  if (!$isParagraphNode(node)) {\n    return false\n  }\n\n  const firstChild = node.getFirstChild()\n  return (\n    firstChild == null ||\n    (node.getChildrenSize() === 1 &&\n      $isTextNode(firstChild) &&\n      MARKDOWN_EMPTY_LINE_REG_EXP.test(firstChild.getTextContent()))\n  )\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/types.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","names":[],"sources":["../src/types.ts"],"sourcesContent":["import type {\n  DecoratorNode,\n  EditorConfig,\n  LexicalEditor,\n  EditorConfig as LexicalEditorConfig,\n  LexicalNode,\n  SerializedEditorState,\n  SerializedLexicalNode,\n} from 'lexical'\nimport type {\n  ClientField,\n  DefaultServerCellComponentProps,\n  LabelFunction,\n  PayloadComponent,\n  RichTextAdapter,\n  RichTextField,\n  RichTextFieldClient,\n  RichTextFieldClientProps,\n  SanitizedConfig,\n  ServerFieldBase,\n  StaticLabel,\n} from 'payload'\n\nimport type { BlockComponentContextType } from './features/blocks/client/component/BlockContent.js'\nexport type { BlockComponentContextType }\nimport type { BlockComponentProps } from './features/blocks/client/component/index.js'\nimport type { InlineBlockComponentContextType } from './features/blocks/client/componentInline/index.js'\nimport type {\n  JSXConverterArgs,\n  JSXConverters,\n  SerializedLexicalNodeWithParent,\n} from './features/converters/lexicalToJSX/converter/types.js'\nimport type {\n  BaseClientFeatureProps,\n  FeatureProviderProviderClient,\n} from './features/typesClient.js'\nimport type { FeatureProviderServer } from './features/typesServer.js'\nimport type { SanitizedServerEditorConfig } from './lexical/config/types.js'\nimport type {\n  DefaultNodeTypes,\n  SerializedBlockNode,\n  SerializedInlineBlockNode,\n} from './nodeTypes.js'\nimport type { InitialLexicalFormState } from './utilities/buildInitialState.js'\n\n/**\n * Base constraint for serialized Lexical node types.\n * Used as the generic constraint for node map types.\n * Extends the base SerializedLexicalNode with optional type for flexibility.\n */\nexport type SerializedNodeBase = { [key: string]: unknown; type?: string }\n\nexport type LexicalFieldAdminProps = {\n  /**\n   * Controls if the add block button should be hidden. @default false\n   */\n  hideAddBlockButton?: boolean\n  /**\n   * Controls if the draggable block element should be hidden. @default false\n   */\n  hideDraggableBlockElement?: boolean\n  /**\n   * Controls if the gutter (padding to the left & gray vertical line) should be hidden. @default false\n   */\n  hideGutter?: boolean\n  /**\n   * Controls if the insert paragraph at the end button should be hidden. @default false\n   */\n  hideInsertParagraphAtEnd?: boolean\n  /**\n   * Changes the placeholder text in the editor if no content is present.\n   */\n  placeholder?: LabelFunction | StaticLabel\n}\n\nexport type LexicalFieldAdminClientProps = {\n  placeholder?: string\n} & Omit<LexicalFieldAdminProps, 'placeholder'>\n\nexport type FeaturesInput =\n  | (({\n      defaultFeatures,\n      rootFeatures,\n    }: {\n      /**\n       * This opinionated array contains all \"recommended\" default features.\n       *\n       * @Example\n       *\n       * ```ts\n       *  editor: lexicalEditor({\n       *    features: ({ defaultFeatures }) => [...defaultFeatures, FixedToolbarFeature()],\n       *  })\n       *  ```\n       */\n      defaultFeatures: FeatureProviderServer<any, any, any>[]\n      /**\n       * This array contains all features that are enabled in the root richText editor (the one defined in the payload.config.ts).\n       * If this field is the root richText editor, or if the root richText editor is not a lexical editor, this array will be empty.\n       *\n       * @Example\n       *\n       * ```ts\n       *  editor: lexicalEditor({\n       *    features: ({ rootFeatures }) => [...rootFeatures, FixedToolbarFeature()],\n       *  })\n       *  ```\n       */\n      rootFeatures: FeatureProviderServer<any, any, any>[]\n    }) => FeatureProviderServer<any, any, any>[])\n  | FeatureProviderServer<any, any, any>[]\n\ntype WithinEditorArgs = {\n  config: EditorConfig\n  editor: LexicalEditor\n  node: LexicalNode\n}\n\n/**\n *\n * @experimental - This API is experimental and may change in a minor release.\n * @internal\n */\nexport type NodeMapValue<TNode extends SerializedNodeBase = SerializedLexicalNode> = {\n  /**\n   * Provide a react component to render the node.\n   *\n   * **JSX Converter:** Always works. Takes priority over `html`.\n   *\n   * **Lexical Editor:** Only works for DecoratorNodes (renders in `decorate` method). Takes priority over `html` and `createDOM`.\n   */\n  Component?: (\n    args:\n      | ({\n          isEditor: false\n          isJSXConverter: true\n        } & JSXConverterArgs<TNode>)\n      | ({\n          isEditor: true\n          isJSXConverter: false\n          node: {\n            _originalDecorate?: (editor: LexicalEditor, config: EditorConfig) => React.ReactNode\n          } & DecoratorNode<React.ReactNode>\n        } & Omit<WithinEditorArgs, 'node'>),\n  ) => React.ReactNode\n  /**\n   * Provide a function to create the DOM element for the node.\n   *\n   * **JSX Converter:** Not used (only `Component` and `html` work).\n   *\n   * **Lexical Editor:** Always works (renders in `createDOM` method).\n   * - For ElementNodes: This is the standard way to customize rendering.\n   * - For DecoratorNodes: When combined with `html`, the DOM gets custom structure while `decorate` renders the `html` content.\n   */\n  createDOM?: (args: WithinEditorArgs) => HTMLElement\n  /**\n   * Provide HTML string or function to render the node.\n   *\n   * **JSX Converter:** Always works (ignored if `Component` is provided).\n   *\n   * **Lexical Editor behavior depends on node type:**\n   *\n   * - **ElementNodes:** `html` is used in `createDOM` to generate the DOM structure.\n   *\n   * - **DecoratorNodes (have both `createDOM` and `decorate`):**\n   *   - If only `html` is provided: `createDOM` uses `html` to create DOM, `decorate` returns `null`\n   *   - If `html` + `Component`: `createDOM` uses `html`, `decorate` uses `Component`\n   *   - If `html` + `createDOM`: Custom `createDOM` creates structure, `decorate` renders `html` content\n   *   - If `html` + `Component` + `createDOM`: Custom `createDOM` creates structure, `decorate` uses `Component` (html ignored in editor)\n   */\n  html?: (\n    args:\n      | ({\n          isEditor: false\n          isJSXConverter: true\n        } & JSXConverterArgs<TNode>)\n      | ({\n          isEditor: true\n          isJSXConverter: false\n        } & WithinEditorArgs),\n  ) => string\n}\n\ntype SharedViewMapBlockEditorProps<TNode extends SerializedBlockNode | SerializedInlineBlockNode> =\n  {\n    /**\n     * True when rendering in the admin editor.\n     */\n    isEditor: true\n    /**\n     * False when rendering in the admin editor.\n     */\n    isJSXConverter: false\n  } & Pick<BlockComponentProps<TNode['fields']>, 'className' | 'formData' | 'nodeKey'>\n\n/**\n * Props passed to a custom Block component in editor mode.\n * Use `isEditor` to discriminate between editor and JSX converter modes.\n *\n * @experimental - This API is experimental and may change in a minor release.\n */\nexport type ViewMapBlockEditorProps<TNode extends SerializedBlockNode> = {\n  /**\n   * Hook to access block UI components (BlockCollapsible, EditButton, etc.).\n   * Call this inside your component to get the context values.\n   * Passed as a prop so you don't need to import from @payloadcms/richtext-lexical/client.\n   */\n  useBlockComponentContext: () => BlockComponentContextType\n} & SharedViewMapBlockEditorProps<TNode>\n\n/**\n * Props passed to a custom Block component in editor mode.\n * Use `isEditor` to discriminate between editor and JSX converter modes.\n *\n * @experimental - This API is experimental and may change in a minor release.\n */\nexport type ViewMapInlineBlockEditorProps<TNode extends SerializedInlineBlockNode> = {\n  useInlineBlockComponentContext: () => InlineBlockComponentContextType\n} & SharedViewMapBlockEditorProps<TNode>\n\n/**\n * Props passed to a custom Block component in JSX converter mode (frontend).\n * Use `isEditor` to discriminate between editor and JSX converter modes.\n *\n * @experimental - This API is experimental and may change in a minor release.\n */\nexport type ViewMapBlockJSXConverterProps<\n  TNode extends SerializedBlockNode | SerializedInlineBlockNode =\n    | SerializedBlockNode\n    | SerializedInlineBlockNode,\n> = {\n  /**\n   * Index of this node among its siblings.\n   */\n  childIndex: number\n  /**\n   * Available JSX converters for nested content.\n   */\n  converters: JSXConverters\n  /**\n   * The block's form data (field values).\n   */\n  formData: TNode['fields']\n  /**\n   * False when rendering via JSX converter (frontend).\n   */\n  isEditor: false\n  /**\n   * True when rendering via JSX converter (frontend).\n   */\n  isJSXConverter: true\n  /**\n   * The serialized block node.\n   */\n  node: TNode\n  /**\n   * Function to convert child nodes to JSX.\n   */\n  nodesToJSX: (args: {\n    converters?: JSXConverters\n    disableIndent?: boolean | string[]\n    disableTextAlign?: boolean | string[]\n    nodes: SerializedLexicalNode[]\n    parent?: SerializedLexicalNodeWithParent\n  }) => React.ReactNode[]\n  /**\n   * The parent node in the tree.\n   */\n  parent: SerializedLexicalNodeWithParent\n}\n\n/**\n * Props passed to a custom Block component in a view map.\n * This is a discriminated union - use `isEditor` to narrow the type.\n *\n * When `isEditor` is true, you're in the admin editor with access to `blockContext`.\n * When `isEditor` is false, you're in the frontend JSX converter with `nodesToJSX`.\n *\n * @example\n * ```tsx\n * const MyBlock: React.FC<ViewMapBlockComponentProps> = (props) => {\n *   if (props.isEditor) {\n *     // Admin editor - blockContext available\n *     const { BlockCollapsible, EditButton } = props.blockContext\n *     return <BlockCollapsible>{props.formData.title}</BlockCollapsible>\n *   }\n *   // Frontend - readonly render\n *   return <div>{props.formData.title}</div>\n * }\n * ```\n *\n * @experimental - This API is experimental and may change in a minor release.\n */\nexport type ViewMapBlockComponentProps<TNode extends SerializedBlockNode = SerializedBlockNode> =\n  | ViewMapBlockEditorProps<TNode>\n  | ViewMapBlockJSXConverterProps<TNode>\n\nexport type ViewMapInlineBlockComponentProps<\n  TNode extends SerializedInlineBlockNode = SerializedInlineBlockNode,\n> = ViewMapBlockJSXConverterProps<TNode> | ViewMapInlineBlockEditorProps<TNode>\n\n/**\n *\n * @experimental - This API is experimental and may change in a minor release.\n * @internal\n */\nexport type NodeMapBlockValue<TNode extends SerializedBlockNode = SerializedBlockNode> = {\n  /**\n   * A React component that replaces the entire block, including the header/collapsible.\n   * Works for both admin editor and frontend JSX conversion.\n   *\n   * Use `isEditor` to discriminate between modes:\n   * - Editor mode: `blockContext` is available with UI components (BlockCollapsible, EditButton, etc.)\n   * - JSX converter mode: `nodesToJSX` is available for rendering nested content\n   *\n   * @example\n   * ```tsx\n   * Block: (props) => {\n   *   if (props.isEditor) {\n   *     const { BlockCollapsible } = props.blockContext\n   *     return <BlockCollapsible>{props.formData.title}</BlockCollapsible>\n   *   }\n   *   return <div>{props.formData.title}</div>\n   * }\n   * ```\n   */\n  Block?: React.FC<ViewMapBlockComponentProps<TNode>>\n  /**\n   * A React component that replaces the block label.\n   * Use `useBlockComponentContext()` hook to access block context.\n   */\n  Label?: React.FC<ViewMapBlockComponentProps<TNode>>\n} & Pick<NodeMapValue<TNode>, 'Component' | 'createDOM' | 'html'>\n\nexport type NodeMapInlineBlockValue<\n  TNode extends SerializedInlineBlockNode = SerializedInlineBlockNode,\n> = {\n  /**\n   * A React component that replaces the entire block, including the header/collapsible.\n   * Works for both admin editor and frontend JSX conversion.\n   *\n   * Use `isEditor` to discriminate between modes:\n   * - Editor mode: `blockContext` is available with UI components (BlockCollapsible, EditButton, etc.)\n   * - JSX converter mode: `nodesToJSX` is available for rendering nested content\n   *\n   * @example\n   * ```tsx\n   * InlineBlock: (props) => {\n   *   if (props.isEditor) {\n   *     const { BlockCollapsible } = props.blockContext\n   *     return <BlockCollapsible>{props.formData.title}</BlockCollapsible>\n   *   }\n   *   return <div>{props.formData.title}</div>\n   * }\n   * ```\n   */\n  Block?: React.FC<ViewMapInlineBlockComponentProps<TNode>>\n  /**\n   * A React component that replaces the block label.\n   * Use `useBlockComponentContext()` hook to access block context.\n   */\n  Label?: React.FC<ViewMapInlineBlockComponentProps<TNode>>\n} & Pick<NodeMapValue<TNode>, 'Component' | 'createDOM' | 'html'>\n\n/**\n * @experimental - This API is experimental and may change in a minor release.\n * @internal\n */\nexport type LexicalEditorNodeMap<\n  TNodes extends SerializedNodeBase =\n    | DefaultNodeTypes\n    | SerializedBlockNode<{ blockName?: null | string; blockType: string }> // need these to ensure types for blocks and inlineBlocks work if no generics are provided\n    | SerializedInlineBlockNode<{ blockName?: null | string; blockType: string }>, // need these to ensure types for blocks and inlineBlocks work if no generics are provided\n> = {\n  // The index signature must include NodeMapBlockValue in the nested blockSlug mapping because\n  // 'blocks' and 'inlineBlocks' properties use NodeMapBlockValue (which adds Block/Label props).\n  // TypeScript requires that intersection properties be assignable to index signatures.\n  [key: string]:\n    | {\n        [blockSlug: string]: NodeMapBlockValue<any> | NodeMapInlineBlockValue<any>\n      }\n    | NodeMapValue<any>\n    | undefined\n} & {\n  [nodeType in Exclude<NonNullable<TNodes['type']>, 'block' | 'inlineBlock'>]?: NodeMapValue<\n    Extract<TNodes, { type: nodeType }>\n  >\n} & {\n  blocks?: {\n    [K in Extract<\n      Extract<TNodes, { type: 'block' }> extends SerializedBlockNode<infer B>\n        ? B extends { blockType: string }\n          ? B['blockType']\n          : never\n        : never,\n      string\n    >]?: NodeMapBlockValue<\n      Extract<TNodes, { type: 'block' }> extends SerializedBlockNode<infer B>\n        ? SerializedBlockNode<Extract<B, { blockType: K }>>\n        : SerializedBlockNode\n    >\n  }\n  inlineBlocks?: {\n    [K in Extract<\n      Extract<TNodes, { type: 'inlineBlock' }> extends SerializedInlineBlockNode<infer B>\n        ? B extends { blockType: string }\n          ? B['blockType']\n          : never\n        : never,\n      string\n    >]?: NodeMapInlineBlockValue<\n      Extract<TNodes, { type: 'inlineBlock' }> extends SerializedInlineBlockNode<infer B>\n        ? SerializedInlineBlockNode<Extract<B, { blockType: K }>>\n        : SerializedInlineBlockNode\n    >\n  }\n  unknown?: NodeMapValue<SerializedLexicalNode>\n}\n\n/**\n * A map of views, which can be used to render the editor in different ways.\n *\n * In order to override the default view, you can add a `default` key to the map.\n *\n * @experimental - This API is experimental and may change in a minor release.\n * @internal\n */\nexport type ClientFeaturesMap = {\n  [featureKey: string]: {\n    clientFeatureProps?: BaseClientFeatureProps<Record<string, any>>\n    clientFeatureProvider?: FeatureProviderProviderClient<any, any>\n  }\n}\n\nexport type LexicalEditorViewMap<\n  TNodes extends SerializedNodeBase =\n    | DefaultNodeTypes\n    | SerializedBlockNode<{ blockName?: null | string; blockType: string }> // need these to ensure types for blocks and inlineBlocks work if no generics are provided\n    | SerializedInlineBlockNode<{ blockName?: null | string; blockType: string }>, // need these to ensure types for blocks and inlineBlocks work if no generics are provided\n> = {\n  [viewKey: string]: {\n    admin?: LexicalFieldAdminClientProps\n    /**\n     * Transform the client features for this view.\n     * Receives the full clientFeatures map and should return a (potentially modified) map.\n     * Can be used to remove features or add new ones per-view.\n     *\n     * @example Remove toolbars\n     * ```ts\n     * filterFeatures: (features) => {\n     *   const { toolbarFixed, toolbarInline, ...rest } = features\n     *   return rest\n     * }\n     * ```\n     */\n    filterFeatures?: (clientFeatures: ClientFeaturesMap) => ClientFeaturesMap\n    /**\n     * Lexical editor configuration. Can be an object or a function that receives the default config.\n     * Using a function avoids needing to import defaultEditorLexicalConfig.\n     *\n     * @example\n     * ```ts\n     * lexical: (defaultConfig) => ({\n     *   ...defaultConfig,\n     *   theme: { ...defaultConfig.theme, paragraph: 'my-paragraph' },\n     * })\n     * ```\n     */\n    lexical?: ((defaultConfig: LexicalEditorConfig) => LexicalEditorConfig) | LexicalEditorConfig\n    nodes: LexicalEditorNodeMap<TNodes>\n  }\n}\n\n/**\n * @todo rename to LexicalEditorArgs in 4.0, since these are arguments for the lexicalEditor function\n */\nexport type LexicalEditorProps = {\n  admin?: LexicalFieldAdminProps\n  features?: FeaturesInput\n  lexical?: LexicalEditorConfig\n  /**\n   * A path to a LexicalEditorViewMap, which can be used to render the editor in different ways.\n   *\n   * In order to override the default view, you can add a `default` key to the map.\n   *\n   * @experimental - This API is experimental and may change in a minor release.\n   * @internal\n   */\n  views?: PayloadComponent\n}\n\nexport type LexicalRichTextAdapter = {\n  editorConfig: SanitizedServerEditorConfig\n  features: FeatureProviderServer<any, any, any>[]\n} & RichTextAdapter<SerializedEditorState, AdapterProps>\n\nexport type LexicalRichTextAdapterProvider =\n  /**\n   * This is being called during the payload sanitization process\n   */\n  ({\n    config,\n    isRoot,\n    parentIsLocalized,\n  }: {\n    config: SanitizedConfig\n    isRoot?: boolean\n    parentIsLocalized: boolean\n  }) => Promise<LexicalRichTextAdapter>\n\nexport type SingleFeatureClientSchemaMap = {\n  [key: string]: ClientField[]\n}\nexport type FeatureClientSchemaMap = {\n  [featureKey: string]: SingleFeatureClientSchemaMap\n}\n\nexport type LexicalRichTextFieldProps = {\n  admin?: LexicalFieldAdminClientProps\n  // clientFeatures is added through the rsc field\n  clientFeatures: ClientFeaturesMap\n  /**\n   * Part of the import map that contains client components for all lexical features of this field that\n   * have been added through `feature.componentImports`.\n   */\n  featureClientImportMap?: Record<string, any>\n  featureClientSchemaMap: FeatureClientSchemaMap\n  initialLexicalFormState: InitialLexicalFormState\n  lexicalEditorConfig: LexicalEditorConfig | undefined // Undefined if default lexical editor config should be used\n  views?: LexicalEditorViewMap\n} & Pick<ServerFieldBase, 'permissions'> &\n  RichTextFieldClientProps<SerializedEditorState, AdapterProps, object>\n\nexport type LexicalRichTextCellProps = DefaultServerCellComponentProps<\n  RichTextFieldClient<SerializedEditorState, AdapterProps, object>,\n  SerializedEditorState\n>\n\nexport type AdapterProps = {\n  editorConfig: SanitizedServerEditorConfig\n}\n\nexport type GeneratedFeatureProviderComponent = {\n  clientFeature: FeatureProviderProviderClient<any, any>\n  clientFeatureProps: BaseClientFeatureProps<object>\n}\n\nexport type LexicalRichTextField = RichTextField<SerializedEditorState, AdapterProps>\n"],"mappings":"AAmiBA","ignoreList":[]}

package/dist/utilities/jsx/jsx.spec.js

@@ -1,178 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { extractPropsFromJSXPropsString } from './extractPropsFromJSXPropsString.js';
-import { propsToJSXString } from './jsx.js';
-describe('jsx', () => {
-  describe('prop string to object', () => {
-    const INPUT_AND_OUTPUT = [{
-      input: 'key="value"',
-      output: {
-        key: 'value'
-      }
-    }, {
-      input: "key='value'",
-      output: {
-        key: 'value'
-      },
-      inputFromOutput: 'key="value"'
-    }, {
-      input: 'key={[1, 2, 3]}',
-      output: {
-        key: [1, 2, 3]
-      }
-    }, {
-      input: 'key={[1, 2, 3, [1, 2]]}',
-      output: {
-        key: [1, 2, 3, [1, 2]]
-      }
-    }, {
-      input: 'object={4}',
-      output: {
-        object: 4
-      }
-    }, {
-      input: 'object={{"test": 1}}',
-      output: {
-        object: {
-          test: 1
-        }
-      }
-    }, {
-      input: 'object={[1, 2, 3, [1, 2]]}',
-      output: {
-        object: [1, 2, 3, [1, 2]]
-      }
-    }, {
-      input: 'object={[1, 2]}',
-      output: {
-        object: [1, 2]
-      }
-    }, {
-      input: 'key="value" object={{key: "value"}}',
-      inputFromOutput: 'key="value" object={{"key": "value"}}',
-      output: {
-        key: 'value',
-        object: {
-          key: 'value'
-        }
-      }
-    }, {
-      input: 'global packageId="myId" uniqueId="some unique id!" update',
-      output: {
-        global: true,
-        packageId: 'myId',
-        uniqueId: 'some unique id!',
-        update: true
-      }
-    }, {
-      input: 'global key="value" object={{key: "value", something: "test", hello: 1}} packageId="myId" uniqueId="some unique id!" update',
-      inputFromOutput: 'global key="value" object={{"hello": 1, "key": "value", "something": "test"}} packageId="myId" uniqueId="some unique id!" update',
-      output: {
-        global: true,
-        key: 'value',
-        object: {
-          hello: 1,
-          key: 'value',
-          something: 'test'
-        },
-        packageId: 'myId',
-        uniqueId: 'some unique id!',
-        update: true
-      }
-    }, {
-      input: 'object={{hello: 1, key: "value", nested: { key: "value" }, something: "test", test: [1, 2, 3]}}',
-      inputFromOutput: 'object={{"hello": 1, "key": "value", "nested": {"key": "value"}, "something": "test", "test": [1, 2, 3]}}',
-      output: {
-        object: {
-          hello: 1,
-          key: 'value',
-          nested: {
-            key: 'value'
-          },
-          something: 'test',
-          test: [1, 2, 3]
-        }
-      }
-    }, {
-      input: 'global key="value" object={{hello: 1, key: "value", nested: { key: "value" }, something: "test", test: [1, 2, 3]}} packageId="myId" uniqueId="some unique id!" update',
-      inputFromOutput: 'global key="value" object={{"hello": 1, "key": "value", "nested": { "key": "value" }, "something": "test", "test": [1, 2, 3]}} packageId="myId" uniqueId="some unique id!" update',
-      output: {
-        global: true,
-        key: 'value',
-        object: {
-          hello: 1,
-          key: 'value',
-          nested: {
-            key: 'value'
-          },
-          something: 'test',
-          test: [1, 2, 3]
-        },
-        packageId: 'myId',
-        uniqueId: 'some unique id!',
-        update: true
-      }
-    }, {
-      // Test if unquoted property keys in objects within arrays are supprted. This is
-      // supported through the more lenient JSOX parser, instead of using JSON.parse()
-      input: 'key={[1, 2, { hello: "there" }]}',
-      inputFromOutput: 'key={[1, 2, { "hello": "there" }]}',
-      output: {
-        key: [1, 2, {
-          hello: 'there'
-        }]
-      }
-    }, {
-      // Test if ` strings work
-      input: `key={[1, 2, { hello: \`there\` }]}`,
-      inputFromOutput: 'key={[1, 2, { "hello": "there" }]}',
-      output: {
-        key: [1, 2, {
-          hello: 'there'
-        }]
-      }
-    }, {
-      // Test if multiline ` strings work
-      input: `key={[1, 2, { hello: \`Hello
-there\` }]}`,
-      inputFromOutput: 'key={[1, 2, { "hello": "Hello\\nthere" }]}',
-      output: {
-        key: [1, 2, {
-          hello: 'Hello\nthere'
-        }]
-      }
-    }];
-    for (const {
-      input,
-      output
-    } of INPUT_AND_OUTPUT) {
-      it(`can correctly convert to object: "${input.replace(/\n/g, '\\n')}"`, () => {
-        const propsObject = extractPropsFromJSXPropsString({
-          propsString: input
-        });
-        console.log({
-          output,
-          propsObject
-        });
-        expect(propsObject).toStrictEqual(output);
-      });
-    }
-    for (const {
-      input: originalInput,
-      inputFromOutput,
-      output
-    } of INPUT_AND_OUTPUT) {
-      const input = inputFromOutput || originalInput;
-      it(`can correctly convert from object: "${input.replace(/\n/g, '\\n')}"`, () => {
-        const propsString = propsToJSXString({
-          props: output
-        });
-        console.log({
-          input,
-          propsString
-        });
-        expect(propsString.replaceAll(' ', '')).toBe(input.replaceAll(' ', ''));
-      });
-    }
-  });
-});
-//# sourceMappingURL=jsx.spec.js.map

package/dist/utilities/jsx/jsx.spec.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"jsx.spec.js","names":["describe","it","expect","extractPropsFromJSXPropsString","propsToJSXString","INPUT_AND_OUTPUT","input","output","key","inputFromOutput","object","test","global","packageId","uniqueId","update","hello","something","nested","replace","propsObject","propsString","console","log","toStrictEqual","originalInput","props","replaceAll","toBe"],"sources":["../../../src/utilities/jsx/jsx.spec.ts"],"sourcesContent":["import { describe, it, expect } from 'vitest'\nimport { extractPropsFromJSXPropsString } from './extractPropsFromJSXPropsString.js'\nimport { propsToJSXString } from './jsx.js'\n\ndescribe('jsx', () => {\n  describe('prop string to object', () => {\n    const INPUT_AND_OUTPUT: {\n      input: string\n      inputFromOutput?: string\n      output: Record<string, any>\n    }[] = [\n      {\n        input: 'key=\"value\"',\n        output: {\n          key: 'value',\n        },\n      },\n      {\n        input: \"key='value'\",\n        output: {\n          key: 'value',\n        },\n        inputFromOutput: 'key=\"value\"',\n      },\n      {\n        input: 'key={[1, 2, 3]}',\n        output: {\n          key: [1, 2, 3],\n        },\n      },\n      {\n        input: 'key={[1, 2, 3, [1, 2]]}',\n        output: {\n          key: [1, 2, 3, [1, 2]],\n        },\n      },\n      {\n        input: 'object={4}',\n        output: {\n          object: 4,\n        },\n      },\n      {\n        input: 'object={{\"test\": 1}}',\n        output: {\n          object: { test: 1 },\n        },\n      },\n      {\n        input: 'object={[1, 2, 3, [1, 2]]}',\n        output: {\n          object: [1, 2, 3, [1, 2]],\n        },\n      },\n      {\n        input: 'object={[1, 2]}',\n        output: {\n          object: [1, 2],\n        },\n      },\n      {\n        input: 'key=\"value\" object={{key: \"value\"}}',\n        inputFromOutput: 'key=\"value\" object={{\"key\": \"value\"}}',\n        output: {\n          key: 'value',\n          object: { key: 'value' },\n        },\n      },\n      {\n        input: 'global packageId=\"myId\" uniqueId=\"some unique id!\" update',\n        output: {\n          global: true,\n          packageId: 'myId',\n          uniqueId: 'some unique id!',\n          update: true,\n        },\n      },\n      {\n        input:\n          'global key=\"value\" object={{key: \"value\", something: \"test\", hello: 1}} packageId=\"myId\" uniqueId=\"some unique id!\" update',\n        inputFromOutput:\n          'global key=\"value\" object={{\"hello\": 1, \"key\": \"value\", \"something\": \"test\"}} packageId=\"myId\" uniqueId=\"some unique id!\" update',\n        output: {\n          global: true,\n          key: 'value',\n          object: { hello: 1, key: 'value', something: 'test' },\n          packageId: 'myId',\n          uniqueId: 'some unique id!',\n          update: true,\n        },\n      },\n      {\n        input:\n          'object={{hello: 1, key: \"value\", nested: { key: \"value\" }, something: \"test\", test: [1, 2, 3]}}',\n        inputFromOutput:\n          'object={{\"hello\": 1, \"key\": \"value\", \"nested\": {\"key\": \"value\"}, \"something\": \"test\", \"test\": [1, 2, 3]}}',\n        output: {\n          object: {\n            hello: 1,\n            key: 'value',\n            nested: { key: 'value' },\n            something: 'test',\n            test: [1, 2, 3],\n          },\n        },\n      },\n      {\n        input:\n          'global key=\"value\" object={{hello: 1, key: \"value\", nested: { key: \"value\" }, something: \"test\", test: [1, 2, 3]}} packageId=\"myId\" uniqueId=\"some unique id!\" update',\n        inputFromOutput:\n          'global key=\"value\" object={{\"hello\": 1, \"key\": \"value\", \"nested\": { \"key\": \"value\" }, \"something\": \"test\", \"test\": [1, 2, 3]}} packageId=\"myId\" uniqueId=\"some unique id!\" update',\n        output: {\n          global: true,\n          key: 'value',\n          object: {\n            hello: 1,\n            key: 'value',\n            nested: { key: 'value' },\n            something: 'test',\n            test: [1, 2, 3],\n          },\n          packageId: 'myId',\n          uniqueId: 'some unique id!',\n          update: true,\n        },\n      },\n      {\n        // Test if unquoted property keys in objects within arrays are supprted. This is\n        // supported through the more lenient JSOX parser, instead of using JSON.parse()\n        input: 'key={[1, 2, { hello: \"there\" }]}',\n        inputFromOutput: 'key={[1, 2, { \"hello\": \"there\" }]}',\n        output: {\n          key: [1, 2, { hello: 'there' }],\n        },\n      },\n      {\n        // Test if ` strings work\n        input: `key={[1, 2, { hello: \\`there\\` }]}`,\n        inputFromOutput: 'key={[1, 2, { \"hello\": \"there\" }]}',\n        output: {\n          key: [1, 2, { hello: 'there' }],\n        },\n      },\n      {\n        // Test if multiline ` strings work\n        input: `key={[1, 2, { hello: \\`Hello\nthere\\` }]}`,\n        inputFromOutput: 'key={[1, 2, { \"hello\": \"Hello\\\\nthere\" }]}',\n        output: {\n          key: [1, 2, { hello: 'Hello\\nthere' }],\n        },\n      },\n    ]\n\n    for (const { input, output } of INPUT_AND_OUTPUT) {\n      it(`can correctly convert to object: \"${input.replace(/\\n/g, '\\\\n')}\"`, () => {\n        const propsObject = extractPropsFromJSXPropsString({ propsString: input })\n        console.log({ output, propsObject })\n\n        expect(propsObject).toStrictEqual(output)\n      })\n    }\n\n    for (const { input: originalInput, inputFromOutput, output } of INPUT_AND_OUTPUT) {\n      const input = inputFromOutput || originalInput\n      it(`can correctly convert from object: \"${input.replace(/\\n/g, '\\\\n')}\"`, () => {\n        const propsString = propsToJSXString({ props: output })\n        console.log({ input, propsString })\n\n        expect(propsString.replaceAll(' ', '')).toBe(input.replaceAll(' ', ''))\n      })\n    }\n  })\n})\n"],"mappings":"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","ignoreList":[]}

package/dist/utilities/migrateSlateToLexical/index.d.ts

@@ -1,15 +0,0 @@
-import type { Payload } from 'payload';
-/**
- * This goes through every single collection and field in the payload config, and migrates its data from Slate to Lexical. This does not support sub-fields within slate.
- *
- * It will only translate fields fulfilling all these requirements:
- * - field schema uses lexical editor
- * - lexical editor has SlateToLexicalFeature added
- * - saved field data is in Slate format
- *
- * @param payload
- */
-export declare function migrateSlateToLexical({ payload }: {
-    payload: Payload;
-}): Promise<void>;
-//# sourceMappingURL=index.d.ts.map

package/dist/utilities/migrateSlateToLexical/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utilities/migrateSlateToLexical/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAyC,OAAO,EAAE,MAAM,SAAS,CAAA;AAI7E;;;;;;;;;GASG;AACH,wBAAsB,qBAAqB,CAAC,EAAE,OAAO,EAAE,EAAE;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,iBAoC5E"}