@payloadcms/richtext-lexical 3.0.0-canary.fb81f02 → 3.0.0

package/dist/features/blocks/client/markdownTransformer.js

@@ -0,0 +1,144 @@
+import { createHeadlessEditor } from '@lexical/headless';
+import { $convertFromMarkdownString, $convertToMarkdownString } from '@lexical/markdown';
+import { extractPropsFromJSXPropsString } from '../../../utilities/jsx/extractPropsFromJSXPropsString.js';
+import { propsToJSXString } from '../../../utilities/jsx/jsx.js';
+import { $createBlockNode, $isBlockNode, BlockNode } from './nodes/BlocksNode.js';
+function createTagRegexes(tagName) {
+  const escapedTagName = tagName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return {
+    regExpEnd: new RegExp(`</(${escapedTagName})\\s*>|<${escapedTagName}[^>]*?/>`, 'i'),
+    regExpStart: new RegExp(`<(${escapedTagName})([^>]*?)\\s*(/?)>`, 'i')
+  };
+}
+export const getBlockMarkdownTransformers = ({
+  blocks
+}) => {
+  if (!blocks?.length) {
+    return [];
+  }
+  const transformers = [];
+  for (const block of blocks) {
+    if (!block.jsx) {
+      continue;
+    }
+    const regex = createTagRegexes(block.slug);
+    transformers.push(({
+      allNodes,
+      allTransformers
+    }) => ({
+      type: 'multiline-element',
+      dependencies: [BlockNode],
+      export: node => {
+        if (!$isBlockNode(node)) {
+          return null;
+        }
+        if (node.getFields()?.blockType?.toLowerCase() !== block.slug.toLowerCase()) {
+          return null;
+        }
+        const nodeFields = node.getFields();
+        const lexicalToMarkdown = getLexicalToMarkdown(allNodes, allTransformers);
+        const exportResult = block.jsx.export({
+          fields: nodeFields,
+          lexicalToMarkdown
+        });
+        if (exportResult === false) {
+          return null;
+        }
+        if (typeof exportResult === 'string') {
+          return exportResult;
+        }
+        if (exportResult?.children?.length) {
+          return `<${nodeFields.blockType}${exportResult.props ? ' ' + propsToJSXString({
+            props: exportResult.props
+          }) : ''}>\n  ${exportResult.children}\n</${nodeFields.blockType}>`;
+        }
+        return `<${nodeFields.blockType}${exportResult.props ? ' ' + propsToJSXString({
+          props: exportResult.props
+        }) : ''}/>`;
+      },
+      regExpEnd: block.jsx?.customEndRegex ?? regex.regExpEnd,
+      regExpStart: block.jsx?.customStartRegex ?? regex.regExpStart,
+      replace: (rootNode, children, openMatch, closeMatch, linesInBetween) => {
+        if (block?.jsx?.import) {
+          if (!linesInBetween) {
+            // convert children to linesInBetween
+            let line = '';
+            if (children) {
+              for (const child of children) {
+                line += child.getTextContent();
+              }
+            }
+            linesInBetween = [line];
+          }
+          const childrenString = linesInBetween.join('\n').trim();
+          const propsString = openMatch?.length > 2 ? openMatch[2]?.trim() : null;
+          const markdownToLexical = getMarkdownToLexical(allNodes, allTransformers);
+          const blockFields = block.jsx.import({
+            children: childrenString,
+            closeMatch: closeMatch,
+            htmlToLexical: null,
+            markdownToLexical,
+            openMatch: openMatch,
+            props: propsString ? extractPropsFromJSXPropsString({
+              propsString
+            }) : {}
+          });
+          if (blockFields === false) {
+            return false;
+          }
+          const node = $createBlockNode({
+            blockType: block.slug,
+            ...blockFields,
+            blockName: blockFields.blockName || ''
+          });
+          if (node) {
+            rootNode.append(node);
+          }
+          return;
+        }
+        return false // Run next transformer
+        ;
+      }
+    }));
+  }
+  return transformers;
+};
+export function getMarkdownToLexical(allNodes, allTransformers) {
+  const markdownToLexical = ({
+    markdown
+  }) => {
+    const headlessEditor = createHeadlessEditor({
+      nodes: allNodes
+    });
+    headlessEditor.update(() => {
+      $convertFromMarkdownString(markdown, allTransformers);
+    }, {
+      discrete: true
+    });
+    const editorJSON = headlessEditor.getEditorState().toJSON();
+    return editorJSON;
+  };
+  return markdownToLexical;
+}
+export function getLexicalToMarkdown(allNodes, allTransformers) {
+  const lexicalToMarkdown = ({
+    editorState
+  }) => {
+    const headlessEditor = createHeadlessEditor({
+      nodes: allNodes
+    });
+    try {
+      headlessEditor.setEditorState(headlessEditor.parseEditorState(editorState)) // This should commit the editor state immediately
+      ;
+    } catch (e) {
+      console.error('getLexicalToMarkdown: ERROR parsing editor state', e);
+    }
+    let markdown = '';
+    headlessEditor.getEditorState().read(() => {
+      markdown = $convertToMarkdownString(allTransformers);
+    });
+    return markdown;
+  };
+  return lexicalToMarkdown;
+}
+//# sourceMappingURL=markdownTransformer.js.map

