@payloadcms/richtext-lexical 4.0.0-internal.38b7f1d → 4.0.0-internal.3aa3d85

package/dist/lexical/theme/EditorTheme.css

@@ -6,7 +6,7 @@
     --lexical-h1-font-size: 2rem; /* 32px */
     --lexical-h1-letter-spacing: -0.544px;
     --lexical-h2-font-size: 1.5rem; /* 24px */
-    --lexical-h2-letter-spacing: -0.408px;
+    --lexical-h2-letter-spacing: var(--text-heading-large-letter-spacing);
     --lexical-h2-line-height: 2rem; /* 32px */
     --lexical-h3-font-size: 1.25rem; /* 20px */
     --lexical-h3-letter-spacing: -0.34px;
@@ -131,8 +131,7 @@
   .LexicalEditorTheme__tabNode.LexicalEditorTheme__textUnderline::after {
     content: '';
     position: absolute;
-    left: 0;
-    right: 0;
+    inset-inline: 0;
     bottom: 0.15em;
     border-bottom: 0.1em solid currentColor;
   }
@@ -140,8 +139,7 @@
   .LexicalEditorTheme__tabNode.LexicalEditorTheme__textStrikethrough::before {
     content: '';
     position: absolute;
-    left: 0;
-    right: 0;
+    inset-inline: 0;
     top: 0.69em;
     border-top: 0.1em solid currentColor;
   }
@@ -150,8 +148,7 @@
   .LexicalEditorTheme__tabNode.LexicalEditorTheme__textUnderlineStrikethrough::after {
     content: '';
     position: absolute;
-    left: 0;
-    right: 0;
+    inset-inline: 0;
   }
 
   .LexicalEditorTheme__tabNode.LexicalEditorTheme__textUnderlineStrikethrough::before {
@@ -201,7 +198,7 @@
       content: '';
       display: block;
       position: absolute;
-      top: -2px;
+      top: calc(var(--stroke-width-medium) * -1);
       width: var(--spacer-3);
       border-top: var(--stroke-width-small) solid var(--color-text);
       animation: CursorBlink 1.1s steps(2, start) infinite;
@@ -263,7 +260,8 @@
   .LexicalEditorTheme__listItem {
     font-family: var(--text-body-large-font-family);
     font-size: var(--text-body-large-font-size);
-    margin: 0 0 var(--spacer-3) var(--spacer-6);
+    margin-block-end: var(--spacer-3);
+    margin-inline-start: var(--spacer-6);
   }
 
   .LexicalEditorTheme__listItem[style*='text-align: center'],
@@ -280,24 +278,25 @@
   }
 
   .LexicalEditorTheme__listItem[dir='rtl'] {
-    margin: 0 var(--spacer-6) 0.4em 0;
+    margin-block-end: 0.4em;
+    margin-inline-end: var(--spacer-6);
   }
 
   .LexicalEditorTheme__listItemChecked,
   .LexicalEditorTheme__listItemUnchecked {
     position: relative;
-    padding-right: var(--spacer-4);
-    margin-right: var(--spacer-3);
+    padding-inline-start: var(--spacer-4);
+    margin-inline-start: var(--spacer-3);
     list-style-type: none;
     outline: none;
   }
 
   .LexicalEditorTheme__listItemUnchecked[dir='rtl'],
   .LexicalEditorTheme__listItemChecked[dir='rtl'] {
-    margin-left: 0;
-    padding-left: 0;
-    padding-right: var(--spacer-4);
-    margin-right: var(--spacer-3);
+    margin-inline-start: 0;
+    padding-inline-start: 0;
+    padding-inline-end: var(--spacer-4);
+    margin-inline-end: var(--spacer-3);
   }
 
   .LexicalEditorTheme__listItemChecked {
@@ -310,7 +309,7 @@
     width: var(--spacer-3);
     height: var(--spacer-3);
     top: 0;
-    left: 0;
+    inset-inline-start: 0;
     cursor: pointer;
     display: block;
     position: absolute;
@@ -320,18 +319,18 @@
 
   .LexicalEditorTheme__listItemUnchecked[dir='rtl']:before,
   .LexicalEditorTheme__listItemChecked[dir='rtl']:before {
-    left: auto;
-    right: 0;
+    inset-inline-start: auto;
+    inset-inline-end: 0;
   }
 
   .LexicalEditorTheme__listItemUnchecked:focus:before,
   .LexicalEditorTheme__listItemChecked:focus:before {
     outline: 0;
-    box-shadow: 0 0 0 2px var(--color-border-selected);
+    box-shadow: 0 0 0 var(--stroke-width-medium) var(--color-border-selected);
   }
 
   .LexicalEditorTheme__listItemUnchecked:before {
-    border: 1px solid var(--color-text);
+    border: var(--stroke-width-small) solid var(--color-text);
     background-color: var(--color-bg);
   }
 

package/dist/lexical/ui/ContentEditable.css

@@ -7,8 +7,8 @@
     outline: 0;
     padding-top: var(--spacer-2);
     padding-bottom: var(--spacer-2);
-    padding-left: 0;
-    padding-right: 0;
+    padding-inline-start: 0;
+    padding-inline-end: 0;
 
     &:focus-visible {
       outline: none !important;
@@ -37,7 +37,7 @@
           > .editor-scroller
           > .editor
           > .ContentEditable__root::before {
-          border-left: 2px solid var(--color-border-danger);
+          border-inline-start: var(--stroke-width-medium) solid var(--color-border-danger);
         }
       }
 
@@ -47,7 +47,7 @@
           > .editor-scroller
           > .editor
           > .ContentEditable__root::before {
-          border-left: 2px solid var(--color-border-danger);
+          border-inline-start: var(--stroke-width-medium) solid var(--color-border-danger);
         }
       }
     }
@@ -72,7 +72,7 @@
           > .editor-scroller
           > .editor
           > .ContentEditable__root::before {
-          border-left: 2px solid var(--color-border-danger);
+          border-inline-start: var(--stroke-width-medium) solid var(--color-border-danger);
         }
       }
     }

package/dist/lexical/utils/markdown/convertFromMarkdownString.d.ts

@@ -0,0 +1,17 @@
+import type { Transformer } from '@lexical/markdown';
+import type { ElementNode } from 'lexical';
+/**
+ * Payload's markdown import. Wraps `@lexical/markdown`'s `$convertFromMarkdownString`
+ * with Payload's `normalizeMarkdown` preprocessing (nested code fences + table-row
+ * whitespace handling).
+ *
+ * TODO: Remove this wrapper and the `normalizeMarkdown` import once
+ * https://github.com/facebook/lexical/pull/8734 is merged and we upgrade to a
+ * release that includes it. At that point callers can use `@lexical/markdown`'s
+ * `$convertFromMarkdownString` directly.
+ *
+ * @param shouldPreserveNewLines By setting this to true, new lines will be preserved between conversions.
+ * @param shouldMergeAdjacentLines By setting this to true, adjacent non empty lines will be merged according to commonmark spec: https://spec.commonmark.org/0.24/#example-177. Not applicable if shouldPreserveNewLines = true.
+ */
+export declare function $convertFromMarkdownString(markdown: string, transformers?: Array<Transformer>, node?: ElementNode, shouldPreserveNewLines?: boolean, shouldMergeAdjacentLines?: boolean): void;
+//# sourceMappingURL=convertFromMarkdownString.d.ts.map

package/dist/lexical/utils/markdown/convertFromMarkdownString.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convertFromMarkdownString.d.ts","sourceRoot":"","sources":["../../../../src/lexical/utils/markdown/convertFromMarkdownString.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AACpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAU1C;;;;;;;;;;;;GAYG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,MAAM,EAChB,YAAY,GAAE,KAAK,CAAC,WAAW,CAAgB,EAC/C,IAAI,CAAC,EAAE,WAAW,EAClB,sBAAsB,UAAQ,EAC9B,wBAAwB,UAAQ,GAC/B,IAAI,CASN"}

package/dist/lexical/utils/markdown/convertFromMarkdownString.js

@@ -0,0 +1,27 @@
+import { $convertFromMarkdownString as $convertFromMarkdownStringUpstream,
+// eslint-disable-next-line payload/no-conflicting-lexical-markdown-imports -- this wrapper intentionally uses upstream's default transformer set
+TRANSFORMERS } from '@lexical/markdown';
+import { normalizeMarkdown } from './normalizeMarkdown.js';
+/**
+ * Payload's markdown import. Wraps `@lexical/markdown`'s `$convertFromMarkdownString`
+ * with Payload's `normalizeMarkdown` preprocessing (nested code fences + table-row
+ * whitespace handling).
+ *
+ * TODO: Remove this wrapper and the `normalizeMarkdown` import once
+ * https://github.com/facebook/lexical/pull/8734 is merged and we upgrade to a
+ * release that includes it. At that point callers can use `@lexical/markdown`'s
+ * `$convertFromMarkdownString` directly.
+ *
+ * @param shouldPreserveNewLines By setting this to true, new lines will be preserved between conversions.
+ * @param shouldMergeAdjacentLines By setting this to true, adjacent non empty lines will be merged according to commonmark spec: https://spec.commonmark.org/0.24/#example-177. Not applicable if shouldPreserveNewLines = true.
+ */
+export function $convertFromMarkdownString(markdown, transformers = TRANSFORMERS, node, shouldPreserveNewLines = false, shouldMergeAdjacentLines = false) {
+  if (shouldPreserveNewLines) {
+    return $convertFromMarkdownStringUpstream(markdown, transformers, node, true);
+  }
+  // Passing shouldMergeAdjacentLines = false to upstream stops it from
+  // re-normalizing markdown that normalizeMarkdown has already normalized.
+  const sanitizedMarkdown = normalizeMarkdown(markdown, shouldMergeAdjacentLines);
+  return $convertFromMarkdownStringUpstream(sanitizedMarkdown, transformers, node, false, false);
+}
+//# sourceMappingURL=convertFromMarkdownString.js.map

package/dist/lexical/utils/markdown/convertFromMarkdownString.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"convertFromMarkdownString.js","names":["$convertFromMarkdownString","$convertFromMarkdownStringUpstream","TRANSFORMERS","normalizeMarkdown","markdown","transformers","node","shouldPreserveNewLines","shouldMergeAdjacentLines","sanitizedMarkdown"],"sources":["../../../../src/lexical/utils/markdown/convertFromMarkdownString.ts"],"sourcesContent":["import type { Transformer } from '@lexical/markdown'\nimport type { ElementNode } from 'lexical'\n\nimport {\n  $convertFromMarkdownString as $convertFromMarkdownStringUpstream,\n  // eslint-disable-next-line payload/no-conflicting-lexical-markdown-imports -- this wrapper intentionally uses upstream's default transformer set\n  TRANSFORMERS,\n} from '@lexical/markdown'\n\nimport { normalizeMarkdown } from './normalizeMarkdown.js'\n\n/**\n * Payload's markdown import. Wraps `@lexical/markdown`'s `$convertFromMarkdownString`\n * with Payload's `normalizeMarkdown` preprocessing (nested code fences + table-row\n * whitespace handling).\n *\n * TODO: Remove this wrapper and the `normalizeMarkdown` import once\n * https://github.com/facebook/lexical/pull/8734 is merged and we upgrade to a\n * release that includes it. At that point callers can use `@lexical/markdown`'s\n * `$convertFromMarkdownString` directly.\n *\n * @param shouldPreserveNewLines By setting this to true, new lines will be preserved between conversions.\n * @param shouldMergeAdjacentLines By setting this to true, adjacent non empty lines will be merged according to commonmark spec: https://spec.commonmark.org/0.24/#example-177. Not applicable if shouldPreserveNewLines = true.\n */\nexport function $convertFromMarkdownString(\n  markdown: string,\n  transformers: Array<Transformer> = TRANSFORMERS,\n  node?: ElementNode,\n  shouldPreserveNewLines = false,\n  shouldMergeAdjacentLines = false,\n): void {\n  if (shouldPreserveNewLines) {\n    return $convertFromMarkdownStringUpstream(markdown, transformers, node, true)\n  }\n\n  // Passing shouldMergeAdjacentLines = false to upstream stops it from\n  // re-normalizing markdown that normalizeMarkdown has already normalized.\n  const sanitizedMarkdown = normalizeMarkdown(markdown, shouldMergeAdjacentLines)\n  return $convertFromMarkdownStringUpstream(sanitizedMarkdown, transformers, node, false, false)\n}\n"],"mappings":"AAGA,SACEA,0BAAA,IAA8BC,kCAAkC;AAEhE;AAAAC,YAAY,QACP;AAEP,SAASC,iBAAiB,QAAQ;AAElC;;;;;;;;;;;;;AAaA,OAAO,SAASH,2BACdI,QAAgB,EAChBC,YAAA,GAAmCH,YAAY,EAC/CI,IAAkB,EAClBC,sBAAA,GAAyB,KAAK,EAC9BC,wBAAA,GAA2B,KAAK;EAEhC,IAAID,sBAAA,EAAwB;IAC1B,OAAON,kCAAA,CAAmCG,QAAA,EAAUC,YAAA,EAAcC,IAAA,EAAM;EAC1E;EAEA;EACA;EACA,MAAMG,iBAAA,GAAoBN,iBAAA,CAAkBC,QAAA,EAAUI,wBAAA;EACtD,OAAOP,kCAAA,CAAmCQ,iBAAA,EAAmBJ,YAAA,EAAcC,IAAA,EAAM,OAAO;AAC1F","ignoreList":[]}

package/dist/lexical/utils/markdown/convertFromMarkdownString.spec.js