package/dist/features/blocks/client/markdownTransformer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdownTransformer.js","names":["createHeadlessEditor","$convertFromMarkdownString","$convertToMarkdownString","extractPropsFromJSXPropsString","propsToJSXString","$createBlockNode","$isBlockNode","BlockNode","createTagRegexes","tagName","escapedTagName","replace","regExpEnd","RegExp","regExpStart","getBlockMarkdownTransformers","blocks","length","transformers","block","jsx","regex","slug","push","allNodes","allTransformers","type","dependencies","export","node","getFields","blockType","toLowerCase","nodeFields","lexicalToMarkdown","getLexicalToMarkdown","exportResult","fields","children","props","customEndRegex","customStartRegex","rootNode","openMatch","closeMatch","linesInBetween","import","line","child","getTextContent","childrenString","join","trim","propsString","markdownToLexical","getMarkdownToLexical","blockFields","htmlToLexical","blockName","append","markdown","headlessEditor","nodes","update","discrete","editorJSON","getEditorState","toJSON","editorState","setEditorState","parseEditorState","e","console","error","read"],"sources":["../../../../src/features/blocks/client/markdownTransformer.ts"],"sourcesContent":["import type { MultilineElementTransformer, Transformer } from '@lexical/markdown'\nimport type { Klass, LexicalNode, LexicalNodeReplacement, SerializedEditorState } from 'lexical'\nimport type { ClientBlock } from 'payload'\n\nimport { createHeadlessEditor } from '@lexical/headless'\nimport { $convertFromMarkdownString, $convertToMarkdownString } from '@lexical/markdown'\n\nimport { extractPropsFromJSXPropsString } from '../../../utilities/jsx/extractPropsFromJSXPropsString.js'\nimport { propsToJSXString } from '../../../utilities/jsx/jsx.js'\nimport { $createBlockNode, $isBlockNode, BlockNode } from './nodes/BlocksNode.js'\n\nfunction createTagRegexes(tagName: string) {\n  const escapedTagName = tagName.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')\n  return {\n    regExpEnd: new RegExp(`</(${escapedTagName})\\\\s*>|<${escapedTagName}[^>]*?/>`, 'i'),\n    regExpStart: new RegExp(`<(${escapedTagName})([^>]*?)\\\\s*(/?)>`, 'i'),\n  }\n}\nexport const getBlockMarkdownTransformers = ({\n  blocks,\n}: {\n  blocks: ClientBlock[]\n}): ((props: {\n  allNodes: Array<Klass<LexicalNode> | LexicalNodeReplacement>\n  allTransformers: Transformer[]\n}) => MultilineElementTransformer)[] => {\n  if (!blocks?.length) {\n    return []\n  }\n\n  const transformers: ((props: {\n    allNodes: Array<Klass<LexicalNode> | LexicalNodeReplacement>\n    allTransformers: Transformer[]\n  }) => MultilineElementTransformer)[] = []\n\n  for (const block of blocks) {\n    if (!block.jsx) {\n      continue\n    }\n    const regex = createTagRegexes(block.slug)\n    transformers.push(({ allNodes, allTransformers }) => ({\n      type: 'multiline-element',\n      dependencies: [BlockNode],\n      export: (node) => {\n        if (!$isBlockNode(node)) {\n          return null\n        }\n        if (node.getFields()?.blockType?.toLowerCase() !== block.slug.toLowerCase()) {\n          return null\n        }\n\n        const nodeFields = node.getFields()\n        const lexicalToMarkdown = getLexicalToMarkdown(allNodes, allTransformers)\n\n        const exportResult = block.jsx!.export({\n          fields: nodeFields,\n          lexicalToMarkdown,\n        })\n        if (exportResult === false) {\n          return null\n        }\n        if (typeof exportResult === 'string') {\n          return exportResult\n        }\n\n        if (exportResult?.children?.length) {\n          return `<${nodeFields.blockType}${exportResult.props ? ' ' + propsToJSXString({ props: exportResult.props }) : ''}>\\n  ${exportResult.children}\\n</${nodeFields.blockType}>`\n        }\n\n        return `<${nodeFields.blockType}${exportResult.props ? ' ' + propsToJSXString({ props: exportResult.props }) : ''}/>`\n      },\n      regExpEnd: block.jsx?.customEndRegex ?? regex.regExpEnd,\n      regExpStart: block.jsx?.customStartRegex ?? regex.regExpStart,\n      replace: (rootNode, children, openMatch, closeMatch, linesInBetween) => {\n        if (block?.jsx?.import) {\n          if (!linesInBetween) {\n            // convert children to linesInBetween\n            let line = ''\n            if (children) {\n              for (const child of children) {\n                line += child.getTextContent()\n              }\n            }\n\n            linesInBetween = [line]\n          }\n\n          const childrenString = linesInBetween.join('\\n').trim()\n\n          const propsString: null | string = openMatch?.length > 2 ? openMatch[2]?.trim() : null\n\n          const markdownToLexical = getMarkdownToLexical(allNodes, allTransformers)\n\n          const blockFields = block.jsx.import({\n            children: childrenString,\n            closeMatch: closeMatch as RegExpMatchArray,\n            htmlToLexical: null, // TODO\n            markdownToLexical,\n            openMatch: openMatch as RegExpMatchArray,\n            props: propsString\n              ? extractPropsFromJSXPropsString({\n                  propsString,\n                })\n              : {},\n          })\n          if (blockFields === false) {\n            return false\n          }\n\n          const node = $createBlockNode({\n            blockType: block.slug,\n            ...blockFields,\n            blockName: blockFields.blockName || '',\n          })\n          if (node) {\n            rootNode.append(node)\n          }\n\n          return\n        }\n        return false // Run next transformer\n      },\n    }))\n  }\n\n  return transformers\n}\n\nexport function getMarkdownToLexical(\n  allNodes: Array<Klass<LexicalNode> | LexicalNodeReplacement>,\n  allTransformers: Transformer[],\n): (args: { markdown: string }) => SerializedEditorState {\n  const markdownToLexical = ({ markdown }: { markdown: string }): SerializedEditorState => {\n    const headlessEditor = createHeadlessEditor({\n      nodes: allNodes,\n    })\n\n    headlessEditor.update(\n      () => {\n        $convertFromMarkdownString(markdown, allTransformers)\n      },\n      { discrete: true },\n    )\n\n    const editorJSON = headlessEditor.getEditorState().toJSON()\n\n    return editorJSON\n  }\n  return markdownToLexical\n}\n\nexport function getLexicalToMarkdown(\n  allNodes: Array<Klass<LexicalNode> | LexicalNodeReplacement>,\n  allTransformers: Transformer[],\n): (args: { editorState: Record<string, any> }) => string {\n  const lexicalToMarkdown = ({ editorState }: { editorState: Record<string, any> }): string => {\n    const headlessEditor = createHeadlessEditor({\n      nodes: allNodes,\n    })\n\n    try {\n      headlessEditor.setEditorState(headlessEditor.parseEditorState(editorState as any)) // This should commit the editor state immediately\n    } catch (e) {\n      console.error('getLexicalToMarkdown: ERROR parsing editor state', e)\n    }\n\n    let markdown: string = ''\n    headlessEditor.getEditorState().read(() => {\n      markdown = $convertToMarkdownString(allTransformers)\n    })\n\n    return markdown\n  }\n  return lexicalToMarkdown\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/features/blocks/client/nodes/BlocksNode.d.ts

@@ -0,0 +1,14 @@
+import type { EditorConfig, LexicalEditor, LexicalNode } from 'lexical';
+import { type JSX } from 'react';
+import type { BlockFieldsOptionalID, SerializedBlockNode } from '../../server/nodes/BlocksNode.js';
+import { ServerBlockNode } from '../../server/nodes/BlocksNode.js';
+export declare class BlockNode extends ServerBlockNode {
+    static clone(node: ServerBlockNode): ServerBlockNode;
+    static getType(): string;
+    static importJSON(serializedNode: SerializedBlockNode): BlockNode;
+    decorate(editor: LexicalEditor, config: EditorConfig): JSX.Element;
+    exportJSON(): SerializedBlockNode;
+}
+export declare function $createBlockNode(fields: BlockFieldsOptionalID): BlockNode;
+export declare function $isBlockNode(node: BlockNode | LexicalNode | null | undefined): node is BlockNode;
+//# sourceMappingURL=BlocksNode.d.ts.map

package/dist/features/blocks/client/nodes/BlocksNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlocksNode.d.ts","sourceRoot":"","sources":["../../../../../src/features/blocks/client/nodes/BlocksNode.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAGvE,OAAc,EAAE,KAAK,GAAG,EAAE,MAAM,OAAO,CAAA;AAEvC,OAAO,KAAK,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAA;AAElG,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAA;AAGlE,qBAAa,SAAU,SAAQ,eAAe;IAC5C,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,eAAe,GAAG,eAAe;IAIpD,MAAM,CAAC,OAAO,IAAI,MAAM;IAIxB,MAAM,CAAC,UAAU,CAAC,cAAc,EAAE,mBAAmB,GAAG,SAAS;IAgBjE,QAAQ,CAAC,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,YAAY,GAAG,GAAG,CAAC,OAAO;IAIlE,UAAU,IAAI,mBAAmB;CAGlC;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,qBAAqB,GAAG,SAAS,CAOzE;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,SAAS,GAAG,WAAW,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,IAAI,SAAS,CAEhG"}

package/dist/features/blocks/client/nodes/BlocksNode.js

@@ -0,0 +1,51 @@
+'use client';
+
+import { jsx as _jsx } from "react/jsx-runtime";
+import ObjectID from 'bson-objectid';
+import React from 'react';
+import { ServerBlockNode } from '../../server/nodes/BlocksNode.js';
+import { BlockComponent } from '../component/index.js';
+export class BlockNode extends ServerBlockNode {
+  static clone(node) {
+    return super.clone(node);
+  }
+  static getType() {
+    return super.getType();
+  }
+  static importJSON(serializedNode) {
+    if (serializedNode.version === 1) {
+      // Convert (version 1 had the fields wrapped in another, unnecessary data property)
+      serializedNode = {
+        ...serializedNode,
+        fields: {
+          ...serializedNode.fields.data
+        },
+        version: 2
+      };
+    }
+    const node = $createBlockNode(serializedNode.fields);
+    node.setFormat(serializedNode.format);
+    return node;
+  }
+  decorate(editor, config) {
+    return /*#__PURE__*/_jsx(BlockComponent, {
+      formData: this.getFields(),
+      nodeKey: this.getKey()
+    });
+  }
+  exportJSON() {
+    return super.exportJSON();
+  }
+}
+export function $createBlockNode(fields) {
+  return new BlockNode({
+    fields: {
+      ...fields,
+      id: fields?.id || new ObjectID.default().toHexString()
+    }
+  });
+}
+export function $isBlockNode(node) {
+  return node instanceof BlockNode;
+}
+//# sourceMappingURL=BlocksNode.js.map

package/dist/features/blocks/client/nodes/BlocksNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlocksNode.js","names":["ObjectID","React","ServerBlockNode","BlockComponent","BlockNode","clone","node","getType","importJSON","serializedNode","version","fields","data","$createBlockNode","setFormat","format","decorate","editor","config","_jsx","formData","getFields","nodeKey","getKey","exportJSON","id","default","toHexString","$isBlockNode"],"sources":["../../../../../src/features/blocks/client/nodes/BlocksNode.tsx"],"sourcesContent":["'use client'\nimport type { EditorConfig, LexicalEditor, LexicalNode } from 'lexical'\n\nimport ObjectID from 'bson-objectid'\nimport React, { type JSX } from 'react'\n\nimport type { BlockFieldsOptionalID, SerializedBlockNode } from '../../server/nodes/BlocksNode.js'\n\nimport { ServerBlockNode } from '../../server/nodes/BlocksNode.js'\nimport { BlockComponent } from '../component/index.js'\n\nexport class BlockNode extends ServerBlockNode {\n  static clone(node: ServerBlockNode): ServerBlockNode {\n    return super.clone(node)\n  }\n\n  static getType(): string {\n    return super.getType()\n  }\n\n  static importJSON(serializedNode: SerializedBlockNode): BlockNode {\n    if (serializedNode.version === 1) {\n      // Convert (version 1 had the fields wrapped in another, unnecessary data property)\n      serializedNode = {\n        ...serializedNode,\n        fields: {\n          ...(serializedNode as any).fields.data,\n        },\n        version: 2,\n      }\n    }\n    const node = $createBlockNode(serializedNode.fields)\n    node.setFormat(serializedNode.format)\n    return node\n  }\n\n  decorate(editor: LexicalEditor, config: EditorConfig): JSX.Element {\n    return <BlockComponent formData={this.getFields()} nodeKey={this.getKey()} />\n  }\n\n  exportJSON(): SerializedBlockNode {\n    return super.exportJSON()\n  }\n}\n\nexport function $createBlockNode(fields: BlockFieldsOptionalID): BlockNode {\n  return new BlockNode({\n    fields: {\n      ...fields,\n      id: fields?.id || new ObjectID.default().toHexString(),\n    },\n  })\n}\n\nexport function $isBlockNode(node: BlockNode | LexicalNode | null | undefined): node is BlockNode {\n  return node instanceof BlockNode\n}\n"],"mappings":"AAAA;;;AAGA,OAAOA,QAAA,MAAc;AACrB,OAAOC,KAAA,MAAyB;AAIhC,SAASC,eAAe,QAAQ;AAChC,SAASC,cAAc,QAAQ;AAE/B,OAAO,MAAMC,SAAA,SAAkBF,eAAA;EAC7B,OAAOG,MAAMC,IAAqB,EAAmB;IACnD,OAAO,KAAK,CAACD,KAAA,CAAMC,IAAA;EACrB;EAEA,OAAOC,QAAA,EAAkB;IACvB,OAAO,KAAK,CAACA,OAAA;EACf;EAEA,OAAOC,WAAWC,cAAmC,EAAa;IAChE,IAAIA,cAAA,CAAeC,OAAO,KAAK,GAAG;MAChC;MACAD,cAAA,GAAiB;QACf,GAAGA,cAAc;QACjBE,MAAA,EAAQ;UACN,GAAGF,cAAC,CAAuBE,MAAM,CAACC;QACpC;QACAF,OAAA,EAAS;MACX;IACF;IACA,MAAMJ,IAAA,GAAOO,gBAAA,CAAiBJ,cAAA,CAAeE,MAAM;IACnDL,IAAA,CAAKQ,SAAS,CAACL,cAAA,CAAeM,MAAM;IACpC,OAAOT,IAAA;EACT;EAEAU,SAASC,MAAqB,EAAEC,MAAoB,EAAe;IACjE,oBAAOC,IAAA,CAAChB,cAAA;MAAeiB,QAAA,EAAU,IAAI,CAACC,SAAS;MAAIC,OAAA,EAAS,IAAI,CAACC,MAAM;;EACzE;EAEAC,WAAA,EAAkC;IAChC,OAAO,KAAK,CAACA,UAAA;EACf;AACF;AAEA,OAAO,SAASX,iBAAiBF,MAA6B;EAC5D,OAAO,IAAIP,SAAA,CAAU;IACnBO,MAAA,EAAQ;MACN,GAAGA,MAAM;MACTc,EAAA,EAAId,MAAA,EAAQc,EAAA,IAAM,IAAIzB,QAAA,CAAS0B,OAAO,GAAGC,WAAW;IACtD;EACF;AACF;AAEA,OAAO,SAASC,aAAatB,IAAgD;EAC3E,OAAOA,IAAA,YAAgBF,SAAA;AACzB","ignoreList":[]}

package/dist/features/blocks/client/nodes/InlineBlocksNode.d.ts

@@ -0,0 +1,25 @@
+import type { EditorConfig, LexicalEditor, LexicalNode, SerializedLexicalNode, Spread } from 'lexical';
+import { type JSX } from 'react';
+import type { SerializedServerInlineBlockNode } from '../../server/nodes/InlineBlocksNode.js';
+import { ServerInlineBlockNode } from '../../server/nodes/InlineBlocksNode.js';
+export type InlineBlockFields = {
+    /** Block form data */
+    [key: string]: any;
+    blockType: string;
+    id: string;
+};
+export type SerializedInlineBlockNode = Spread<{
+    children?: never;
+    fields: InlineBlockFields;
+    type: 'inlineBlock';
+}, SerializedLexicalNode>;
+export declare class InlineBlockNode extends ServerInlineBlockNode {
+    static clone(node: ServerInlineBlockNode): ServerInlineBlockNode;
+    static getType(): string;
+    static importJSON(serializedNode: SerializedInlineBlockNode): InlineBlockNode;
+    decorate(editor: LexicalEditor, config: EditorConfig): JSX.Element;
+    exportJSON(): SerializedServerInlineBlockNode;
+}
+export declare function $createInlineBlockNode(fields: Exclude<InlineBlockFields, 'id'>): InlineBlockNode;
+export declare function $isInlineBlockNode(node: InlineBlockNode | LexicalNode | null | undefined): node is InlineBlockNode;
+//# sourceMappingURL=InlineBlocksNode.d.ts.map

package/dist/features/blocks/client/nodes/InlineBlocksNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InlineBlocksNode.d.ts","sourceRoot":"","sources":["../../../../../src/features/blocks/client/nodes/InlineBlocksNode.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,YAAY,EACZ,aAAa,EACb,WAAW,EACX,qBAAqB,EACrB,MAAM,EACP,MAAM,SAAS,CAAA;AAGhB,OAAc,EAAE,KAAK,GAAG,EAAE,MAAM,OAAO,CAAA;AAEvC,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,wCAAwC,CAAA;AAE7F,OAAO,EAAE,qBAAqB,EAAE,MAAM,wCAAwC,CAAA;AAE9E,MAAM,MAAM,iBAAiB,GAAG;IAC9B,sBAAsB;IACtB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;IAElB,SAAS,EAAE,MAAM,CAAA;IACjB,EAAE,EAAE,MAAM,CAAA;CACX,CAAA;AAQD,MAAM,MAAM,yBAAyB,GAAG,MAAM,CAC5C;IACE,QAAQ,CAAC,EAAE,KAAK,CAAA;IAChB,MAAM,EAAE,iBAAiB,CAAA;IACzB,IAAI,EAAE,aAAa,CAAA;CACpB,EACD,qBAAqB,CACtB,CAAA;AAED,qBAAa,eAAgB,SAAQ,qBAAqB;IACxD,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,qBAAqB,GAAG,qBAAqB;IAIhE,MAAM,CAAC,OAAO,IAAI,MAAM;IAIxB,MAAM,CAAC,UAAU,CAAC,cAAc,EAAE,yBAAyB,GAAG,eAAe;IAK7E,QAAQ,CAAC,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,YAAY,GAAG,GAAG,CAAC,OAAO;IAIlE,UAAU,IAAI,+BAA+B;CAG9C;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,OAAO,CAAC,iBAAiB,EAAE,IAAI,CAAC,GAAG,eAAe,CAOhG;AAED,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,eAAe,GAAG,WAAW,GAAG,IAAI,GAAG,SAAS,GACrD,IAAI,IAAI,eAAe,CAEzB"}

package/dist/features/blocks/client/nodes/InlineBlocksNode.js

@@ -0,0 +1,42 @@
+'use client';
+
+import { jsx as _jsx } from "react/jsx-runtime";
+import ObjectID from 'bson-objectid';
+import React from 'react';
+import { ServerInlineBlockNode } from '../../server/nodes/InlineBlocksNode.js';
+const InlineBlockComponent = /*#__PURE__*/React.lazy(() => import('../componentInline/index.js').then(module => ({
+  default: module.InlineBlockComponent
+})));
+export class InlineBlockNode extends ServerInlineBlockNode {
+  static clone(node) {
+    return super.clone(node);
+  }
+  static getType() {
+    return super.getType();
+  }
+  static importJSON(serializedNode) {
+    const node = $createInlineBlockNode(serializedNode.fields);
+    return node;
+  }
+  decorate(editor, config) {
+    return /*#__PURE__*/_jsx(InlineBlockComponent, {
+      formData: this.getFields(),
+      nodeKey: this.getKey()
+    });
+  }
+  exportJSON() {
+    return super.exportJSON();
+  }
+}
+export function $createInlineBlockNode(fields) {
+  return new InlineBlockNode({
+    fields: {
+      ...fields,
+      id: fields?.id || new ObjectID.default().toHexString()
+    }
+  });
+}
+export function $isInlineBlockNode(node) {
+  return node instanceof InlineBlockNode;
+}
+//# sourceMappingURL=InlineBlocksNode.js.map

package/dist/features/blocks/client/nodes/InlineBlocksNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InlineBlocksNode.js","names":["ObjectID","React","ServerInlineBlockNode","InlineBlockComponent","lazy","then","module","default","InlineBlockNode","clone","node","getType","importJSON","serializedNode","$createInlineBlockNode","fields","decorate","editor","config","_jsx","formData","getFields","nodeKey","getKey","exportJSON","id","toHexString","$isInlineBlockNode"],"sources":["../../../../../src/features/blocks/client/nodes/InlineBlocksNode.tsx"],"sourcesContent":["'use client'\nimport type {\n  EditorConfig,\n  LexicalEditor,\n  LexicalNode,\n  SerializedLexicalNode,\n  Spread,\n} from 'lexical'\n\nimport ObjectID from 'bson-objectid'\nimport React, { type JSX } from 'react'\n\nimport type { SerializedServerInlineBlockNode } from '../../server/nodes/InlineBlocksNode.js'\n\nimport { ServerInlineBlockNode } from '../../server/nodes/InlineBlocksNode.js'\n\nexport type InlineBlockFields = {\n  /** Block form data */\n  [key: string]: any\n  //blockName: string\n  blockType: string\n  id: string\n}\n\nconst InlineBlockComponent = React.lazy(() =>\n  import('../componentInline/index.js').then((module) => ({\n    default: module.InlineBlockComponent,\n  })),\n)\n\nexport type SerializedInlineBlockNode = Spread<\n  {\n    children?: never // required so that our typed editor state doesn't automatically add children\n    fields: InlineBlockFields\n    type: 'inlineBlock'\n  },\n  SerializedLexicalNode\n>\n\nexport class InlineBlockNode extends ServerInlineBlockNode {\n  static clone(node: ServerInlineBlockNode): ServerInlineBlockNode {\n    return super.clone(node)\n  }\n\n  static getType(): string {\n    return super.getType()\n  }\n\n  static importJSON(serializedNode: SerializedInlineBlockNode): InlineBlockNode {\n    const node = $createInlineBlockNode(serializedNode.fields)\n    return node\n  }\n\n  decorate(editor: LexicalEditor, config: EditorConfig): JSX.Element {\n    return <InlineBlockComponent formData={this.getFields()} nodeKey={this.getKey()} />\n  }\n\n  exportJSON(): SerializedServerInlineBlockNode {\n    return super.exportJSON()\n  }\n}\n\nexport function $createInlineBlockNode(fields: Exclude<InlineBlockFields, 'id'>): InlineBlockNode {\n  return new InlineBlockNode({\n    fields: {\n      ...fields,\n      id: fields?.id || new ObjectID.default().toHexString(),\n    },\n  })\n}\n\nexport function $isInlineBlockNode(\n  node: InlineBlockNode | LexicalNode | null | undefined,\n): node is InlineBlockNode {\n  return node instanceof InlineBlockNode\n}\n"],"mappings":"AAAA;;;AASA,OAAOA,QAAA,MAAc;AACrB,OAAOC,KAAA,MAAyB;AAIhC,SAASC,qBAAqB,QAAQ;AAUtC,MAAMC,oBAAA,gBAAuBF,KAAA,CAAMG,IAAI,CAAC,MACtC,MAAM,CAAC,+BAA+BC,IAAI,CAAEC,MAAA,KAAY;EACtDC,OAAA,EAASD,MAAA,CAAOH;AAClB;AAYF,OAAO,MAAMK,eAAA,SAAwBN,qBAAA;EACnC,OAAOO,MAAMC,IAA2B,EAAyB;IAC/D,OAAO,KAAK,CAACD,KAAA,CAAMC,IAAA;EACrB;EAEA,OAAOC,QAAA,EAAkB;IACvB,OAAO,KAAK,CAACA,OAAA;EACf;EAEA,OAAOC,WAAWC,cAAyC,EAAmB;IAC5E,MAAMH,IAAA,GAAOI,sBAAA,CAAuBD,cAAA,CAAeE,MAAM;IACzD,OAAOL,IAAA;EACT;EAEAM,SAASC,MAAqB,EAAEC,MAAoB,EAAe;IACjE,oBAAOC,IAAA,CAAChB,oBAAA;MAAqBiB,QAAA,EAAU,IAAI,CAACC,SAAS;MAAIC,OAAA,EAAS,IAAI,CAACC,MAAM;;EAC/E;EAEAC,WAAA,EAA8C;IAC5C,OAAO,KAAK,CAACA,UAAA;EACf;AACF;AAEA,OAAO,SAASV,uBAAuBC,MAAwC;EAC7E,OAAO,IAAIP,eAAA,CAAgB;IACzBO,MAAA,EAAQ;MACN,GAAGA,MAAM;MACTU,EAAA,EAAIV,MAAA,EAAQU,EAAA,IAAM,IAAIzB,QAAA,CAASO,OAAO,GAAGmB,WAAW;IACtD;EACF;AACF;AAEA,OAAO,SAASC,mBACdjB,IAAsD;EAEtD,OAAOA,IAAA,YAAgBF,eAAA;AACzB","ignoreList":[]}

package/dist/features/blocks/client/plugin/commands.d.ts

@@ -0,0 +1,5 @@
+import type { LexicalCommand } from 'lexical';
+import type { InsertBlockPayload } from './index.js';
+export declare const INSERT_BLOCK_COMMAND: LexicalCommand<InsertBlockPayload>;
+export declare const INSERT_INLINE_BLOCK_COMMAND: LexicalCommand<Partial<InsertBlockPayload>>;
+//# sourceMappingURL=commands.d.ts.map

package/dist/features/blocks/client/plugin/commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../../../../../src/features/blocks/client/plugin/commands.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAI7C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAEpD,eAAO,MAAM,oBAAoB,EAAE,cAAc,CAAC,kBAAkB,CAC7B,CAAA;AAEvC,eAAO,MAAM,2BAA2B,EAAE,cAAc,CAAC,OAAO,CAAC,kBAAkB,CAAC,CACtC,CAAA"}

package/dist/features/blocks/client/plugin/commands.js

@@ -0,0 +1,6 @@
+'use client';
+
+import { createCommand } from 'lexical';
+export const INSERT_BLOCK_COMMAND = createCommand('INSERT_BLOCK_COMMAND');
+export const INSERT_INLINE_BLOCK_COMMAND = createCommand('INSERT_INLINE_BLOCK_COMMAND');
+//# sourceMappingURL=commands.js.map

package/dist/features/blocks/client/plugin/commands.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"commands.js","names":["createCommand","INSERT_BLOCK_COMMAND","INSERT_INLINE_BLOCK_COMMAND"],"sources":["../../../../../src/features/blocks/client/plugin/commands.ts"],"sourcesContent":["'use client'\nimport type { LexicalCommand } from 'lexical'\n\nimport { createCommand } from 'lexical'\n\nimport type { InsertBlockPayload } from './index.js'\n\nexport const INSERT_BLOCK_COMMAND: LexicalCommand<InsertBlockPayload> =\n  createCommand('INSERT_BLOCK_COMMAND')\n\nexport const INSERT_INLINE_BLOCK_COMMAND: LexicalCommand<Partial<InsertBlockPayload>> =\n  createCommand('INSERT_INLINE_BLOCK_COMMAND')\n"],"mappings":"AAAA;;AAGA,SAASA,aAAa,QAAQ;AAI9B,OAAO,MAAMC,oBAAA,GACXD,aAAA,CAAc;AAEhB,OAAO,MAAME,2BAAA,GACXF,aAAA,CAAc","ignoreList":[]}

package/dist/features/blocks/client/plugin/index.d.ts

@@ -0,0 +1,5 @@
+import type { PluginComponent } from '../../../typesClient.js';
+import type { BlockFieldsOptionalID } from '../../server/nodes/BlocksNode.js';
+export type InsertBlockPayload = BlockFieldsOptionalID;
+export declare const BlocksPlugin: PluginComponent;
+//# sourceMappingURL=index.d.ts.map

package/dist/features/blocks/client/plugin/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/blocks/client/plugin/index.tsx"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAA;AAC9D,OAAO,KAAK,EAAe,qBAAqB,EAAE,MAAM,kCAAkC,CAAA;AAQ1F,MAAM,MAAM,kBAAkB,GAAG,qBAAqB,CAAA;AAEtD,eAAO,MAAM,YAAY,EAAE,eAoF1B,CAAA"}

package/dist/features/blocks/client/plugin/index.js

@@ -0,0 +1,98 @@
+'use client';
+
+import { c as _c } from "react/compiler-runtime";
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext.js';
+import { $insertNodeToNearestRoot, $wrapNodeInElement, mergeRegister } from '@lexical/utils';
+import { formatDrawerSlug, useEditDepth } from '@payloadcms/ui';
+import { $createParagraphNode, $getNodeByKey, $getPreviousSelection, $getSelection, $insertNodes, $isParagraphNode, $isRangeSelection, $isRootOrShadowRoot, COMMAND_PRIORITY_EDITOR } from 'lexical';
+import { useEffect, useState } from 'react';
+import { useEditorConfigContext } from '../../../../lexical/config/client/EditorConfigProvider.js';
+import { useLexicalDrawer } from '../../../../utilities/fieldsDrawer/useLexicalDrawer.js';
+import { $createBlockNode, BlockNode } from '../nodes/BlocksNode.js';
+import { $createInlineBlockNode, $isInlineBlockNode } from '../nodes/InlineBlocksNode.js';
+import { INSERT_BLOCK_COMMAND, INSERT_INLINE_BLOCK_COMMAND } from './commands.js';
+export const BlocksPlugin = () => {
+  const $ = _c(10);
+  const [editor] = useLexicalComposerContext();
+  const [targetNodeKey, setTargetNodeKey] = useState(null);
+  const {
+    uuid
+  } = useEditorConfigContext();
+  const editDepth = useEditDepth();
+  const t0 = `lexical-inlineBlocks-create-` + uuid;
+  let t1;
+  if ($[0] !== t0 || $[1] !== editDepth) {
+    t1 = formatDrawerSlug({
+      slug: t0,
+      depth: editDepth
+    });
+    $[0] = t0;
+    $[1] = editDepth;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  const drawerSlug = t1;
+  const {
+    toggleDrawer
+  } = useLexicalDrawer(drawerSlug, true);
+  let t2;
+  if ($[3] !== editor || $[4] !== targetNodeKey) {
+    t2 = () => {
+      if (!editor.hasNodes([BlockNode])) {
+        throw new Error("BlocksPlugin: BlocksNode not registered on editor");
+      }
+      return mergeRegister(editor.registerCommand(INSERT_BLOCK_COMMAND, payload => {
+        editor.update(() => {
+          const selection = $getSelection() || $getPreviousSelection();
+          if ($isRangeSelection(selection)) {
+            const blockNode = $createBlockNode(payload);
+            $insertNodeToNearestRoot(blockNode);
+            const {
+              focus
+            } = selection;
+            const focusNode = focus.getNode();
+            if ($isParagraphNode(focusNode) && focusNode.getTextContentSize() === 0 && focusNode.getParentOrThrow().getChildren().filter(node => $isParagraphNode(node)).length > 1) {
+              focusNode.remove();
+            }
+          }
+        });
+        return true;
+      }, COMMAND_PRIORITY_EDITOR), editor.registerCommand(INSERT_INLINE_BLOCK_COMMAND, fields => {
+        if (targetNodeKey) {
+          const node_0 = $getNodeByKey(targetNodeKey);
+          if (!node_0 || !$isInlineBlockNode(node_0)) {
+            return false;
+          }
+          node_0.setFields(fields);
+          setTargetNodeKey(null);
+          return true;
+        }
+        const inlineBlockNode = $createInlineBlockNode(fields);
+        $insertNodes([inlineBlockNode]);
+        if ($isRootOrShadowRoot(inlineBlockNode.getParentOrThrow())) {
+          $wrapNodeInElement(inlineBlockNode, $createParagraphNode).selectEnd();
+        }
+        return true;
+      }, COMMAND_PRIORITY_EDITOR));
+    };
+    $[3] = editor;
+    $[4] = targetNodeKey;
+    $[5] = t2;
+  } else {
+    t2 = $[5];
+  }
+  let t3;
+  if ($[6] !== editor || $[7] !== targetNodeKey || $[8] !== toggleDrawer) {
+    t3 = [editor, targetNodeKey, toggleDrawer];
+    $[6] = editor;
+    $[7] = targetNodeKey;
+    $[8] = toggleDrawer;
+    $[9] = t3;
+  } else {
+    t3 = $[9];
+  }
+  useEffect(t2, t3);
+  return null;
+};
+//# sourceMappingURL=index.js.map

package/dist/features/blocks/client/plugin/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["c","_c","useLexicalComposerContext","$insertNodeToNearestRoot","$wrapNodeInElement","mergeRegister","formatDrawerSlug","useEditDepth","$createParagraphNode","$getNodeByKey","$getPreviousSelection","$getSelection","$insertNodes","$isParagraphNode","$isRangeSelection","$isRootOrShadowRoot","COMMAND_PRIORITY_EDITOR","useEffect","useState","useEditorConfigContext","useLexicalDrawer","$createBlockNode","BlockNode","$createInlineBlockNode","$isInlineBlockNode","INSERT_BLOCK_COMMAND","INSERT_INLINE_BLOCK_COMMAND","BlocksPlugin","$","editor","targetNodeKey","setTargetNodeKey","uuid","editDepth","t0","t1","slug","depth","drawerSlug","toggleDrawer","t2","hasNodes","Error","registerCommand","payload","update","selection","blockNode","focus","focusNode","getNode","getTextContentSize","getParentOrThrow","getChildren","filter","node","length","remove","fields","node_0","setFields","inlineBlockNode","selectEnd","t3"],"sources":["../../../../../src/features/blocks/client/plugin/index.tsx"],"sourcesContent":["'use client'\n\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext.js'\nimport { $insertNodeToNearestRoot, $wrapNodeInElement, mergeRegister } from '@lexical/utils'\nimport { formatDrawerSlug, useEditDepth } from '@payloadcms/ui'\nimport {\n  $createParagraphNode,\n  $getNodeByKey,\n  $getPreviousSelection,\n  $getSelection,\n  $insertNodes,\n  $isParagraphNode,\n  $isRangeSelection,\n  $isRootOrShadowRoot,\n  COMMAND_PRIORITY_EDITOR,\n} from 'lexical'\nimport { useEffect, useState } from 'react'\n\nimport type { PluginComponent } from '../../../typesClient.js'\nimport type { BlockFields, BlockFieldsOptionalID } from '../../server/nodes/BlocksNode.js'\n\nimport { useEditorConfigContext } from '../../../../lexical/config/client/EditorConfigProvider.js'\nimport { useLexicalDrawer } from '../../../../utilities/fieldsDrawer/useLexicalDrawer.js'\nimport { $createBlockNode, BlockNode } from '../nodes/BlocksNode.js'\nimport { $createInlineBlockNode, $isInlineBlockNode } from '../nodes/InlineBlocksNode.js'\nimport { INSERT_BLOCK_COMMAND, INSERT_INLINE_BLOCK_COMMAND } from './commands.js'\n\nexport type InsertBlockPayload = BlockFieldsOptionalID\n\nexport const BlocksPlugin: PluginComponent = () => {\n  const [editor] = useLexicalComposerContext()\n\n  const [targetNodeKey, setTargetNodeKey] = useState<null | string>(null)\n\n  const { uuid } = useEditorConfigContext()\n  const editDepth = useEditDepth()\n\n  const drawerSlug = formatDrawerSlug({\n    slug: `lexical-inlineBlocks-create-` + uuid,\n    depth: editDepth,\n  })\n\n  const { toggleDrawer } = useLexicalDrawer(drawerSlug, true)\n\n  useEffect(() => {\n    if (!editor.hasNodes([BlockNode])) {\n      throw new Error('BlocksPlugin: BlocksNode not registered on editor')\n    }\n\n    return mergeRegister(\n      editor.registerCommand<InsertBlockPayload>(\n        INSERT_BLOCK_COMMAND,\n        (payload: InsertBlockPayload) => {\n          editor.update(() => {\n            const selection = $getSelection() || $getPreviousSelection()\n\n            if ($isRangeSelection(selection)) {\n              const blockNode = $createBlockNode(payload)\n              // Insert blocks node BEFORE potentially removing focusNode, as $insertNodeToNearestRoot errors if the focusNode doesn't exist\n              $insertNodeToNearestRoot(blockNode)\n\n              const { focus } = selection\n              const focusNode = focus.getNode()\n\n              // First, delete currently selected node if it's an empty paragraph and if there are sufficient\n              // paragraph nodes (more than 1) left in the parent node, so that we don't \"trap\" the user\n              if (\n                $isParagraphNode(focusNode) &&\n                focusNode.getTextContentSize() === 0 &&\n                focusNode\n                  .getParentOrThrow()\n                  .getChildren()\n                  .filter((node) => $isParagraphNode(node)).length > 1\n              ) {\n                focusNode.remove()\n              }\n            }\n          })\n\n          return true\n        },\n        COMMAND_PRIORITY_EDITOR,\n      ),\n      editor.registerCommand(\n        INSERT_INLINE_BLOCK_COMMAND,\n        (fields) => {\n          if (targetNodeKey) {\n            const node = $getNodeByKey(targetNodeKey)\n\n            if (!node || !$isInlineBlockNode(node)) {\n              return false\n            }\n\n            node.setFields(fields as BlockFields)\n\n            setTargetNodeKey(null)\n            return true\n          }\n\n          const inlineBlockNode = $createInlineBlockNode(fields as BlockFields)\n          $insertNodes([inlineBlockNode])\n          if ($isRootOrShadowRoot(inlineBlockNode.getParentOrThrow())) {\n            $wrapNodeInElement(inlineBlockNode, $createParagraphNode).selectEnd()\n          }\n\n          return true\n        },\n        COMMAND_PRIORITY_EDITOR,\n      ),\n    )\n  }, [editor, targetNodeKey, toggleDrawer])\n\n  return null\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/features/blocks/server/graphQLPopulationPromise.d.ts

@@ -0,0 +1,6 @@
+import type { Block } from 'payload';
+import type { PopulationPromise } from '../../typesServer.js';
+import type { SerializedInlineBlockNode } from '../client/nodes/InlineBlocksNode.js';
+import type { SerializedBlockNode } from './nodes/BlocksNode.js';
+export declare const blockPopulationPromiseHOC: (blocks: Block[]) => PopulationPromise<SerializedBlockNode | SerializedInlineBlockNode>;
+//# sourceMappingURL=graphQLPopulationPromise.d.ts.map

package/dist/features/blocks/server/graphQLPopulationPromise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphQLPopulationPromise.d.ts","sourceRoot":"","sources":["../../../../src/features/blocks/server/graphQLPopulationPromise.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAEpC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAA;AAC7D,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,qCAAqC,CAAA;AACpF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAIhE,eAAO,MAAM,yBAAyB,WAC5B,KAAK,EAAE,KACd,iBAAiB,CAAC,mBAAmB,GAAG,yBAAyB,CA4CnE,CAAA"}

package/dist/features/blocks/server/graphQLPopulationPromise.js

@@ -0,0 +1,44 @@
+import { recursivelyPopulateFieldsForGraphQL } from '../../../populateGraphQL/recursivelyPopulateFieldsForGraphQL.js';
+export const blockPopulationPromiseHOC = blocks => {
+  const blockPopulationPromise = ({
+    context,
+    currentDepth,
+    depth,
+    draft,
+    editorPopulationPromises,
+    fieldPromises,
+    findMany,
+    flattenLocales,
+    node,
+    overrideAccess,
+    populationPromises,
+    req,
+    showHiddenFields
+  }) => {
+    const blockFieldData = node.fields;
+    // find block used in this node
+    const block = blocks.find(block => block.slug === blockFieldData.blockType);
+    if (!block || !block?.fields?.length || !blockFieldData) {
+      return;
+    }
+    recursivelyPopulateFieldsForGraphQL({
+      context,
+      currentDepth,
+      data: blockFieldData,
+      depth,
+      draft,
+      editorPopulationPromises,
+      fieldPromises,
+      fields: block.fields,
+      findMany,
+      flattenLocales,
+      overrideAccess,
+      populationPromises,
+      req,
+      showHiddenFields,
+      siblingDoc: blockFieldData
+    });
+  };
+  return blockPopulationPromise;
+};
+//# sourceMappingURL=graphQLPopulationPromise.js.map

package/dist/features/blocks/server/graphQLPopulationPromise.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphQLPopulationPromise.js","names":["recursivelyPopulateFieldsForGraphQL","blockPopulationPromiseHOC","blocks","blockPopulationPromise","context","currentDepth","depth","draft","editorPopulationPromises","fieldPromises","findMany","flattenLocales","node","overrideAccess","populationPromises","req","showHiddenFields","blockFieldData","fields","block","find","slug","blockType","length","data","siblingDoc"],"sources":["../../../../src/features/blocks/server/graphQLPopulationPromise.ts"],"sourcesContent":["import type { Block } from 'payload'\n\nimport type { PopulationPromise } from '../../typesServer.js'\nimport type { SerializedInlineBlockNode } from '../client/nodes/InlineBlocksNode.js'\nimport type { SerializedBlockNode } from './nodes/BlocksNode.js'\n\nimport { recursivelyPopulateFieldsForGraphQL } from '../../../populateGraphQL/recursivelyPopulateFieldsForGraphQL.js'\n\nexport const blockPopulationPromiseHOC = (\n  blocks: Block[],\n): PopulationPromise<SerializedBlockNode | SerializedInlineBlockNode> => {\n  const blockPopulationPromise: PopulationPromise<SerializedBlockNode> = ({\n    context,\n    currentDepth,\n    depth,\n    draft,\n    editorPopulationPromises,\n    fieldPromises,\n    findMany,\n    flattenLocales,\n    node,\n    overrideAccess,\n    populationPromises,\n    req,\n    showHiddenFields,\n  }) => {\n    const blockFieldData = node.fields\n\n    // find block used in this node\n    const block = blocks.find((block) => block.slug === blockFieldData.blockType)\n    if (!block || !block?.fields?.length || !blockFieldData) {\n      return\n    }\n\n    recursivelyPopulateFieldsForGraphQL({\n      context,\n      currentDepth,\n      data: blockFieldData,\n      depth,\n      draft,\n      editorPopulationPromises,\n      fieldPromises,\n      fields: block.fields,\n      findMany,\n      flattenLocales,\n      overrideAccess,\n      populationPromises,\n      req,\n      showHiddenFields,\n      siblingDoc: blockFieldData,\n    })\n  }\n\n  return blockPopulationPromise\n}\n"],"mappings":"AAMA,SAASA,mCAAmC,QAAQ;AAEpD,OAAO,MAAMC,yBAAA,GACXC,MAAA;EAEA,MAAMC,sBAAA,GAAiEA,CAAC;IACtEC,OAAO;IACPC,YAAY;IACZC,KAAK;IACLC,KAAK;IACLC,wBAAwB;IACxBC,aAAa;IACbC,QAAQ;IACRC,cAAc;IACdC,IAAI;IACJC,cAAc;IACdC,kBAAkB;IAClBC,GAAG;IACHC;EAAgB,CACjB;IACC,MAAMC,cAAA,GAAiBL,IAAA,CAAKM,MAAM;IAElC;IACA,MAAMC,KAAA,GAAQjB,MAAA,CAAOkB,IAAI,CAAED,KAAA,IAAUA,KAAA,CAAME,IAAI,KAAKJ,cAAA,CAAeK,SAAS;IAC5E,IAAI,CAACH,KAAA,IAAS,CAACA,KAAA,EAAOD,MAAA,EAAQK,MAAA,IAAU,CAACN,cAAA,EAAgB;MACvD;IACF;IAEAjB,mCAAA,CAAoC;MAClCI,OAAA;MACAC,YAAA;MACAmB,IAAA,EAAMP,cAAA;MACNX,KAAA;MACAC,KAAA;MACAC,wBAAA;MACAC,aAAA;MACAS,MAAA,EAAQC,KAAA,CAAMD,MAAM;MACpBR,QAAA;MACAC,cAAA;MACAE,cAAA;MACAC,kBAAA;MACAC,GAAA;MACAC,gBAAA;MACAS,UAAA,EAAYR;IACd;EACF;EAEA,OAAOd,sBAAA;AACT","ignoreList":[]}

package/dist/features/blocks/server/i18n.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i18n.d.ts","sourceRoot":"","sources":["../../../../src/features/blocks/server/i18n.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAA;AAEhE,eAAO,MAAM,IAAI,EAAE,OAAO,CAAC,gBAAgB,CAiS1C,CAAA"}