@@ -0,0 +1,88 @@
+import { createHeadlessEditor } from '@lexical/headless';
+import { LinkNode } from '@lexical/link';
+import { ListItemNode, ListNode } from '@lexical/list';
+import { $convertToMarkdownString } from '@lexical/markdown';
+import { HeadingNode, QuoteNode } from '@lexical/rich-text';
+import { $getRoot, $isElementNode, $isLineBreakNode } from 'lexical';
+import { describe, expect, it } from 'vitest';
+import { $convertFromMarkdownString } from './convertFromMarkdownString.js';
+function createEditor() {
+  return createHeadlessEditor({
+    nodes: [HeadingNode, QuoteNode, ListNode, ListItemNode, LinkNode]
+  });
+}
+// Payload's editor imports markdown with shouldMergeAdjacentLines = true, so the
+// specs exercise that path: hard line breaks must survive even when adjacent lines
+// are merged, while soft wraps collapse to a single space.
+function importMarkdown(markdown) {
+  const editor = createEditor();
+  editor.update(() => $convertFromMarkdownString(markdown, undefined, undefined, false, true), {
+    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;
+}
+function roundTrip(markdown) {
+  const editor = createEditor();
+  editor.update(() => $convertFromMarkdownString(markdown, undefined, undefined, false, true), {
+    discrete: true
+  });
+  let output = '';
+  editor.getEditorState().read(() => {
+    output = $convertToMarkdownString();
+  });
+  return output;
+}
+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);
+    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');
+  });
+});
+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=convertFromMarkdownString.spec.js.map

package/dist/lexical/utils/markdown/convertFromMarkdownString.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"convertFromMarkdownString.spec.js","names":["createHeadlessEditor","LinkNode","ListItemNode","ListNode","$convertToMarkdownString","HeadingNode","QuoteNode","$getRoot","$isElementNode","$isLineBreakNode","describe","expect","it","$convertFromMarkdownString","createEditor","nodes","importMarkdown","markdown","editor","update","undefined","discrete","result","hasLineBreak","textContent","getEditorState","read","firstChild","getFirstChild","Error","getChildren","some","child","getTextContent","roundTrip","output","join","toBe","md"],"sources":["../../../../src/lexical/utils/markdown/convertFromMarkdownString.spec.ts"],"sourcesContent":["import { createHeadlessEditor } from '@lexical/headless'\nimport { LinkNode } from '@lexical/link'\nimport { ListItemNode, ListNode } from '@lexical/list'\nimport { $convertToMarkdownString } from '@lexical/markdown'\nimport { HeadingNode, QuoteNode } from '@lexical/rich-text'\nimport { $getRoot, $isElementNode, $isLineBreakNode } from 'lexical'\nimport { describe, expect, it } from 'vitest'\n\nimport { $convertFromMarkdownString } from './convertFromMarkdownString.js'\n\nfunction createEditor() {\n  return createHeadlessEditor({\n    nodes: [HeadingNode, QuoteNode, ListNode, ListItemNode, LinkNode],\n  })\n}\n\n// Payload's editor imports markdown with shouldMergeAdjacentLines = true, so the\n// specs exercise that path: hard line breaks must survive even when adjacent lines\n// are merged, while soft wraps collapse to a single space.\nfunction importMarkdown(markdown: string): { hasLineBreak: boolean; textContent: string } {\n  const editor = createEditor()\n  editor.update(() => $convertFromMarkdownString(markdown, undefined, undefined, false, true), {\n    discrete: true,\n  })\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\nfunction roundTrip(markdown: string): string {\n  const editor = createEditor()\n  editor.update(() => $convertFromMarkdownString(markdown, undefined, undefined, false, true), {\n    discrete: true,\n  })\n  let output = ''\n  editor.getEditorState().read(() => {\n    output = $convertToMarkdownString()\n  })\n  return output\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    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\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/lexical/utils/markdown/createBlockNode.d.ts

@@ -1,4 +1,4 @@
+import type { ElementTransformer } from '@lexical/markdown';
 import type { ElementNode } from 'lexical';
-import type { ElementTransformer } from '../../../packages/@lexical/markdown/MarkdownTransformers.js';
 export declare const createBlockNode: (createNode: (match: Array<string>) => ElementNode) => ElementTransformer["replace"];
 //# sourceMappingURL=createBlockNode.d.ts.map

package/dist/lexical/utils/markdown/createBlockNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createBlockNode.d.ts","sourceRoot":"","sources":["../../../../src/lexical/utils/markdown/createBlockNode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAE1C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,6DAA6D,CAAA;AAErG,eAAO,MAAM,eAAe,eACd,CAAC,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,KAAK,WAAW,KAChD,kBAAkB,CAAC,SAAS,CAS9B,CAAA"}
+{"version":3,"file":"createBlockNode.d.ts","sourceRoot":"","sources":["../../../../src/lexical/utils/markdown/createBlockNode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AAC3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAE1C,eAAO,MAAM,eAAe,GAC1B,YAAY,CAAC,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,KAAK,WAAW,KAChD,kBAAkB,CAAC,SAAS,CAS9B,CAAA"}

package/dist/lexical/utils/markdown/createBlockNode.js.map

@@ -1 +1 @@
-{"version":3,"file":"createBlockNode.js","names":["createBlockNode","createNode","parentNode","children","match","node","append","replace","select"],"sources":["../../../../src/lexical/utils/markdown/createBlockNode.ts"],"sourcesContent":["import type { ElementNode } from 'lexical'\n\nimport type { ElementTransformer } from '../../../packages/@lexical/markdown/MarkdownTransformers.js'\n\nexport const createBlockNode = (\n  createNode: (match: Array<string>) => ElementNode,\n): ElementTransformer['replace'] => {\n  return (parentNode, children, match) => {\n    const node = createNode(match)\n    if (node) {\n      node.append(...children)\n      parentNode.replace(node)\n      node.select(0, 0)\n    }\n  }\n}\n"],"mappings":"AAIA,OAAO,MAAMA,eAAA,GACXC,UAAA;EAEA,OAAO,CAACC,UAAA,EAAYC,QAAA,EAAUC,KAAA;IAC5B,MAAMC,IAAA,GAAOJ,UAAA,CAAWG,KAAA;IACxB,IAAIC,IAAA,EAAM;MACRA,IAAA,CAAKC,MAAM,IAAIH,QAAA;MACfD,UAAA,CAAWK,OAAO,CAACF,IAAA;MACnBA,IAAA,CAAKG,MAAM,CAAC,GAAG;IACjB;EACF;AACF","ignoreList":[]}
+{"version":3,"file":"createBlockNode.js","names":["createBlockNode","createNode","parentNode","children","match","node","append","replace","select"],"sources":["../../../../src/lexical/utils/markdown/createBlockNode.ts"],"sourcesContent":["import type { ElementTransformer } from '@lexical/markdown'\nimport type { ElementNode } from 'lexical'\n\nexport const createBlockNode = (\n  createNode: (match: Array<string>) => ElementNode,\n): ElementTransformer['replace'] => {\n  return (parentNode, children, match) => {\n    const node = createNode(match)\n    if (node) {\n      node.append(...children)\n      parentNode.replace(node)\n      node.select(0, 0)\n    }\n  }\n}\n"],"mappings":"AAGA,OAAO,MAAMA,eAAA,GACXC,UAAA;EAEA,OAAO,CAACC,UAAA,EAAYC,QAAA,EAAUC,KAAA;IAC5B,MAAMC,IAAA,GAAOJ,UAAA,CAAWG,KAAA;IACxB,IAAIC,IAAA,EAAM;MACRA,IAAA,CAAKC,MAAM,IAAIH,QAAA;MACfD,UAAA,CAAWK,OAAO,CAACF,IAAA;MACnBA,IAAA,CAAKG,MAAM,CAAC,GAAG;IACjB;EACF;AACF","ignoreList":[]}

package/dist/lexical/utils/markdown/normalizeMarkdown.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Payload-specific markdown normalization, run by `$convertFromMarkdownString`
+ * before delegating the import to `@lexical/markdown`. Handles nested code
+ * fences and preserves table-row whitespace.
+ *
+ * TODO: Remove this file once https://github.com/facebook/lexical/pull/8734 is
+ * merged and we upgrade to a release that includes it. That PR fixes the nested
+ * code fence handling upstream, so `$convertFromMarkdownString` can call
+ * `@lexical/markdown` directly instead of pre-normalizing here.
+ */
+/**
+ * Represents a CommonMark hard line break marker: either a trailing backslash
+ * or two-or-more trailing spaces.
+ *
+ * See https://spec.commonmark.org/0.31.2/#hard-line-breaks
+ */
+export type MarkdownHardLineBreak = string;
+/**
+ * Detects a CommonMark hard line break marker at the end of a raw line.
+ *
+ * @returns a tuple of `[textWithoutMarker, marker]` when a marker is found, otherwise null.
+ */
+export declare function parseMarkdownHardLineBreak(line: string): [string, MarkdownHardLineBreak] | null;
+export declare function normalizeMarkdown(input: string, shouldMergeAdjacentLines: boolean): string;
+//# sourceMappingURL=normalizeMarkdown.d.ts.map

package/dist/lexical/utils/markdown/normalizeMarkdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizeMarkdown.d.ts","sourceRoot":"","sources":["../../../../src/lexical/utils/markdown/normalizeMarkdown.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAoBH;;;;;GAKG;AACH,MAAM,MAAM,qBAAqB,GAAG,MAAM,CAAA;AAE1C;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,qBAAqB,CAAC,GAAG,IAAI,CAO/F;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,wBAAwB,EAAE,OAAO,GAAG,MAAM,CAgF1F"}

package/dist/lexical/utils/markdown/normalizeMarkdown.js

@@ -0,0 +1,91 @@
+/**
+ * Payload-specific markdown normalization, run by `$convertFromMarkdownString`
+ * before delegating the import to `@lexical/markdown`. Handles nested code
+ * fences and preserves table-row whitespace.
+ *
+ * TODO: Remove this file once https://github.com/facebook/lexical/pull/8734 is
+ * merged and we upgrade to a release that includes it. That PR fixes the nested
+ * code fence handling upstream, so `$convertFromMarkdownString` can call
+ * `@lexical/markdown` directly instead of pre-normalizing here.
+ */ // These regexes are only used with `.test()` here, so their capturing groups
+// are unused in this module.
+/* eslint-disable regexp/no-unused-capturing-group */const EMPTY_OR_WHITESPACE_ONLY = /^[\t ]*$/;
+const ORDERED_LIST_REGEX = /^(\s*)(\d+)\.\s/;
+const UNORDERED_LIST_REGEX = /^(\s*)[-*+]\s/;
+const CHECK_LIST_REGEX = /^(\s*)(?:-\s)?\s?(\[(\s|x)?\])\s/i;
+const HEADING_REGEX = /^(#{1,6})\s/;
+const QUOTE_REGEX = /^>\s/;
+const CODE_START_REGEX = /^[ \t]*(\\`\\`\\`|```)(\w+)?/;
+const CODE_END_REGEX = /[ \t]*(\\`\\`\\`|```)$/;
+const CODE_SINGLE_LINE_REGEX = /^[ \t]*```[^`]+(?:(?:`{1,2}|`{4,})[^`]+)*```(?:[^`]|$)/;
+const TABLE_ROW_REG_EXP = /^\|(.+)\|\s?$/;
+const TABLE_ROW_DIVIDER_REG_EXP = /^(\| ?:?-*:? ?)+\|\s?$/;
+const TAG_START_REGEX = /^[ \t]*<[a-z_][\w-]*(?:\s[^<>]*)?\/?>/i;
+const TAG_END_REGEX = /^[ \t]*<\/[a-z_][\w-]*\s*>/i;
+/**
+ * Detects a CommonMark hard line break marker at the end of a raw line.
+ *
+ * @returns a tuple of `[textWithoutMarker, marker]` when a marker is found, otherwise null.
+ */
+export function parseMarkdownHardLineBreak(line) {
+  if (line.endsWith('\\')) {
+    return [line.slice(0, -1), '\\'];
+  }
+  const spaces = line.match(/^(.*?\S)( {2,})$/);
+  return spaces ? [spaces[1], spaces[2]] : null;
+}
+export function normalizeMarkdown(input, shouldMergeAdjacentLines) {
+  const lines = input.split('\n');
+  let inCodeBlock = false;
+  const sanitizedLines = [];
+  let nestedDeepCodeBlock = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lastLine = sanitizedLines[sanitizedLines.length - 1];
+    // A hard line break marker on the current line only matters if another line follows it.
+    const hardLineBreak = i < lines.length - 1 ? parseMarkdownHardLineBreak(line) : null;
+    const lastLineHasHardLineBreak = lastLine !== undefined && parseMarkdownHardLineBreak(lastLine) !== null;
+    // Code blocks of ```single line``` don't toggle the inCodeBlock flag
+    if (CODE_SINGLE_LINE_REGEX.test(line)) {
+      sanitizedLines.push(line);
+      continue;
+    }
+    if (CODE_END_REGEX.test(line)) {
+      if (nestedDeepCodeBlock === 0) {
+        inCodeBlock = true;
+      }
+      if (nestedDeepCodeBlock === 1) {
+        inCodeBlock = false;
+      }
+      if (nestedDeepCodeBlock > 0) {
+        nestedDeepCodeBlock--;
+      }
+      sanitizedLines.push(line);
+      continue;
+    }
+    // Toggle inCodeBlock state when encountering start or end of a code block
+    if (CODE_START_REGEX.test(line)) {
+      inCodeBlock = true;
+      nestedDeepCodeBlock++;
+      sanitizedLines.push(line);
+      continue;
+    }
+    // If we are inside a code block, keep the line unchanged
+    if (inCodeBlock) {
+      sanitizedLines.push(line);
+      continue;
+    }
+    // In markdown the concept of "empty paragraphs" does not exist.
+    // Blocks must be separated by an empty line. Non-empty adjacent lines must be merged.
+    if (EMPTY_OR_WHITESPACE_ONLY.test(line) || EMPTY_OR_WHITESPACE_ONLY.test(lastLine) || !lastLine || HEADING_REGEX.test(lastLine) || HEADING_REGEX.test(line) || QUOTE_REGEX.test(line) || ORDERED_LIST_REGEX.test(line) || UNORDERED_LIST_REGEX.test(line) || CHECK_LIST_REGEX.test(line) || TABLE_ROW_REG_EXP.test(line) || TABLE_ROW_DIVIDER_REG_EXP.test(line) ||
+    // Don't merge the next line into a line that ends with a hard line break marker.
+    lastLineHasHardLineBreak || !shouldMergeAdjacentLines || TAG_START_REGEX.test(line) || TAG_END_REGEX.test(line) || TAG_START_REGEX.test(lastLine) || TAG_END_REGEX.test(lastLine) || CODE_END_REGEX.test(lastLine)) {
+      sanitizedLines.push(line);
+    } else {
+      // Preserve a trailing hard line break marker on the merged line so it survives import.
+      sanitizedLines[sanitizedLines.length - 1] = lastLine + ' ' + (hardLineBreak === null ? line.trim() : line.trimStart());
+    }
+  }
+  return sanitizedLines.join('\n');
+}
+//# sourceMappingURL=normalizeMarkdown.js.map

package/dist/lexical/utils/markdown/normalizeMarkdown.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizeMarkdown.js","names":["EMPTY_OR_WHITESPACE_ONLY","ORDERED_LIST_REGEX","UNORDERED_LIST_REGEX","CHECK_LIST_REGEX","HEADING_REGEX","QUOTE_REGEX","CODE_START_REGEX","CODE_END_REGEX","CODE_SINGLE_LINE_REGEX","TABLE_ROW_REG_EXP","TABLE_ROW_DIVIDER_REG_EXP","TAG_START_REGEX","TAG_END_REGEX","parseMarkdownHardLineBreak","line","endsWith","slice","spaces","match","normalizeMarkdown","input","shouldMergeAdjacentLines","lines","split","inCodeBlock","sanitizedLines","nestedDeepCodeBlock","i","length","lastLine","hardLineBreak","lastLineHasHardLineBreak","undefined","test","push","trim","trimStart","join"],"sources":["../../../../src/lexical/utils/markdown/normalizeMarkdown.ts"],"sourcesContent":["/**\n * Payload-specific markdown normalization, run by `$convertFromMarkdownString`\n * before delegating the import to `@lexical/markdown`. Handles nested code\n * fences and preserves table-row whitespace.\n *\n * TODO: Remove this file once https://github.com/facebook/lexical/pull/8734 is\n * merged and we upgrade to a release that includes it. That PR fixes the nested\n * code fence handling upstream, so `$convertFromMarkdownString` can call\n * `@lexical/markdown` directly instead of pre-normalizing here.\n */\n\n// These regexes are only used with `.test()` here, so their capturing groups\n// are unused in this module.\n/* eslint-disable regexp/no-unused-capturing-group */\n\nconst EMPTY_OR_WHITESPACE_ONLY = /^[\\t ]*$/\nconst ORDERED_LIST_REGEX = /^(\\s*)(\\d+)\\.\\s/\nconst UNORDERED_LIST_REGEX = /^(\\s*)[-*+]\\s/\nconst CHECK_LIST_REGEX = /^(\\s*)(?:-\\s)?\\s?(\\[(\\s|x)?\\])\\s/i\nconst HEADING_REGEX = /^(#{1,6})\\s/\nconst QUOTE_REGEX = /^>\\s/\nconst CODE_START_REGEX = /^[ \\t]*(\\\\`\\\\`\\\\`|```)(\\w+)?/\nconst CODE_END_REGEX = /[ \\t]*(\\\\`\\\\`\\\\`|```)$/\nconst CODE_SINGLE_LINE_REGEX = /^[ \\t]*```[^`]+(?:(?:`{1,2}|`{4,})[^`]+)*```(?:[^`]|$)/\nconst TABLE_ROW_REG_EXP = /^\\|(.+)\\|\\s?$/\nconst TABLE_ROW_DIVIDER_REG_EXP = /^(\\| ?:?-*:? ?)+\\|\\s?$/\nconst TAG_START_REGEX = /^[ \\t]*<[a-z_][\\w-]*(?:\\s[^<>]*)?\\/?>/i\nconst TAG_END_REGEX = /^[ \\t]*<\\/[a-z_][\\w-]*\\s*>/i\n\n/**\n * Represents a CommonMark hard line break marker: either a trailing backslash\n * or two-or-more trailing spaces.\n *\n * See https://spec.commonmark.org/0.31.2/#hard-line-breaks\n */\nexport type MarkdownHardLineBreak = string\n\n/**\n * Detects a CommonMark hard line break marker at the end of a raw line.\n *\n * @returns a tuple of `[textWithoutMarker, marker]` when a marker is found, otherwise null.\n */\nexport function parseMarkdownHardLineBreak(line: string): [string, MarkdownHardLineBreak] | null {\n  if (line.endsWith('\\\\')) {\n    return [line.slice(0, -1), '\\\\']\n  }\n\n  const spaces = line.match(/^(.*?\\S)( {2,})$/)\n  return spaces ? [spaces[1]!, spaces[2]!] : null\n}\n\nexport function normalizeMarkdown(input: string, shouldMergeAdjacentLines: boolean): string {\n  const lines = input.split('\\n')\n  let inCodeBlock = false\n  const sanitizedLines: string[] = []\n  let nestedDeepCodeBlock = 0\n\n  for (let i = 0; i < lines.length; i++) {\n    const line = lines[i]!\n    const lastLine = sanitizedLines[sanitizedLines.length - 1]\n    // A hard line break marker on the current line only matters if another line follows it.\n    const hardLineBreak = i < lines.length - 1 ? parseMarkdownHardLineBreak(line) : null\n    const lastLineHasHardLineBreak =\n      lastLine !== undefined && parseMarkdownHardLineBreak(lastLine) !== null\n\n    // Code blocks of ```single line``` don't toggle the inCodeBlock flag\n    if (CODE_SINGLE_LINE_REGEX.test(line)) {\n      sanitizedLines.push(line)\n      continue\n    }\n\n    if (CODE_END_REGEX.test(line)) {\n      if (nestedDeepCodeBlock === 0) {\n        inCodeBlock = true\n      }\n      if (nestedDeepCodeBlock === 1) {\n        inCodeBlock = false\n      }\n      if (nestedDeepCodeBlock > 0) {\n        nestedDeepCodeBlock--\n      }\n      sanitizedLines.push(line)\n      continue\n    }\n\n    // Toggle inCodeBlock state when encountering start or end of a code block\n    if (CODE_START_REGEX.test(line)) {\n      inCodeBlock = true\n      nestedDeepCodeBlock++\n      sanitizedLines.push(line)\n      continue\n    }\n\n    // If we are inside a code block, keep the line unchanged\n    if (inCodeBlock) {\n      sanitizedLines.push(line)\n      continue\n    }\n\n    // In markdown the concept of \"empty paragraphs\" does not exist.\n    // Blocks must be separated by an empty line. Non-empty adjacent lines must be merged.\n    if (\n      EMPTY_OR_WHITESPACE_ONLY.test(line) ||\n      EMPTY_OR_WHITESPACE_ONLY.test(lastLine!) ||\n      !lastLine ||\n      HEADING_REGEX.test(lastLine) ||\n      HEADING_REGEX.test(line) ||\n      QUOTE_REGEX.test(line) ||\n      ORDERED_LIST_REGEX.test(line) ||\n      UNORDERED_LIST_REGEX.test(line) ||\n      CHECK_LIST_REGEX.test(line) ||\n      TABLE_ROW_REG_EXP.test(line) ||\n      TABLE_ROW_DIVIDER_REG_EXP.test(line) ||\n      // Don't merge the next line into a line that ends with a hard line break marker.\n      lastLineHasHardLineBreak ||\n      !shouldMergeAdjacentLines ||\n      TAG_START_REGEX.test(line) ||\n      TAG_END_REGEX.test(line) ||\n      TAG_START_REGEX.test(lastLine) ||\n      TAG_END_REGEX.test(lastLine) ||\n      CODE_END_REGEX.test(lastLine)\n    ) {\n      sanitizedLines.push(line)\n    } else {\n      // Preserve a trailing hard line break marker on the merged line so it survives import.\n      sanitizedLines[sanitizedLines.length - 1] =\n        lastLine + ' ' + (hardLineBreak === null ? line.trim() : line.trimStart())\n    }\n  }\n\n  return sanitizedLines.join('\\n')\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/lexical-proxy/@lexical-markdown.d.ts

@@ -1,2 +1,2 @@
-export * from '../packages/@lexical/markdown/index.js';
+export * from '@lexical/markdown';
 //# sourceMappingURL=@lexical-markdown.d.ts.map

package/dist/lexical-proxy/@lexical-markdown.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"@lexical-markdown.d.ts","sourceRoot":"","sources":["../../src/lexical-proxy/@lexical-markdown.ts"],"names":[],"mappings":"AAAA,cAAc,wCAAwC,CAAA"}
+{"version":3,"file":"@lexical-markdown.d.ts","sourceRoot":"","sources":["../../src/lexical-proxy/@lexical-markdown.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA"}

package/dist/lexical-proxy/@lexical-markdown.js

@@ -1,2 +1,2 @@
-export * from '../packages/@lexical/markdown/index.js';
+export * from '@lexical/markdown';
 //# sourceMappingURL=@lexical-markdown.js.map

package/dist/lexical-proxy/@lexical-markdown.js.map

@@ -1 +1 @@
-{"version":3,"file":"@lexical-markdown.js","names":[],"sources":["../../src/lexical-proxy/@lexical-markdown.ts"],"sourcesContent":["export * from '../packages/@lexical/markdown/index.js'\n"],"mappings":"AAAA,cAAc","ignoreList":[]}
+{"version":3,"file":"@lexical-markdown.js","names":[],"sources":["../../src/lexical-proxy/@lexical-markdown.ts"],"sourcesContent":["export * from '@lexical/markdown'\n"],"mappings":"AAAA,cAAc","ignoreList":[]}

package/dist/populateGraphQL/populateLexicalPopulationPromises.d.ts

@@ -1,7 +1,7 @@
 import type { SerializedEditorState } from 'lexical';
 import type { RichTextAdapter } from 'payload';
 import type { PopulationPromise } from '../features/typesServer.js';
-import type { AdapterProps } from '../types.js';
+import type { AdapterProps } from '../types/index.js';
 export type Args = {
     editorPopulationPromises: Map<string, Array<PopulationPromise>>;
     parentIsLocalized: boolean;

package/dist/populateGraphQL/populateLexicalPopulationPromises.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"populateLexicalPopulationPromises.d.ts","sourceRoot":"","sources":["../../src/populateGraphQL/populateLexicalPopulationPromises.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AACpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAE9C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAA;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAI/C,MAAM,MAAM,IAAI,GAAG;IACjB,wBAAwB,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAA;IAC/D,iBAAiB,EAAE,OAAO,CAAA;CAC3B,GAAG,UAAU,CACZ,WAAW,CAAC,eAAe,CAAC,qBAAqB,EAAE,YAAY,CAAC,CAAC,2BAA2B,CAAC,CAAC,CAC/F,CAAC,CAAC,CAAC,CAAA;AAEJ;;GAEG;AACH,eAAO,MAAM,iCAAiC,iNAgB3C,IAAI,SAoCN,CAAA"}
+{"version":3,"file":"populateLexicalPopulationPromises.d.ts","sourceRoot":"","sources":["../../src/populateGraphQL/populateLexicalPopulationPromises.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AACpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAE9C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAA;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAIrD,MAAM,MAAM,IAAI,GAAG;IACjB,wBAAwB,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAA;IAC/D,iBAAiB,EAAE,OAAO,CAAA;CAC3B,GAAG,UAAU,CACZ,WAAW,CAAC,eAAe,CAAC,qBAAqB,EAAE,YAAY,CAAC,CAAC,2BAA2B,CAAC,CAAC,CAC/F,CAAC,CAAC,CAAC,CAAA;AAEJ;;GAEG;AACH,eAAO,MAAM,iCAAiC,GAAI,8MAgB/C,IAAI,SAoCN,CAAA"}

package/dist/populateGraphQL/populateLexicalPopulationPromises.js.map

@@ -1 +1 @@
-{"version":3,"file":"populateLexicalPopulationPromises.js","names":["recurseNodes","populateLexicalPopulationPromises","context","currentDepth","depth","draft","editorPopulationPromises","field","fieldPromises","findMany","flattenLocales","overrideAccess","parentIsLocalized","populationPromises","req","showHiddenFields","siblingDoc","shouldPopulate","callback","node","editorPopulationPromisesOfNodeType","get","type","promise","nodes","name","root","children"],"sources":["../../src/populateGraphQL/populateLexicalPopulationPromises.ts"],"sourcesContent":["import type { SerializedEditorState } from 'lexical'\nimport type { RichTextAdapter } from 'payload'\n\nimport type { PopulationPromise } from '../features/typesServer.js'\nimport type { AdapterProps } from '../types.js'\n\nimport { recurseNodes } from '../utilities/forEachNodeRecursively.js'\n\nexport type Args = {\n  editorPopulationPromises: Map<string, Array<PopulationPromise>>\n  parentIsLocalized: boolean\n} & Parameters<\n  NonNullable<RichTextAdapter<SerializedEditorState, AdapterProps>['graphQLPopulationPromises']>\n>[0]\n\n/**\n * Appends all new populationPromises to the populationPromises prop\n */\nexport const populateLexicalPopulationPromises = ({\n  context,\n  currentDepth,\n  depth,\n  draft,\n  editorPopulationPromises,\n  field,\n  fieldPromises,\n  findMany,\n  flattenLocales,\n  overrideAccess,\n  parentIsLocalized,\n  populationPromises,\n  req,\n  showHiddenFields,\n  siblingDoc,\n}: Args) => {\n  const shouldPopulate = depth && currentDepth! <= depth\n\n  if (!shouldPopulate) {\n    return\n  }\n\n  recurseNodes({\n    callback: (node) => {\n      const editorPopulationPromisesOfNodeType = editorPopulationPromises?.get(node.type)\n      if (editorPopulationPromisesOfNodeType) {\n        for (const promise of editorPopulationPromisesOfNodeType) {\n          promise({\n            context,\n            currentDepth: currentDepth!,\n            depth,\n            draft,\n            editorPopulationPromises,\n            field,\n            fieldPromises,\n            findMany,\n            flattenLocales,\n            node,\n            overrideAccess: overrideAccess!,\n            parentIsLocalized,\n            populationPromises,\n            req,\n            showHiddenFields,\n            siblingDoc,\n          })\n        }\n      }\n    },\n\n    nodes: (siblingDoc[field?.name] as SerializedEditorState)?.root?.children ?? [],\n  })\n}\n"],"mappings":"AAMA,SAASA,YAAY,QAAQ;AAS7B;;;AAGA,OAAO,MAAMC,iCAAA,GAAoCA,CAAC;EAChDC,OAAO;EACPC,YAAY;EACZC,KAAK;EACLC,KAAK;EACLC,wBAAwB;EACxBC,KAAK;EACLC,aAAa;EACbC,QAAQ;EACRC,cAAc;EACdC,cAAc;EACdC,iBAAiB;EACjBC,kBAAkB;EAClBC,GAAG;EACHC,gBAAgB;EAChBC;AAAU,CACL;EACL,MAAMC,cAAA,GAAiBb,KAAA,IAASD,YAAA,IAAiBC,KAAA;EAEjD,IAAI,CAACa,cAAA,EAAgB;IACnB;EACF;EAEAjB,YAAA,CAAa;IACXkB,QAAA,EAAWC,IAAA;MACT,MAAMC,kCAAA,GAAqCd,wBAAA,EAA0Be,GAAA,CAAIF,IAAA,CAAKG,IAAI;MAClF,IAAIF,kCAAA,EAAoC;QACtC,KAAK,MAAMG,OAAA,IAAWH,kCAAA,EAAoC;UACxDG,OAAA,CAAQ;YACNrB,OAAA;YACAC,YAAA,EAAcA,YAAA;YACdC,KAAA;YACAC,KAAA;YACAC,wBAAA;YACAC,KAAA;YACAC,aAAA;YACAC,QAAA;YACAC,cAAA;YACAS,IAAA;YACAR,cAAA,EAAgBA,cAAA;YAChBC,iBAAA;YACAC,kBAAA;YACAC,GAAA;YACAC,gBAAA;YACAC;UACF;QACF;MACF;IACF;IAEAQ,KAAA,EAAOR,UAAW,CAACT,KAAA,EAAOkB,IAAA,CAAK,EAA4BC,IAAA,EAAMC,QAAA,IAAY;EAC/E;AACF","ignoreList":[]}
+{"version":3,"file":"populateLexicalPopulationPromises.js","names":["recurseNodes","populateLexicalPopulationPromises","context","currentDepth","depth","draft","editorPopulationPromises","field","fieldPromises","findMany","flattenLocales","overrideAccess","parentIsLocalized","populationPromises","req","showHiddenFields","siblingDoc","shouldPopulate","callback","node","editorPopulationPromisesOfNodeType","get","type","promise","nodes","name","root","children"],"sources":["../../src/populateGraphQL/populateLexicalPopulationPromises.ts"],"sourcesContent":["import type { SerializedEditorState } from 'lexical'\nimport type { RichTextAdapter } from 'payload'\n\nimport type { PopulationPromise } from '../features/typesServer.js'\nimport type { AdapterProps } from '../types/index.js'\n\nimport { recurseNodes } from '../utilities/forEachNodeRecursively.js'\n\nexport type Args = {\n  editorPopulationPromises: Map<string, Array<PopulationPromise>>\n  parentIsLocalized: boolean\n} & Parameters<\n  NonNullable<RichTextAdapter<SerializedEditorState, AdapterProps>['graphQLPopulationPromises']>\n>[0]\n\n/**\n * Appends all new populationPromises to the populationPromises prop\n */\nexport const populateLexicalPopulationPromises = ({\n  context,\n  currentDepth,\n  depth,\n  draft,\n  editorPopulationPromises,\n  field,\n  fieldPromises,\n  findMany,\n  flattenLocales,\n  overrideAccess,\n  parentIsLocalized,\n  populationPromises,\n  req,\n  showHiddenFields,\n  siblingDoc,\n}: Args) => {\n  const shouldPopulate = depth && currentDepth! <= depth\n\n  if (!shouldPopulate) {\n    return\n  }\n\n  recurseNodes({\n    callback: (node) => {\n      const editorPopulationPromisesOfNodeType = editorPopulationPromises?.get(node.type)\n      if (editorPopulationPromisesOfNodeType) {\n        for (const promise of editorPopulationPromisesOfNodeType) {\n          promise({\n            context,\n            currentDepth: currentDepth!,\n            depth,\n            draft,\n            editorPopulationPromises,\n            field,\n            fieldPromises,\n            findMany,\n            flattenLocales,\n            node,\n            overrideAccess: overrideAccess!,\n            parentIsLocalized,\n            populationPromises,\n            req,\n            showHiddenFields,\n            siblingDoc,\n          })\n        }\n      }\n    },\n\n    nodes: (siblingDoc[field?.name] as SerializedEditorState)?.root?.children ?? [],\n  })\n}\n"],"mappings":"AAMA,SAASA,YAAY,QAAQ;AAS7B;;;AAGA,OAAO,MAAMC,iCAAA,GAAoCA,CAAC;EAChDC,OAAO;EACPC,YAAY;EACZC,KAAK;EACLC,KAAK;EACLC,wBAAwB;EACxBC,KAAK;EACLC,aAAa;EACbC,QAAQ;EACRC,cAAc;EACdC,cAAc;EACdC,iBAAiB;EACjBC,kBAAkB;EAClBC,GAAG;EACHC,gBAAgB;EAChBC;AAAU,CACL;EACL,MAAMC,cAAA,GAAiBb,KAAA,IAASD,YAAA,IAAiBC,KAAA;EAEjD,IAAI,CAACa,cAAA,EAAgB;IACnB;EACF;EAEAjB,YAAA,CAAa;IACXkB,QAAA,EAAWC,IAAA;MACT,MAAMC,kCAAA,GAAqCd,wBAAA,EAA0Be,GAAA,CAAIF,IAAA,CAAKG,IAAI;MAClF,IAAIF,kCAAA,EAAoC;QACtC,KAAK,MAAMG,OAAA,IAAWH,kCAAA,EAAoC;UACxDG,OAAA,CAAQ;YACNrB,OAAA;YACAC,YAAA,EAAcA,YAAA;YACdC,KAAA;YACAC,KAAA;YACAC,wBAAA;YACAC,KAAA;YACAC,aAAA;YACAC,QAAA;YACAC,cAAA;YACAS,IAAA;YACAR,cAAA,EAAgBA,cAAA;YAChBC,iBAAA;YACAC,kBAAA;YACAC,GAAA;YACAC,gBAAA;YACAC;UACF;QACF;MACF;IACF;IAEAQ,KAAA,EAAOR,UAAW,CAACT,KAAA,EAAOkB,IAAA,CAAK,EAA4BC,IAAA,EAAMC,QAAA,IAAY;EAC/E;AACF","ignoreList":[]}

package/dist/populateGraphQL/recursivelyPopulateFieldsForGraphQL.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recursivelyPopulateFieldsForGraphQL.d.ts","sourceRoot":"","sources":["../../src/populateGraphQL/recursivelyPopulateFieldsForGraphQL.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAIhF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAA;AAEnE,KAAK,wBAAwB,GAAG;IAC9B,OAAO,EAAE,cAAc,CAAA;IACvB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,IAAI,EAAE,OAAO,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,OAAO,CAAA;IACd;;OAEG;IACH,wBAAwB,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAA;IAC/D;;OAEG;IACH,aAAa,EAAE,OAAO,CAAC,IAAI,CAAC,EAAE,CAAA;IAC9B,MAAM,EAAE,KAAK,EAAE,CAAA;IACf,QAAQ,EAAE,OAAO,CAAA;IACjB,cAAc,EAAE,OAAO,CAAA;IACvB,cAAc,EAAE,OAAO,CAAA;IACvB,iBAAiB,EAAE,OAAO,CAAA;IAC1B,kBAAkB,EAAE,OAAO,CAAC,IAAI,CAAC,EAAE,CAAA;IACnC,GAAG,EAAE,cAAc,CAAA;IACnB,gBAAgB,EAAE,OAAO,CAAA;IACzB,UAAU,EAAE,UAAU,CAAA;CACvB,CAAA;AAED,eAAO,MAAM,mCAAmC,8LAgB7C,wBAAwB,KAAG,IA0B7B,CAAA"}
+{"version":3,"file":"recursivelyPopulateFieldsForGraphQL.d.ts","sourceRoot":"","sources":["../../src/populateGraphQL/recursivelyPopulateFieldsForGraphQL.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAIhF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAA;AAEnE,KAAK,wBAAwB,GAAG;IAC9B,OAAO,EAAE,cAAc,CAAA;IACvB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,IAAI,EAAE,OAAO,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,OAAO,CAAA;IACd;;OAEG;IACH,wBAAwB,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAA;IAC/D;;OAEG;IACH,aAAa,EAAE,OAAO,CAAC,IAAI,CAAC,EAAE,CAAA;IAC9B,MAAM,EAAE,KAAK,EAAE,CAAA;IACf,QAAQ,EAAE,OAAO,CAAA;IACjB,cAAc,EAAE,OAAO,CAAA;IACvB,cAAc,EAAE,OAAO,CAAA;IACvB,iBAAiB,EAAE,OAAO,CAAA;IAC1B,kBAAkB,EAAE,OAAO,CAAC,IAAI,CAAC,EAAE,CAAA;IACnC,GAAG,EAAE,cAAc,CAAA;IACnB,gBAAgB,EAAE,OAAO,CAAA;IACzB,UAAU,EAAE,UAAU,CAAA;CACvB,CAAA;AAED,eAAO,MAAM,mCAAmC,GAAI,2LAgBjD,wBAAwB,KAAG,IA0B7B,CAAA"}

package/dist/types/builtInNodes.d.ts

@@ -0,0 +1,14 @@
+import type { JSONSchemaFn } from '../features/typesServer.js';
+/**
+ * Cross-cutting Lexical types shared by every element node. Inlined into
+ * `payload-types.ts`. Must stay byte-for-byte in sync with the runtime twins
+ * in `types/nodeTypes.ts` (`LexicalElementFormat`, `LexicalElementDirection`,
+ * `SerializedLexicalElementBase`) — cross-module assignability depends on it.
+ */
+export declare const CORE_LEXICAL_TYPE_STRING = "/** @internal Core Lexical types \u2014 see @payloadcms/richtext-lexical. */\nexport type LexicalElementFormat = 'left' | 'start' | 'center' | 'right' | 'end' | 'justify' | '';\nexport type LexicalElementDirection = ('ltr' | 'rtl') | null;\n\nexport interface SerializedLexicalElementBase<TChildren> {\n  children: TChildren[];\n  direction: LexicalElementDirection;\n  format: LexicalElementFormat;\n  indent: number;\n  textFormat?: number;\n  textStyle?: string;\n  version: number;\n}";
+export declare const textNodeJSONSchema: JSONSchemaFn;
+export declare const tabNodeJSONSchema: JSONSchemaFn;
+export declare const lineBreakNodeJSONSchema: JSONSchemaFn;
+export declare const paragraphNodeJSONSchema: JSONSchemaFn;
+export declare const rootNodeJSONSchema: JSONSchemaFn;
+//# sourceMappingURL=builtInNodes.d.ts.map

package/dist/types/builtInNodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtInNodes.d.ts","sourceRoot":"","sources":["../../src/types/builtInNodes.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAI9D;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,6eAYnC,CAAA;AA4DF,eAAO,MAAM,kBAAkB,EAAE,YAkBhC,CAAA;AAED,eAAO,MAAM,iBAAiB,EAAE,YAoB/B,CAAA;AAED,eAAO,MAAM,uBAAuB,EAAE,YAYrC,CAAA;AAED,eAAO,MAAM,uBAAuB,EAAE,YAerC,CAAA;AAeD,eAAO,MAAM,kBAAkB,EAAE,YAoBhC,CAAA"}