@payloadcms/richtext-lexical 3.0.0-beta.52 → 3.0.0-beta.53

package/dist/features/blocks/component/index.js

@@ -0,0 +1,158 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Collapsible, Form, Pill, SectionTitle, ShimmerEffect, useConfig, useDocumentInfo, useFieldProps, useFormSubmitted, useTranslation } from '@payloadcms/ui';
+import React, { useCallback, useEffect, useMemo, useState } from 'react';
+const baseClass = 'lexical-block';
+import { getTranslation } from '@payloadcms/translations';
+import { getFormState } from '@payloadcms/ui/shared';
+import { v4 as uuid } from 'uuid';
+import { useEditorConfigContext } from '../../../lexical/config/client/EditorConfigProvider.js';
+import { BlockContent } from './BlockContent.js';
+export const BlockComponent = (props)=>{
+    const { formData, nodeKey } = props;
+    const config = useConfig();
+    const submitted = useFormSubmitted();
+    const { id } = useDocumentInfo();
+    const { path, schemaPath } = useFieldProps();
+    const { editorConfig, field: parentLexicalRichTextField } = useEditorConfigContext();
+    const [initialState, setInitialState] = useState(false);
+    const { field: { richTextComponentMap } } = useEditorConfigContext();
+    const componentMapRenderedFieldsPath = `feature.blocks.fields.${formData?.blockType}`;
+    const schemaFieldsPath = `${schemaPath}.feature.blocks.${formData?.blockType}`;
+    const reducedBlock = editorConfig?.resolvedFeatureMap?.get('blocks')?.clientFeatureProps?.reducedBlocks?.find((block)=>block.slug === formData?.blockType);
+    const fieldMap = richTextComponentMap.get(componentMapRenderedFieldsPath);
+    // Field Schema
+    useEffect(()=>{
+        const awaitInitialState = async ()=>{
+            const state = await getFormState({
+                apiRoute: config.routes.api,
+                body: {
+                    id,
+                    data: JSON.parse(JSON.stringify(formData)),
+                    operation: 'update',
+                    schemaPath: schemaFieldsPath
+                },
+                serverURL: config.serverURL
+            }) // Form State
+            ;
+            if (state) {
+                setInitialState({
+                    ...state,
+                    blockName: {
+                        initialValue: '',
+                        passesCondition: true,
+                        valid: true,
+                        value: formData.blockName
+                    }
+                });
+            }
+        };
+        if (formData) {
+            void awaitInitialState();
+        }
+    }, [
+        config.routes.api,
+        config.serverURL,
+        schemaFieldsPath,
+        id
+    ]);
+    const onChange = useCallback(async ({ formState: prevFormState })=>{
+        const formState = await getFormState({
+            apiRoute: config.routes.api,
+            body: {
+                id,
+                formState: prevFormState,
+                operation: 'update',
+                schemaPath: schemaFieldsPath
+            },
+            serverURL: config.serverURL
+        });
+        return {
+            ...formState,
+            blockName: {
+                initialValue: '',
+                passesCondition: true,
+                valid: true,
+                value: formData.blockName
+            }
+        };
+    }, [
+        config.routes.api,
+        config.serverURL,
+        schemaFieldsPath,
+        id,
+        formData.blockName
+    ]);
+    const { i18n } = useTranslation();
+    const classNames = [
+        `${baseClass}__row`,
+        `${baseClass}__row--no-errors`
+    ].filter(Boolean).join(' ');
+    // Memoized Form JSX
+    const formContent = useMemo(()=>{
+        return reducedBlock && initialState !== false ? /*#__PURE__*/ _jsx(Form, {
+            beforeSubmit: [
+                onChange
+            ],
+            // @ts-expect-error TODO: Fix this
+            fields: fieldMap,
+            initialState: initialState,
+            onChange: [
+                onChange
+            ],
+            submitted: submitted,
+            uuid: uuid(),
+            children: /*#__PURE__*/ _jsx(BlockContent, {
+                baseClass: baseClass,
+                field: parentLexicalRichTextField,
+                formData: formData,
+                formSchema: Array.isArray(fieldMap) ? fieldMap : [],
+                nodeKey: nodeKey,
+                path: `${path}.feature.blocks.${formData.blockType}`,
+                reducedBlock: reducedBlock,
+                schemaPath: schemaFieldsPath
+            })
+        }) : /*#__PURE__*/ _jsx(Collapsible, {
+            className: classNames,
+            collapsibleStyle: "default",
+            header: /*#__PURE__*/ _jsx("div", {
+                className: `${baseClass}__block-header`,
+                children: /*#__PURE__*/ _jsxs("div", {
+                    children: [
+                        /*#__PURE__*/ _jsx(Pill, {
+                            className: `${baseClass}__block-pill ${baseClass}__block-pill-${formData?.blockType}`,
+                            pillStyle: "white",
+                            children: typeof reducedBlock.labels.singular === 'string' ? getTranslation(reducedBlock.labels.singular, i18n) : '[Singular Label]'
+                        }),
+                        /*#__PURE__*/ _jsx(SectionTitle, {
+                            path: "blockName",
+                            readOnly: parentLexicalRichTextField?.readOnly
+                        })
+                    ]
+                })
+            }),
+            children: /*#__PURE__*/ _jsx(ShimmerEffect, {
+                height: "35vh"
+            })
+        }, 0);
+    }, [
+        classNames,
+        fieldMap,
+        parentLexicalRichTextField,
+        nodeKey,
+        i18n,
+        submitted,
+        initialState,
+        reducedBlock,
+        onChange,
+        schemaFieldsPath,
+        path
+    ]) // Adding formData to the dependencies here might break it
+    ;
+    return /*#__PURE__*/ _jsx("div", {
+        className: baseClass + ' ' + baseClass + '-' + formData.blockType,
+        children: formContent
+    });
+};
+
+//# sourceMappingURL=index.js.map

package/dist/features/blocks/component/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/features/blocks/component/index.tsx"],"sourcesContent":["'use client'\n\nimport type { FormProps } from '@payloadcms/ui'\n\nimport {\n  Collapsible,\n  Form,\n  Pill,\n  SectionTitle,\n  ShimmerEffect,\n  useConfig,\n  useDocumentInfo,\n  useFieldProps,\n  useFormSubmitted,\n  useTranslation,\n} from '@payloadcms/ui'\nimport React, { useCallback, useEffect, useMemo, useState } from 'react'\n\nimport { type BlockFields } from '../nodes/BlocksNode.js'\nconst baseClass = 'lexical-block'\nimport type { ReducedBlock } from '@payloadcms/ui/utilities/buildComponentMap'\nimport type { FormState } from 'payload'\n\nimport { getTranslation } from '@payloadcms/translations'\nimport { getFormState } from '@payloadcms/ui/shared'\nimport { v4 as uuid } from 'uuid'\n\nimport type { ClientComponentProps } from '../../types.js'\nimport type { BlocksFeatureClientProps } from '../feature.client.js'\n\nimport { useEditorConfigContext } from '../../../lexical/config/client/EditorConfigProvider.js'\nimport { BlockContent } from './BlockContent.js'\nimport './index.scss'\n\ntype Props = {\n  children?: React.ReactNode\n\n  formData: BlockFields\n  nodeKey?: string\n  /**\n   * This transformedFormData already comes wrapped in blockFieldWrapperName\n   */\n  transformedFormData: BlockFields\n}\n\nexport const BlockComponent: React.FC<Props> = (props) => {\n  const { formData, nodeKey } = props\n  const config = useConfig()\n  const submitted = useFormSubmitted()\n  const { id } = useDocumentInfo()\n  const { path, schemaPath } = useFieldProps()\n  const { editorConfig, field: parentLexicalRichTextField } = useEditorConfigContext()\n\n  const [initialState, setInitialState] = useState<FormState | false>(false)\n  const {\n    field: { richTextComponentMap },\n  } = useEditorConfigContext()\n\n  const componentMapRenderedFieldsPath = `feature.blocks.fields.${formData?.blockType}`\n  const schemaFieldsPath = `${schemaPath}.feature.blocks.${formData?.blockType}`\n\n  const reducedBlock: ReducedBlock = (\n    editorConfig?.resolvedFeatureMap?.get('blocks')\n      ?.clientFeatureProps as ClientComponentProps<BlocksFeatureClientProps>\n  )?.reducedBlocks?.find((block) => block.slug === formData?.blockType)\n\n  const fieldMap = richTextComponentMap.get(componentMapRenderedFieldsPath)\n  // Field Schema\n  useEffect(() => {\n    const awaitInitialState = async () => {\n      const state = await getFormState({\n        apiRoute: config.routes.api,\n        body: {\n          id,\n          data: JSON.parse(JSON.stringify(formData)),\n          operation: 'update',\n          schemaPath: schemaFieldsPath,\n        },\n        serverURL: config.serverURL,\n      }) // Form State\n\n      if (state) {\n        setInitialState({\n          ...state,\n          blockName: {\n            initialValue: '',\n            passesCondition: true,\n            valid: true,\n            value: formData.blockName,\n          },\n        })\n      }\n    }\n\n    if (formData) {\n      void awaitInitialState()\n    }\n  }, [config.routes.api, config.serverURL, schemaFieldsPath, id])\n\n  const onChange: FormProps['onChange'][0] = useCallback(\n    async ({ formState: prevFormState }) => {\n      const formState = await getFormState({\n        apiRoute: config.routes.api,\n        body: {\n          id,\n          formState: prevFormState,\n          operation: 'update',\n          schemaPath: schemaFieldsPath,\n        },\n        serverURL: config.serverURL,\n      })\n\n      return {\n        ...formState,\n        blockName: {\n          initialValue: '',\n          passesCondition: true,\n          valid: true,\n          value: formData.blockName,\n        },\n      }\n    },\n\n    [config.routes.api, config.serverURL, schemaFieldsPath, id, formData.blockName],\n  )\n  const { i18n } = useTranslation()\n\n  const classNames = [`${baseClass}__row`, `${baseClass}__row--no-errors`].filter(Boolean).join(' ')\n\n  // Memoized Form JSX\n  const formContent = useMemo(() => {\n    return reducedBlock && initialState !== false ? (\n      <Form\n        beforeSubmit={[onChange]}\n        // @ts-expect-error TODO: Fix this\n        fields={fieldMap}\n        initialState={initialState}\n        onChange={[onChange]}\n        submitted={submitted}\n        uuid={uuid()}\n      >\n        <BlockContent\n          baseClass={baseClass}\n          field={parentLexicalRichTextField}\n          formData={formData}\n          formSchema={Array.isArray(fieldMap) ? fieldMap : []}\n          nodeKey={nodeKey}\n          path={`${path}.feature.blocks.${formData.blockType}`}\n          reducedBlock={reducedBlock}\n          schemaPath={schemaFieldsPath}\n        />\n      </Form>\n    ) : (\n      <Collapsible\n        className={classNames}\n        collapsibleStyle=\"default\"\n        header={\n          <div className={`${baseClass}__block-header`}>\n            <div>\n              <Pill\n                className={`${baseClass}__block-pill ${baseClass}__block-pill-${formData?.blockType}`}\n                pillStyle=\"white\"\n              >\n                {typeof reducedBlock.labels.singular === 'string'\n                  ? getTranslation(reducedBlock.labels.singular, i18n)\n                  : '[Singular Label]'}\n              </Pill>\n              <SectionTitle path=\"blockName\" readOnly={parentLexicalRichTextField?.readOnly} />\n            </div>\n          </div>\n        }\n        key={0}\n      >\n        <ShimmerEffect height=\"35vh\" />\n      </Collapsible>\n    )\n  }, [\n    classNames,\n    fieldMap,\n    parentLexicalRichTextField,\n    nodeKey,\n    i18n,\n    submitted,\n    initialState,\n    reducedBlock,\n    onChange,\n    schemaFieldsPath,\n    path,\n  ]) // Adding formData to the dependencies here might break it\n  return <div className={baseClass + ' ' + baseClass + '-' + formData.blockType}>{formContent}</div>\n}\n"],"names":["Collapsible","Form","Pill","SectionTitle","ShimmerEffect","useConfig","useDocumentInfo","useFieldProps","useFormSubmitted","useTranslation","React","useCallback","useEffect","useMemo","useState","baseClass","getTranslation","getFormState","v4","uuid","useEditorConfigContext","BlockContent","BlockComponent","props","formData","nodeKey","config","submitted","id","path","schemaPath","editorConfig","field","parentLexicalRichTextField","initialState","setInitialState","richTextComponentMap","componentMapRenderedFieldsPath","blockType","schemaFieldsPath","reducedBlock","resolvedFeatureMap","get","clientFeatureProps","reducedBlocks","find","block","slug","fieldMap","awaitInitialState","state","apiRoute","routes","api","body","data","JSON","parse","stringify","operation","serverURL","blockName","initialValue","passesCondition","valid","value","onChange","formState","prevFormState","i18n","classNames","filter","Boolean","join","formContent","beforeSubmit","fields","formSchema","Array","isArray","className","collapsibleStyle","header","div","pillStyle","labels","singular","readOnly","height"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/dist/features/blocks/component/removeEmptyArrayValues.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"removeEmptyArrayValues.d.ts","sourceRoot":"","sources":["../../../../src/features/blocks/component/removeEmptyArrayValues.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAExC;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,MAAM,EAAE,EAAE;IAAE,MAAM,EAAE,SAAS,CAAA;CAAE,GAAG,SAAS,CAQnF"}

package/dist/features/blocks/component/removeEmptyArrayValues.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/features/blocks/component/removeEmptyArrayValues.ts"],"sourcesContent":["import type { FormState } from 'payload'\n\n/**\n * By default, if an array field is empty, it will be included in the form state with a value of 0.\n * We do not need this behavior here, By setting `disableFormData` to true, we can prevent the field from being included in the form state\n * like that.\n * @param fields form state\n */\nexport function removeEmptyArrayValues({ fields }: { fields: FormState }): FormState {\n  for (const key in fields) {\n    const field = fields[key]\n    if (Array.isArray(field.rows) && 'value' in field) {\n      field.disableFormData = true\n    }\n  }\n  return fields\n}\n"],"names":["removeEmptyArrayValues","fields","key","field","Array","isArray","rows","disableFormData"],"rangeMappings":";;;;;;;;;;;;;","mappings":"AAEA;;;;;CAKC,GACD,OAAO,SAASA,uBAAuB,EAAEC,MAAM,EAAyB;IACtE,IAAK,MAAMC,OAAOD,OAAQ;QACxB,MAAME,QAAQF,MAAM,CAACC,IAAI;QACzB,IAAIE,MAAMC,OAAO,CAACF,MAAMG,IAAI,KAAK,WAAWH,OAAO;YACjDA,MAAMI,eAAe,GAAG;QAC1B;IACF;IACA,OAAON;AACT"}

package/dist/features/blocks/drawer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/features/blocks/drawer/index.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAiB,MAAM,SAAS,CAAA;AAW5D,OAAO,KAA2C,MAAM,OAAO,CAAA;AAU/D,eAAO,MAAM,gCAAgC,EAAE,cAAc,CAAC;IAC5D,OAAO,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,GAAG,KAAK,CAAA;CACrC,CAAqD,CAAA;AAiCtD,eAAO,MAAM,qBAAqB,EAAE,KAAK,CAAC,EA0DzC,CAAA"}

package/dist/features/blocks/drawer/index.js

@@ -0,0 +1,78 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext.js';
+import { BlocksDrawer, formatDrawerSlug, useEditDepth, useModal, useTranslation } from '@payloadcms/ui';
+import { $getNodeByKey, COMMAND_PRIORITY_EDITOR, createCommand } from 'lexical';
+import React, { useCallback, useEffect, useState } from 'react';
+import { useEditorConfigContext } from '../../../lexical/config/client/EditorConfigProvider.js';
+import { $createBlockNode } from '../nodes/BlocksNode.js';
+import { INSERT_BLOCK_COMMAND } from '../plugin/commands.js';
+const baseClass = 'lexical-blocks-drawer';
+export const INSERT_BLOCK_WITH_DRAWER_COMMAND = createCommand('INSERT_BLOCK_WITH_DRAWER_COMMAND');
+const insertBlock = ({ blockType, editor, replaceNodeKey })=>{
+    if (!replaceNodeKey) {
+        editor.dispatchCommand(INSERT_BLOCK_COMMAND, {
+            id: null,
+            blockName: '',
+            blockType
+        });
+    } else {
+        editor.update(()=>{
+            const node = $getNodeByKey(replaceNodeKey);
+            if (node) {
+                node.replace($createBlockNode({
+                    id: null,
+                    blockName: '',
+                    blockType
+                }));
+            }
+        });
+    }
+};
+export const BlocksDrawerComponent = ()=>{
+    const [editor] = useLexicalComposerContext();
+    const { editorConfig, uuid } = useEditorConfigContext();
+    const [replaceNodeKey, setReplaceNodeKey] = useState(null);
+    const editDepth = useEditDepth();
+    const { t } = useTranslation();
+    const { openModal } = useModal();
+    const labels = {
+        plural: t('fields:blocks') || 'Blocks',
+        singular: t('fields:block') || 'Block'
+    };
+    const addRow = useCallback((rowIndex, blockType)=>{
+        insertBlock({
+            blockType,
+            editor,
+            replaceNodeKey
+        });
+    }, [
+        editor,
+        replaceNodeKey
+    ]);
+    const drawerSlug = formatDrawerSlug({
+        slug: `lexical-rich-text-blocks-` + uuid,
+        depth: editDepth
+    });
+    const reducedBlocks = editorConfig?.resolvedFeatureMap?.get('blocks')?.clientFeatureProps?.reducedBlocks;
+    useEffect(()=>{
+        return editor.registerCommand(INSERT_BLOCK_WITH_DRAWER_COMMAND, (payload)=>{
+            setReplaceNodeKey(payload?.replace ? payload?.replace.nodeKey : null);
+            openModal(drawerSlug);
+            return true;
+        }, COMMAND_PRIORITY_EDITOR);
+    }, [
+        editor,
+        drawerSlug,
+        openModal
+    ]);
+    return /*#__PURE__*/ _jsx(BlocksDrawer, {
+        addRow: addRow,
+        addRowIndex: 0,
+        blocks: reducedBlocks,
+        drawerSlug: drawerSlug,
+        labels: labels
+    });
+};
+
+//# sourceMappingURL=index.js.map

package/dist/features/blocks/drawer/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/features/blocks/drawer/index.tsx"],"sourcesContent":["'use client'\nimport type { LexicalCommand, LexicalEditor } from 'lexical'\n\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext.js'\nimport {\n  BlocksDrawer,\n  formatDrawerSlug,\n  useEditDepth,\n  useModal,\n  useTranslation,\n} from '@payloadcms/ui'\nimport { $getNodeByKey, COMMAND_PRIORITY_EDITOR, createCommand } from 'lexical'\nimport React, { useCallback, useEffect, useState } from 'react'\n\nimport type { ClientComponentProps } from '../../types.js'\nimport type { BlocksFeatureClientProps } from '../feature.client.js'\n\nimport { useEditorConfigContext } from '../../../lexical/config/client/EditorConfigProvider.js'\nimport { $createBlockNode } from '../nodes/BlocksNode.js'\nimport { INSERT_BLOCK_COMMAND } from '../plugin/commands.js'\nconst baseClass = 'lexical-blocks-drawer'\n\nexport const INSERT_BLOCK_WITH_DRAWER_COMMAND: LexicalCommand<{\n  replace: { nodeKey: string } | false\n}> = createCommand('INSERT_BLOCK_WITH_DRAWER_COMMAND')\n\nconst insertBlock = ({\n  blockType,\n  editor,\n  replaceNodeKey,\n}: {\n  blockType: string\n  editor: LexicalEditor\n  replaceNodeKey: null | string\n}) => {\n  if (!replaceNodeKey) {\n    editor.dispatchCommand(INSERT_BLOCK_COMMAND, {\n      id: null,\n      blockName: '',\n      blockType,\n    })\n  } else {\n    editor.update(() => {\n      const node = $getNodeByKey(replaceNodeKey)\n      if (node) {\n        node.replace(\n          $createBlockNode({\n            id: null,\n            blockName: '',\n            blockType,\n          }),\n        )\n      }\n    })\n  }\n}\n\nexport const BlocksDrawerComponent: React.FC = () => {\n  const [editor] = useLexicalComposerContext()\n  const { editorConfig, uuid } = useEditorConfigContext()\n\n  const [replaceNodeKey, setReplaceNodeKey] = useState<null | string>(null)\n  const editDepth = useEditDepth()\n  const { t } = useTranslation()\n  const { openModal } = useModal()\n\n  const labels = {\n    plural: t('fields:blocks') || 'Blocks',\n    singular: t('fields:block') || 'Block',\n  }\n\n  const addRow = useCallback(\n    (rowIndex: number, blockType: string) => {\n      insertBlock({\n        blockType,\n        editor,\n        replaceNodeKey,\n      })\n    },\n    [editor, replaceNodeKey],\n  )\n\n  const drawerSlug = formatDrawerSlug({\n    slug: `lexical-rich-text-blocks-` + uuid,\n    depth: editDepth,\n  })\n\n  const reducedBlocks = (\n    editorConfig?.resolvedFeatureMap?.get('blocks')\n      ?.clientFeatureProps as ClientComponentProps<BlocksFeatureClientProps>\n  )?.reducedBlocks\n\n  useEffect(() => {\n    return editor.registerCommand<{\n      replace: { nodeKey: string } | false\n    }>(\n      INSERT_BLOCK_WITH_DRAWER_COMMAND,\n      (payload) => {\n        setReplaceNodeKey(payload?.replace ? payload?.replace.nodeKey : null)\n        openModal(drawerSlug)\n        return true\n      },\n      COMMAND_PRIORITY_EDITOR,\n    )\n  }, [editor, drawerSlug, openModal])\n\n  return (\n    <BlocksDrawer\n      addRow={addRow}\n      addRowIndex={0}\n      blocks={reducedBlocks}\n      drawerSlug={drawerSlug}\n      labels={labels}\n    />\n  )\n}\n"],"names":["useLexicalComposerContext","BlocksDrawer","formatDrawerSlug","useEditDepth","useModal","useTranslation","$getNodeByKey","COMMAND_PRIORITY_EDITOR","createCommand","React","useCallback","useEffect","useState","useEditorConfigContext","$createBlockNode","INSERT_BLOCK_COMMAND","baseClass","INSERT_BLOCK_WITH_DRAWER_COMMAND","insertBlock","blockType","editor","replaceNodeKey","dispatchCommand","id","blockName","update","node","replace","BlocksDrawerComponent","editorConfig","uuid","setReplaceNodeKey","editDepth","t","openModal","labels","plural","singular","addRow","rowIndex","drawerSlug","slug","depth","reducedBlocks","resolvedFeatureMap","get","clientFeatureProps","registerCommand","payload","nodeKey","addRowIndex","blocks"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;;AAGA,SAASA,yBAAyB,QAAQ,2CAA0C;AACpF,SACEC,YAAY,EACZC,gBAAgB,EAChBC,YAAY,EACZC,QAAQ,EACRC,cAAc,QACT,iBAAgB;AACvB,SAASC,aAAa,EAAEC,uBAAuB,EAAEC,aAAa,QAAQ,UAAS;AAC/E,OAAOC,SAASC,WAAW,EAAEC,SAAS,EAAEC,QAAQ,QAAQ,QAAO;AAK/D,SAASC,sBAAsB,QAAQ,yDAAwD;AAC/F,SAASC,gBAAgB,QAAQ,yBAAwB;AACzD,SAASC,oBAAoB,QAAQ,wBAAuB;AAC5D,MAAMC,YAAY;AAElB,OAAO,MAAMC,mCAERT,cAAc,oCAAmC;AAEtD,MAAMU,cAAc,CAAC,EACnBC,SAAS,EACTC,MAAM,EACNC,cAAc,EAKf;IACC,IAAI,CAACA,gBAAgB;QACnBD,OAAOE,eAAe,CAACP,sBAAsB;YAC3CQ,IAAI;YACJC,WAAW;YACXL;QACF;IACF,OAAO;QACLC,OAAOK,MAAM,CAAC;YACZ,MAAMC,OAAOpB,cAAce;YAC3B,IAAIK,MAAM;gBACRA,KAAKC,OAAO,CACVb,iBAAiB;oBACfS,IAAI;oBACJC,WAAW;oBACXL;gBACF;YAEJ;QACF;IACF;AACF;AAEA,OAAO,MAAMS,wBAAkC;IAC7C,MAAM,CAACR,OAAO,GAAGpB;IACjB,MAAM,EAAE6B,YAAY,EAAEC,IAAI,EAAE,GAAGjB;IAE/B,MAAM,CAACQ,gBAAgBU,kBAAkB,GAAGnB,SAAwB;IACpE,MAAMoB,YAAY7B;IAClB,MAAM,EAAE8B,CAAC,EAAE,GAAG5B;IACd,MAAM,EAAE6B,SAAS,EAAE,GAAG9B;IAEtB,MAAM+B,SAAS;QACbC,QAAQH,EAAE,oBAAoB;QAC9BI,UAAUJ,EAAE,mBAAmB;IACjC;IAEA,MAAMK,SAAS5B,YACb,CAAC6B,UAAkBpB;QACjBD,YAAY;YACVC;YACAC;YACAC;QACF;IACF,GACA;QAACD;QAAQC;KAAe;IAG1B,MAAMmB,aAAatC,iBAAiB;QAClCuC,MAAM,CAAC,yBAAyB,CAAC,GAAGX;QACpCY,OAAOV;IACT;IAEA,MAAMW,gBACJd,cAAce,oBAAoBC,IAAI,WAClCC,oBACHH;IAEHhC,UAAU;QACR,OAAOS,OAAO2B,eAAe,CAG3B9B,kCACA,CAAC+B;YACCjB,kBAAkBiB,SAASrB,UAAUqB,SAASrB,QAAQsB,UAAU;YAChEf,UAAUM;YACV,OAAO;QACT,GACAjC;IAEJ,GAAG;QAACa;QAAQoB;QAAYN;KAAU;IAElC,qBACE,KAACjC;QACCqC,QAAQA;QACRY,aAAa;QACbC,QAAQR;QACRH,YAAYA;QACZL,QAAQA;;AAGd,EAAC"}

package/dist/features/blocks/feature.client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature.client.d.ts","sourceRoot":"","sources":["../../../src/features/blocks/feature.client.tsx"],"names":[],"mappings":";AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4CAA4C,CAAA;AAY9E,MAAM,MAAM,wBAAwB,GAAG;IACrC,aAAa,EAAE,YAAY,EAAE,CAAA;CAC9B,CAAA;AAiFD,eAAO,MAAM,4BAA4B;;;6BAA6C,CAAA"}

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/features/blocks/feature.client.tsx"],"sourcesContent":["'use client'\n\nimport type { ReducedBlock } from '@payloadcms/ui/utilities/buildComponentMap'\n\nimport { getTranslation } from '@payloadcms/translations'\n\nimport type { FeatureProviderProviderClient } from '../types.js'\n\nimport { BlockIcon } from '../../lexical/ui/icons/Block/index.js'\nimport { createClientComponent } from '../createClientComponent.js'\nimport { BlockNode } from './nodes/BlocksNode.js'\nimport { INSERT_BLOCK_COMMAND } from './plugin/commands.js'\nimport { BlocksPlugin } from './plugin/index.js'\n\nexport type BlocksFeatureClientProps = {\n  reducedBlocks: ReducedBlock[]\n}\n\nconst BlocksFeatureClient: FeatureProviderProviderClient<BlocksFeatureClientProps> = (props) => {\n  return {\n    clientFeatureProps: props,\n    feature: () => ({\n      clientFeatureProps: props,\n      nodes: [BlockNode],\n      plugins: [\n        {\n          Component: BlocksPlugin,\n          position: 'normal',\n        },\n      ],\n      slashMenu: {\n        groups: [\n          {\n            items: props.reducedBlocks.map((block) => {\n              return {\n                Icon: BlockIcon,\n                key: 'block-' + block.slug,\n                keywords: ['block', 'blocks', block.slug],\n                label: ({ i18n }) => {\n                  if (!block.labels.singular) {\n                    return block.slug\n                  }\n\n                  return getTranslation(block.labels.singular, i18n)\n                },\n                onSelect: ({ editor }) => {\n                  editor.dispatchCommand(INSERT_BLOCK_COMMAND, {\n                    id: null,\n                    blockName: '',\n                    blockType: block.slug,\n                  })\n                },\n              }\n            }),\n            key: 'blocks',\n            label: ({ i18n }) => {\n              return i18n.t('lexical:blocks:label')\n            },\n          },\n        ],\n      },\n      toolbarFixed: {\n        groups: [\n          {\n            type: 'dropdown',\n            ChildComponent: BlockIcon,\n            items: props.reducedBlocks.map((block, index) => {\n              return {\n                ChildComponent: BlockIcon,\n                isActive: undefined, // At this point, we would be inside a sub-richtext-editor. And at this point this will be run against the focused sub-editor, not the parent editor which has the actual block. Thus, no point in running this\n                key: 'block-' + block.slug,\n                label: ({ i18n }) => {\n                  if (!block.labels.singular) {\n                    return block.slug\n                  }\n\n                  return getTranslation(block.labels.singular, i18n)\n                },\n                onSelect: ({ editor }) => {\n                  editor.dispatchCommand(INSERT_BLOCK_COMMAND, {\n                    id: null,\n                    blockName: '',\n                    blockType: block.slug,\n                  })\n                },\n                order: index,\n              }\n            }),\n            key: 'blocks',\n            order: 20,\n          },\n        ],\n      },\n    }),\n  }\n}\n\nexport const BlocksFeatureClientComponent = createClientComponent(BlocksFeatureClient)\n"],"names":["getTranslation","BlockIcon","createClientComponent","BlockNode","INSERT_BLOCK_COMMAND","BlocksPlugin","BlocksFeatureClient","props","clientFeatureProps","feature","nodes","plugins","Component","position","slashMenu","groups","items","reducedBlocks","map","block","Icon","key","slug","keywords","label","i18n","labels","singular","onSelect","editor","dispatchCommand","id","blockName","blockType","t","toolbarFixed","type","ChildComponent","index","isActive","undefined","order","BlocksFeatureClientComponent"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;AAIA,SAASA,cAAc,QAAQ,2BAA0B;AAIzD,SAASC,SAAS,QAAQ,wCAAuC;AACjE,SAASC,qBAAqB,QAAQ,8BAA6B;AACnE,SAASC,SAAS,QAAQ,wBAAuB;AACjD,SAASC,oBAAoB,QAAQ,uBAAsB;AAC3D,SAASC,YAAY,QAAQ,oBAAmB;AAMhD,MAAMC,sBAA+E,CAACC;IACpF,OAAO;QACLC,oBAAoBD;QACpBE,SAAS,IAAO,CAAA;gBACdD,oBAAoBD;gBACpBG,OAAO;oBAACP;iBAAU;gBAClBQ,SAAS;oBACP;wBACEC,WAAWP;wBACXQ,UAAU;oBACZ;iBACD;gBACDC,WAAW;oBACTC,QAAQ;wBACN;4BACEC,OAAOT,MAAMU,aAAa,CAACC,GAAG,CAAC,CAACC;gCAC9B,OAAO;oCACLC,MAAMnB;oCACNoB,KAAK,WAAWF,MAAMG,IAAI;oCAC1BC,UAAU;wCAAC;wCAAS;wCAAUJ,MAAMG,IAAI;qCAAC;oCACzCE,OAAO,CAAC,EAAEC,IAAI,EAAE;wCACd,IAAI,CAACN,MAAMO,MAAM,CAACC,QAAQ,EAAE;4CAC1B,OAAOR,MAAMG,IAAI;wCACnB;wCAEA,OAAOtB,eAAemB,MAAMO,MAAM,CAACC,QAAQ,EAAEF;oCAC/C;oCACAG,UAAU,CAAC,EAAEC,MAAM,EAAE;wCACnBA,OAAOC,eAAe,CAAC1B,sBAAsB;4CAC3C2B,IAAI;4CACJC,WAAW;4CACXC,WAAWd,MAAMG,IAAI;wCACvB;oCACF;gCACF;4BACF;4BACAD,KAAK;4BACLG,OAAO,CAAC,EAAEC,IAAI,EAAE;gCACd,OAAOA,KAAKS,CAAC,CAAC;4BAChB;wBACF;qBACD;gBACH;gBACAC,cAAc;oBACZpB,QAAQ;wBACN;4BACEqB,MAAM;4BACNC,gBAAgBpC;4BAChBe,OAAOT,MAAMU,aAAa,CAACC,GAAG,CAAC,CAACC,OAAOmB;gCACrC,OAAO;oCACLD,gBAAgBpC;oCAChBsC,UAAUC;oCACVnB,KAAK,WAAWF,MAAMG,IAAI;oCAC1BE,OAAO,CAAC,EAAEC,IAAI,EAAE;wCACd,IAAI,CAACN,MAAMO,MAAM,CAACC,QAAQ,EAAE;4CAC1B,OAAOR,MAAMG,IAAI;wCACnB;wCAEA,OAAOtB,eAAemB,MAAMO,MAAM,CAACC,QAAQ,EAAEF;oCAC/C;oCACAG,UAAU,CAAC,EAAEC,MAAM,EAAE;wCACnBA,OAAOC,eAAe,CAAC1B,sBAAsB;4CAC3C2B,IAAI;4CACJC,WAAW;4CACXC,WAAWd,MAAMG,IAAI;wCACvB;oCACF;oCACAmB,OAAOH;gCACT;4BACF;4BACAjB,KAAK;4BACLoB,OAAO;wBACT;qBACD;gBACH;YACF,CAAA;IACF;AACF;AAEA,OAAO,MAAMC,+BAA+BxC,sBAAsBI,qBAAoB"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"feature.server.d.ts","sourceRoot":"","sources":["../../../src/features/blocks/feature.server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAA6B,MAAM,SAAS,CAAA;AAK/D,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,aAAa,CAAA;AAChE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAA;AAUnE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,MAAM,EAAE,KAAK,EAAE,CAAA;CAChB,CAAA;AAED,eAAO,MAAM,aAAa,EAAE,6BAA6B,CACvD,kBAAkB,EAClB,wBAAwB,CAiHzB,CAAA"}

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

@@ -0,0 +1,107 @@
+import { traverseFields } from '@payloadcms/ui/utilities/buildFieldSchemaMap/traverseFields';
+import { baseBlockFields, fieldsToJSONSchema, formatLabels, sanitizeFields } from 'payload';
+// eslint-disable-next-line payload/no-imports-from-exports-dir
+import { BlocksFeatureClientComponent } from '../../exports/client/index.js';
+import { createNode } from '../typeUtilities.js';
+import { blockPopulationPromiseHOC } from './graphQLPopulationPromise.js';
+import { i18n } from './i18n.js';
+import { BlockNode } from './nodes/BlocksNode.js';
+import { blockValidationHOC } from './validate.js';
+export const BlocksFeature = (props)=>{
+    return {
+        feature: async ({ config: _config, isRoot })=>{
+            if (props?.blocks?.length) {
+                const validRelationships = _config.collections.map((c)=>c.slug) || [];
+                for (const block of props.blocks){
+                    block.fields = block.fields.concat(baseBlockFields);
+                    block.labels = !block.labels ? formatLabels(block.slug) : block.labels;
+                    block.fields = await sanitizeFields({
+                        config: _config,
+                        fields: block.fields,
+                        requireFieldLevelRichTextEditor: isRoot,
+                        validRelationships
+                    });
+                }
+            }
+            // Build clientProps
+            const clientProps = {
+                reducedBlocks: []
+            };
+            for (const block of props.blocks){
+                clientProps.reducedBlocks.push({
+                    slug: block.slug,
+                    fieldMap: [],
+                    imageAltText: block.imageAltText,
+                    imageURL: block.imageURL,
+                    labels: block.labels
+                });
+            }
+            return {
+                ClientComponent: BlocksFeatureClientComponent,
+                clientFeatureProps: clientProps,
+                generateSchemaMap: ({ config, i18n, props })=>{
+                    const validRelationships = config.collections.map((c)=>c.slug) || [];
+                    /**
+           * Add sub-fields to the schemaMap. E.g. if you have an array field as part of the block, and it runs addRow, it will request these
+           * sub-fields from the component map. Thus, we need to put them in the component map here.
+           */ const schemaMap = new Map();
+                    for (const block of props.blocks){
+                        schemaMap.set(block.slug, block.fields || []);
+                        traverseFields({
+                            config,
+                            fields: block.fields,
+                            i18n,
+                            schemaMap,
+                            schemaPath: block.slug,
+                            validRelationships
+                        });
+                    }
+                    return schemaMap;
+                },
+                generatedTypes: {
+                    modifyOutputSchema: ({ collectionIDFieldTypes, config, currentSchema, field, interfaceNameDefinitions })=>{
+                        if (!props?.blocks?.length) {
+                            return currentSchema;
+                        }
+                        const blocksField = {
+                            name: field?.name + '_lexical_blocks',
+                            type: 'blocks',
+                            blocks: props.blocks
+                        };
+                        // This is only done so that interfaceNameDefinitions sets those block's interfaceNames.
+                        // we don't actually use the JSON Schema itself in the generated types yet.
+                        fieldsToJSONSchema(collectionIDFieldTypes, [
+                            blocksField
+                        ], interfaceNameDefinitions, config);
+                        return currentSchema;
+                    }
+                },
+                i18n,
+                nodes: [
+                    createNode({
+                        getSubFields: ({ node, req })=>{
+                            const blockType = node.fields.blockType;
+                            const block = props.blocks.find((block)=>block.slug === blockType);
+                            return block?.fields;
+                        },
+                        getSubFieldsData: ({ node })=>{
+                            return node?.fields;
+                        },
+                        graphQLPopulationPromises: [
+                            blockPopulationPromiseHOC(props)
+                        ],
+                        node: BlockNode,
+                        validations: [
+                            blockValidationHOC(props)
+                        ]
+                    })
+                ],
+                serverFeatureProps: props
+            };
+        },
+        key: 'blocks',
+        serverFeatureProps: props
+    };
+};
+
+//# sourceMappingURL=feature.server.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/features/blocks/feature.server.ts"],"sourcesContent":["import type { Block, BlockField, Config, Field } from 'payload'\n\nimport { traverseFields } from '@payloadcms/ui/utilities/buildFieldSchemaMap/traverseFields'\nimport { baseBlockFields, fieldsToJSONSchema, formatLabels, sanitizeFields } from 'payload'\n\nimport type { FeatureProviderProviderServer } from '../types.js'\nimport type { BlocksFeatureClientProps } from './feature.client.js'\n\n// eslint-disable-next-line payload/no-imports-from-exports-dir\nimport { BlocksFeatureClientComponent } from '../../exports/client/index.js'\nimport { createNode } from '../typeUtilities.js'\nimport { blockPopulationPromiseHOC } from './graphQLPopulationPromise.js'\nimport { i18n } from './i18n.js'\nimport { BlockNode } from './nodes/BlocksNode.js'\nimport { blockValidationHOC } from './validate.js'\n\nexport type BlocksFeatureProps = {\n  blocks: Block[]\n}\n\nexport const BlocksFeature: FeatureProviderProviderServer<\n  BlocksFeatureProps,\n  BlocksFeatureClientProps\n> = (props) => {\n  return {\n    feature: async ({ config: _config, isRoot }) => {\n      if (props?.blocks?.length) {\n        const validRelationships = _config.collections.map((c) => c.slug) || []\n\n        for (const block of props.blocks) {\n          block.fields = block.fields.concat(baseBlockFields)\n          block.labels = !block.labels ? formatLabels(block.slug) : block.labels\n\n          block.fields = await sanitizeFields({\n            config: _config as unknown as Config,\n            fields: block.fields,\n            requireFieldLevelRichTextEditor: isRoot,\n            validRelationships,\n          })\n        }\n      }\n\n      // Build clientProps\n      const clientProps: BlocksFeatureClientProps = {\n        reducedBlocks: [],\n      }\n      for (const block of props.blocks) {\n        clientProps.reducedBlocks.push({\n          slug: block.slug,\n          fieldMap: [],\n          imageAltText: block.imageAltText,\n          imageURL: block.imageURL,\n          labels: block.labels,\n        })\n      }\n\n      return {\n        ClientComponent: BlocksFeatureClientComponent,\n        clientFeatureProps: clientProps,\n        generateSchemaMap: ({ config, i18n, props }) => {\n          const validRelationships = config.collections.map((c) => c.slug) || []\n\n          /**\n           * Add sub-fields to the schemaMap. E.g. if you have an array field as part of the block, and it runs addRow, it will request these\n           * sub-fields from the component map. Thus, we need to put them in the component map here.\n           */\n          const schemaMap = new Map<string, Field[]>()\n\n          for (const block of props.blocks) {\n            schemaMap.set(block.slug, block.fields || [])\n\n            traverseFields({\n              config,\n              fields: block.fields,\n              i18n,\n              schemaMap,\n              schemaPath: block.slug,\n              validRelationships,\n            })\n          }\n\n          return schemaMap\n        },\n        generatedTypes: {\n          modifyOutputSchema: ({\n            collectionIDFieldTypes,\n            config,\n            currentSchema,\n            field,\n            interfaceNameDefinitions,\n          }) => {\n            if (!props?.blocks?.length) {\n              return currentSchema\n            }\n\n            const blocksField: BlockField = {\n              name: field?.name + '_lexical_blocks',\n              type: 'blocks',\n              blocks: props.blocks,\n            }\n            // This is only done so that interfaceNameDefinitions sets those block's interfaceNames.\n            // we don't actually use the JSON Schema itself in the generated types yet.\n            fieldsToJSONSchema(\n              collectionIDFieldTypes,\n              [blocksField],\n              interfaceNameDefinitions,\n              config,\n            )\n\n            return currentSchema\n          },\n        },\n        i18n,\n        nodes: [\n          createNode({\n            getSubFields: ({ node, req }) => {\n              const blockType = node.fields.blockType\n\n              const block = props.blocks.find((block) => block.slug === blockType)\n              return block?.fields\n            },\n            getSubFieldsData: ({ node }) => {\n              return node?.fields\n            },\n            graphQLPopulationPromises: [blockPopulationPromiseHOC(props)],\n            node: BlockNode,\n            validations: [blockValidationHOC(props)],\n          }),\n        ],\n        serverFeatureProps: props,\n      }\n    },\n    key: 'blocks',\n    serverFeatureProps: props,\n  }\n}\n"],"names":["traverseFields","baseBlockFields","fieldsToJSONSchema","formatLabels","sanitizeFields","BlocksFeatureClientComponent","createNode","blockPopulationPromiseHOC","i18n","BlockNode","blockValidationHOC","BlocksFeature","props","feature","config","_config","isRoot","blocks","length","validRelationships","collections","map","c","slug","block","fields","concat","labels","requireFieldLevelRichTextEditor","clientProps","reducedBlocks","push","fieldMap","imageAltText","imageURL","ClientComponent","clientFeatureProps","generateSchemaMap","schemaMap","Map","set","schemaPath","generatedTypes","modifyOutputSchema","collectionIDFieldTypes","currentSchema","field","interfaceNameDefinitions","blocksField","name","type","nodes","getSubFields","node","req","blockType","find","getSubFieldsData","graphQLPopulationPromises","validations","serverFeatureProps","key"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAEA,SAASA,cAAc,QAAQ,8DAA6D;AAC5F,SAASC,eAAe,EAAEC,kBAAkB,EAAEC,YAAY,EAAEC,cAAc,QAAQ,UAAS;AAK3F,+DAA+D;AAC/D,SAASC,4BAA4B,QAAQ,gCAA+B;AAC5E,SAASC,UAAU,QAAQ,sBAAqB;AAChD,SAASC,yBAAyB,QAAQ,gCAA+B;AACzE,SAASC,IAAI,QAAQ,YAAW;AAChC,SAASC,SAAS,QAAQ,wBAAuB;AACjD,SAASC,kBAAkB,QAAQ,gBAAe;AAMlD,OAAO,MAAMC,gBAGT,CAACC;IACH,OAAO;QACLC,SAAS,OAAO,EAAEC,QAAQC,OAAO,EAAEC,MAAM,EAAE;YACzC,IAAIJ,OAAOK,QAAQC,QAAQ;gBACzB,MAAMC,qBAAqBJ,QAAQK,WAAW,CAACC,GAAG,CAAC,CAACC,IAAMA,EAAEC,IAAI,KAAK,EAAE;gBAEvE,KAAK,MAAMC,SAASZ,MAAMK,MAAM,CAAE;oBAChCO,MAAMC,MAAM,GAAGD,MAAMC,MAAM,CAACC,MAAM,CAACzB;oBACnCuB,MAAMG,MAAM,GAAG,CAACH,MAAMG,MAAM,GAAGxB,aAAaqB,MAAMD,IAAI,IAAIC,MAAMG,MAAM;oBAEtEH,MAAMC,MAAM,GAAG,MAAMrB,eAAe;wBAClCU,QAAQC;wBACRU,QAAQD,MAAMC,MAAM;wBACpBG,iCAAiCZ;wBACjCG;oBACF;gBACF;YACF;YAEA,oBAAoB;YACpB,MAAMU,cAAwC;gBAC5CC,eAAe,EAAE;YACnB;YACA,KAAK,MAAMN,SAASZ,MAAMK,MAAM,CAAE;gBAChCY,YAAYC,aAAa,CAACC,IAAI,CAAC;oBAC7BR,MAAMC,MAAMD,IAAI;oBAChBS,UAAU,EAAE;oBACZC,cAAcT,MAAMS,YAAY;oBAChCC,UAAUV,MAAMU,QAAQ;oBACxBP,QAAQH,MAAMG,MAAM;gBACtB;YACF;YAEA,OAAO;gBACLQ,iBAAiB9B;gBACjB+B,oBAAoBP;gBACpBQ,mBAAmB,CAAC,EAAEvB,MAAM,EAAEN,IAAI,EAAEI,KAAK,EAAE;oBACzC,MAAMO,qBAAqBL,OAAOM,WAAW,CAACC,GAAG,CAAC,CAACC,IAAMA,EAAEC,IAAI,KAAK,EAAE;oBAEtE;;;WAGC,GACD,MAAMe,YAAY,IAAIC;oBAEtB,KAAK,MAAMf,SAASZ,MAAMK,MAAM,CAAE;wBAChCqB,UAAUE,GAAG,CAAChB,MAAMD,IAAI,EAAEC,MAAMC,MAAM,IAAI,EAAE;wBAE5CzB,eAAe;4BACbc;4BACAW,QAAQD,MAAMC,MAAM;4BACpBjB;4BACA8B;4BACAG,YAAYjB,MAAMD,IAAI;4BACtBJ;wBACF;oBACF;oBAEA,OAAOmB;gBACT;gBACAI,gBAAgB;oBACdC,oBAAoB,CAAC,EACnBC,sBAAsB,EACtB9B,MAAM,EACN+B,aAAa,EACbC,KAAK,EACLC,wBAAwB,EACzB;wBACC,IAAI,CAACnC,OAAOK,QAAQC,QAAQ;4BAC1B,OAAO2B;wBACT;wBAEA,MAAMG,cAA0B;4BAC9BC,MAAMH,OAAOG,OAAO;4BACpBC,MAAM;4BACNjC,QAAQL,MAAMK,MAAM;wBACtB;wBACA,wFAAwF;wBACxF,2EAA2E;wBAC3Ef,mBACE0C,wBACA;4BAACI;yBAAY,EACbD,0BACAjC;wBAGF,OAAO+B;oBACT;gBACF;gBACArC;gBACA2C,OAAO;oBACL7C,WAAW;wBACT8C,cAAc,CAAC,EAAEC,IAAI,EAAEC,GAAG,EAAE;4BAC1B,MAAMC,YAAYF,KAAK5B,MAAM,CAAC8B,SAAS;4BAEvC,MAAM/B,QAAQZ,MAAMK,MAAM,CAACuC,IAAI,CAAC,CAAChC,QAAUA,MAAMD,IAAI,KAAKgC;4BAC1D,OAAO/B,OAAOC;wBAChB;wBACAgC,kBAAkB,CAAC,EAAEJ,IAAI,EAAE;4BACzB,OAAOA,MAAM5B;wBACf;wBACAiC,2BAA2B;4BAACnD,0BAA0BK;yBAAO;wBAC7DyC,MAAM5C;wBACNkD,aAAa;4BAACjD,mBAAmBE;yBAAO;oBAC1C;iBACD;gBACDgD,oBAAoBhD;YACtB;QACF;QACAiD,KAAK;QACLD,oBAAoBhD;IACtB;AACF,EAAC"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"graphQLPopulationPromise.d.ts","sourceRoot":"","sources":["../../../src/features/blocks/graphQLPopulationPromise.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AACpD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AAC7D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAIhE,eAAO,MAAM,yBAAyB,UAC7B,kBAAkB,KACxB,kBAAkB,mBAAmB,CA4CvC,CAAA"}

package/dist/features/blocks/graphQLPopulationPromise.js

@@ -0,0 +1,31 @@
+import { recursivelyPopulateFieldsForGraphQL } from '../../populateGraphQL/recursivelyPopulateFieldsForGraphQL.js';
+export const blockPopulationPromiseHOC = (props)=>{
+    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 = props.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/graphQLPopulationPromise.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/features/blocks/graphQLPopulationPromise.ts"],"sourcesContent":["import type { PopulationPromise } from '../types.js'\nimport type { BlocksFeatureProps } from './feature.server.js'\nimport type { SerializedBlockNode } from './nodes/BlocksNode.js'\n\nimport { recursivelyPopulateFieldsForGraphQL } from '../../populateGraphQL/recursivelyPopulateFieldsForGraphQL.js'\n\nexport const blockPopulationPromiseHOC = (\n  props: BlocksFeatureProps,\n): PopulationPromise<SerializedBlockNode> => {\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 = props.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"],"names":["recursivelyPopulateFieldsForGraphQL","blockPopulationPromiseHOC","props","blockPopulationPromise","context","currentDepth","depth","draft","editorPopulationPromises","fieldPromises","findMany","flattenLocales","node","overrideAccess","populationPromises","req","showHiddenFields","blockFieldData","fields","block","blocks","find","slug","blockType","length","data","siblingDoc"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAIA,SAASA,mCAAmC,QAAQ,+DAA8D;AAElH,OAAO,MAAMC,4BAA4B,CACvCC;IAEA,MAAMC,yBAAiE,CAAC,EACtEC,OAAO,EACPC,YAAY,EACZC,KAAK,EACLC,KAAK,EACLC,wBAAwB,EACxBC,aAAa,EACbC,QAAQ,EACRC,cAAc,EACdC,IAAI,EACJC,cAAc,EACdC,kBAAkB,EAClBC,GAAG,EACHC,gBAAgB,EACjB;QACC,MAAMC,iBAAiBL,KAAKM,MAAM;QAElC,+BAA+B;QAC/B,MAAMC,QAAQjB,MAAMkB,MAAM,CAACC,IAAI,CAAC,CAACF,QAAUA,MAAMG,IAAI,KAAKL,eAAeM,SAAS;QAClF,IAAI,CAACJ,SAAS,CAACA,OAAOD,QAAQM,UAAU,CAACP,gBAAgB;YACvD;QACF;QAEAjB,oCAAoC;YAClCI;YACAC;YACAoB,MAAMR;YACNX;YACAC;YACAC;YACAC;YACAS,QAAQC,MAAMD,MAAM;YACpBR;YACAC;YACAE;YACAC;YACAC;YACAC;YACAU,YAAYT;QACd;IACF;IAEA,OAAOd;AACT,EAAC"}

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

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

package/dist/features/blocks/i18n.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/features/blocks/i18n.ts"],"sourcesContent":["import type { GenericLanguages } from '@payloadcms/translations'\n\nexport const i18n: Partial<GenericLanguages> = {\n  ar: {\n    label: 'كتل',\n  },\n  az: {\n    label: 'Bloklar',\n  },\n  bg: {\n    label: 'Блокове',\n  },\n  cs: {\n    label: 'Bloky',\n  },\n  de: {\n    label: 'Blöcke',\n  },\n  en: {\n    label: 'Blocks',\n  },\n  es: {\n    label: 'Bloques',\n  },\n  fa: {\n    label: 'بلوک ها',\n  },\n  fr: {\n    label: 'Blocs',\n  },\n  he: {\n    label: 'חסימות',\n  },\n  hr: {\n    label: 'Blokovi',\n  },\n  hu: {\n    label: 'Blokkok',\n  },\n  it: {\n    label: 'Blocchi',\n  },\n  ja: {\n    label: 'ブロック',\n  },\n  ko: {\n    label: '블록',\n  },\n  my: {\n    label: 'တံတားများ',\n  },\n  nb: {\n    label: 'Blokker',\n  },\n  nl: {\n    label: 'Blokken',\n  },\n  pl: {\n    label: 'Bloki',\n  },\n  pt: {\n    label: 'Blocos',\n  },\n  ro: {\n    label: 'Blocuri',\n  },\n  rs: {\n    label: 'Blokovi',\n  },\n  'rs-latin': {\n    label: 'Blokovi',\n  },\n  ru: {\n    label: 'Блоки',\n  },\n  sk: {\n    label: 'Bloky',\n  },\n  sv: {\n    label: 'Block',\n  },\n  th: {\n    label: 'บล็อค',\n  },\n  tr: {\n    label: 'Bloklar',\n  },\n  uk: {\n    label: 'Блоки',\n  },\n  vi: {\n    label: 'Khối',\n  },\n  zh: {\n    label: '块',\n  },\n  'zh-TW': {\n    label: '區塊',\n  },\n}\n"],"names":["i18n","ar","label","az","bg","cs","de","en","es","fa","fr","he","hr","hu","it","ja","ko","my","nb","nl","pl","pt","ro","rs","ru","sk","sv","th","tr","uk","vi","zh"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAEA,OAAO,MAAMA,OAAkC;IAC7CC,IAAI;QACFC,OAAO;IACT;IACAC,IAAI;QACFD,OAAO;IACT;IACAE,IAAI;QACFF,OAAO;IACT;IACAG,IAAI;QACFH,OAAO;IACT;IACAI,IAAI;QACFJ,OAAO;IACT;IACAK,IAAI;QACFL,OAAO;IACT;IACAM,IAAI;QACFN,OAAO;IACT;IACAO,IAAI;QACFP,OAAO;IACT;IACAQ,IAAI;QACFR,OAAO;IACT;IACAS,IAAI;QACFT,OAAO;IACT;IACAU,IAAI;QACFV,OAAO;IACT;IACAW,IAAI;QACFX,OAAO;IACT;IACAY,IAAI;QACFZ,OAAO;IACT;IACAa,IAAI;QACFb,OAAO;IACT;IACAc,IAAI;QACFd,OAAO;IACT;IACAe,IAAI;QACFf,OAAO;IACT;IACAgB,IAAI;QACFhB,OAAO;IACT;IACAiB,IAAI;QACFjB,OAAO;IACT;IACAkB,IAAI;QACFlB,OAAO;IACT;IACAmB,IAAI;QACFnB,OAAO;IACT;IACAoB,IAAI;QACFpB,OAAO;IACT;IACAqB,IAAI;QACFrB,OAAO;IACT;IACA,YAAY;QACVA,OAAO;IACT;IACAsB,IAAI;QACFtB,OAAO;IACT;IACAuB,IAAI;QACFvB,OAAO;IACT;IACAwB,IAAI;QACFxB,OAAO;IACT;IACAyB,IAAI;QACFzB,OAAO;IACT;IACA0B,IAAI;QACF1B,OAAO;IACT;IACA2B,IAAI;QACF3B,OAAO;IACT;IACA4B,IAAI;QACF5B,OAAO;IACT;IACA6B,IAAI;QACF7B,OAAO;IACT;IACA,SAAS;QACPA,OAAO;IACT;AACF,EAAC"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"BlocksNode.d.ts","sourceRoot":"","sources":["../../../../src/features/blocks/nodes/BlocksNode.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,6CAA6C,CAAA;AAC/F,OAAO,KAAK,EACV,gBAAgB,EAChB,eAAe,EACf,YAAY,EACZ,iBAAiB,EACjB,aAAa,EACb,WAAW,EACX,OAAO,EACP,MAAM,EACP,MAAM,SAAS,CAAA;AAEhB,OAAO,EAAE,kBAAkB,EAAE,MAAM,6CAA6C,CAAA;AAEhF,OAAc,EAAE,KAAK,GAAG,EAAE,MAAM,OAAO,CAAA;AAEvC,MAAM,MAAM,WAAW,GAAG;IACxB,sBAAsB;IACtB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,EAAE,EAAE,MAAM,CAAA;CACX,CAAA;AAQD,MAAM,MAAM,mBAAmB,GAAG,MAAM,CACtC;IACE,MAAM,EAAE,WAAW,CAAA;CACpB,EACD,4BAA4B,CAC7B,CAAA;AAED,qBAAa,SAAU,SAAQ,kBAAkB;IAC/C,QAAQ,EAAE,WAAW,CAAA;gBAET,EACV,MAAM,EACN,MAAM,EACN,GAAG,GACJ,EAAE;QACD,MAAM,EAAE,WAAW,CAAA;QACnB,MAAM,CAAC,EAAE,iBAAiB,CAAA;QAC1B,GAAG,CAAC,EAAE,OAAO,CAAA;KACd;IAKD,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS;IAQxC,MAAM,CAAC,OAAO,IAAI,MAAM;IAIxB,MAAM,CAAC,SAAS,IAAI,gBAAgB,CAAC,cAAc,CAAC,GAAG,IAAI;IAI3D,MAAM,CAAC,UAAU,CAAC,cAAc,EAAE,mBAAmB,GAAG,SAAS;IAgBjE,MAAM,CAAC,QAAQ,IAAI,KAAK;IAGxB,QAAQ,CAAC,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,YAAY,GAAG,GAAG,CAAC,OAAO;IAKlE,SAAS,IAAI,eAAe;IAQ5B,UAAU,IAAI,mBAAmB;IASjC,SAAS,IAAI,WAAW;IAIxB,cAAc,IAAI,MAAM;IAIxB,SAAS,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI;CAMrC;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,OAAO,CAAC,WAAW,EAAE,IAAI,CAAC,GAAG,SAAS,CAO9E;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,SAAS,GAAG,WAAW,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,IAAI,SAAS,CAEhG"}

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/features/blocks/nodes/BlocksNode.tsx"],"sourcesContent":["import type { SerializedDecoratorBlockNode } from '@lexical/react/LexicalDecoratorBlockNode.js'\nimport type {\n  DOMConversionMap,\n  DOMExportOutput,\n  EditorConfig,\n  ElementFormatType,\n  LexicalEditor,\n  LexicalNode,\n  NodeKey,\n  Spread,\n} from 'lexical'\n\nimport { DecoratorBlockNode } from '@lexical/react/LexicalDecoratorBlockNode.js'\nimport ObjectID from 'bson-objectid'\nimport React, { type JSX } from 'react'\n\nexport type BlockFields = {\n  /** Block form data */\n  [key: string]: any\n  blockName: string\n  blockType: string\n  id: string\n}\n\nconst BlockComponent = React.lazy(() =>\n  import('../component/index.js').then((module) => ({\n    default: module.BlockComponent,\n  })),\n)\n\nexport type SerializedBlockNode = Spread<\n  {\n    fields: BlockFields\n  },\n  SerializedDecoratorBlockNode\n>\n\nexport class BlockNode extends DecoratorBlockNode {\n  __fields: BlockFields\n\n  constructor({\n    fields,\n    format,\n    key,\n  }: {\n    fields: BlockFields\n    format?: ElementFormatType\n    key?: NodeKey\n  }) {\n    super(format, key)\n    this.__fields = fields\n  }\n\n  static clone(node: BlockNode): BlockNode {\n    return new BlockNode({\n      fields: node.__fields,\n      format: node.__format,\n      key: node.__key,\n    })\n  }\n\n  static getType(): string {\n    return 'block'\n  }\n\n  static importDOM(): DOMConversionMap<HTMLDivElement> | null {\n    return {}\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  static isInline(): false {\n    return false\n  }\n  decorate(editor: LexicalEditor, config: EditorConfig): JSX.Element {\n    // @ts-expect-error\n    return <BlockComponent formData={this.getFields()} nodeKey={this.getKey()} />\n  }\n\n  exportDOM(): DOMExportOutput {\n    const element = document.createElement('div')\n\n    const text = document.createTextNode(this.getTextContent())\n    element.append(text)\n    return { element }\n  }\n\n  exportJSON(): SerializedBlockNode {\n    return {\n      ...super.exportJSON(),\n      type: this.getType(),\n      fields: this.getFields(),\n      version: 2,\n    }\n  }\n\n  getFields(): BlockFields {\n    return this.getLatest().__fields\n  }\n\n  getTextContent(): string {\n    return `Block Field`\n  }\n\n  setFields(fields: BlockFields): void {\n    const fieldsCopy = JSON.parse(JSON.stringify(fields)) as BlockFields\n\n    const writable = this.getWritable()\n    writable.__fields = fieldsCopy\n  }\n}\n\nexport function $createBlockNode(fields: Exclude<BlockFields, 'id'>): 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"],"names":["DecoratorBlockNode","ObjectID","React","BlockComponent","lazy","then","module","default","BlockNode","__fields","constructor","fields","format","key","clone","node","__format","__key","getType","importDOM","importJSON","serializedNode","version","data","$createBlockNode","setFormat","isInline","decorate","editor","config","formData","getFields","nodeKey","getKey","exportDOM","element","document","createElement","text","createTextNode","getTextContent","append","exportJSON","type","getLatest","setFields","fieldsCopy","JSON","parse","stringify","writable","getWritable","id","toHexString","$isBlockNode"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";AAYA,SAASA,kBAAkB,QAAQ,8CAA6C;AAChF,OAAOC,cAAc,gBAAe;AACpC,OAAOC,WAAyB,QAAO;AAUvC,MAAMC,+BAAiBD,MAAME,IAAI,CAAC,IAChC,MAAM,CAAC,yBAAyBC,IAAI,CAAC,CAACC,SAAY,CAAA;YAChDC,SAASD,OAAOH,cAAc;QAChC,CAAA;AAUF,OAAO,MAAMK,kBAAkBR;IAC7BS,SAAqB;IAErBC,YAAY,EACVC,MAAM,EACNC,MAAM,EACNC,GAAG,EAKJ,CAAE;QACD,KAAK,CAACD,QAAQC;QACd,IAAI,CAACJ,QAAQ,GAAGE;IAClB;IAEA,OAAOG,MAAMC,IAAe,EAAa;QACvC,OAAO,IAAIP,UAAU;YACnBG,QAAQI,KAAKN,QAAQ;YACrBG,QAAQG,KAAKC,QAAQ;YACrBH,KAAKE,KAAKE,KAAK;QACjB;IACF;IAEA,OAAOC,UAAkB;QACvB,OAAO;IACT;IAEA,OAAOC,YAAqD;QAC1D,OAAO,CAAC;IACV;IAEA,OAAOC,WAAWC,cAAmC,EAAa;QAChE,IAAIA,eAAeC,OAAO,KAAK,GAAG;YAChC,mFAAmF;YACnFD,iBAAiB;gBACf,GAAGA,cAAc;gBACjBV,QAAQ;oBACN,GAAG,AAACU,eAAuBV,MAAM,CAACY,IAAI;gBACxC;gBACAD,SAAS;YACX;QACF;QACA,MAAMP,OAAOS,iBAAiBH,eAAeV,MAAM;QACnDI,KAAKU,SAAS,CAACJ,eAAeT,MAAM;QACpC,OAAOG;IACT;IAEA,OAAOW,WAAkB;QACvB,OAAO;IACT;IACAC,SAASC,MAAqB,EAAEC,MAAoB,EAAe;QACjE,mBAAmB;QACnB,qBAAO,KAAC1B;YAAe2B,UAAU,IAAI,CAACC,SAAS;YAAIC,SAAS,IAAI,CAACC,MAAM;;IACzE;IAEAC,YAA6B;QAC3B,MAAMC,UAAUC,SAASC,aAAa,CAAC;QAEvC,MAAMC,OAAOF,SAASG,cAAc,CAAC,IAAI,CAACC,cAAc;QACxDL,QAAQM,MAAM,CAACH;QACf,OAAO;YAAEH;QAAQ;IACnB;IAEAO,aAAkC;QAChC,OAAO;YACL,GAAG,KAAK,CAACA,YAAY;YACrBC,MAAM,IAAI,CAACzB,OAAO;YAClBP,QAAQ,IAAI,CAACoB,SAAS;YACtBT,SAAS;QACX;IACF;IAEAS,YAAyB;QACvB,OAAO,IAAI,CAACa,SAAS,GAAGnC,QAAQ;IAClC;IAEA+B,iBAAyB;QACvB,OAAO,CAAC,WAAW,CAAC;IACtB;IAEAK,UAAUlC,MAAmB,EAAQ;QACnC,MAAMmC,aAAaC,KAAKC,KAAK,CAACD,KAAKE,SAAS,CAACtC;QAE7C,MAAMuC,WAAW,IAAI,CAACC,WAAW;QACjCD,SAASzC,QAAQ,GAAGqC;IACtB;AACF;AAEA,OAAO,SAAStB,iBAAiBb,MAAkC;IACjE,OAAO,IAAIH,UAAU;QACnBG,QAAQ;YACN,GAAGA,MAAM;YACTyC,IAAIzC,QAAQyC,MAAM,IAAInD,SAASM,OAAO,GAAG8C,WAAW;QACtD;IACF;AACF;AAEA,OAAO,SAASC,aAAavC,IAAgD;IAC3E,OAAOA,gBAAgBP;AACzB"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/features/blocks/plugin/commands.ts"],"sourcesContent":["import 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"],"names":["createCommand","INSERT_BLOCK_COMMAND"],"rangeMappings":";","mappings":"AAEA,SAASA,aAAa,QAAQ,UAAS;AAIvC,OAAO,MAAMC,uBACXD,cAAc,wBAAuB"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/features/blocks/plugin/index.tsx"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AACrD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAA;AACpE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AAMzD,MAAM,MAAM,kBAAkB,GAAG,OAAO,CAAC,WAAW,EAAE,IAAI,CAAC,CAAA;AAE3D,eAAO,MAAM,YAAY,EAAE,eAAe,CAAC,wBAAwB,CA8ClE,CAAA"}

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/features/blocks/plugin/index.tsx"],"sourcesContent":["'use client'\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext.js'\nimport { $insertNodeToNearestRoot, mergeRegister } from '@lexical/utils'\nimport {\n  $getPreviousSelection,\n  $getSelection,\n  $isParagraphNode,\n  $isRangeSelection,\n  COMMAND_PRIORITY_EDITOR,\n} from 'lexical'\nimport React, { useEffect } from 'react'\n\nimport type { PluginComponent } from '../../types.js'\nimport type { BlocksFeatureClientProps } from '../feature.client.js'\nimport type { BlockFields } from '../nodes/BlocksNode.js'\n\nimport { BlocksDrawerComponent } from '../drawer/index.js'\nimport { $createBlockNode, BlockNode } from '../nodes/BlocksNode.js'\nimport { INSERT_BLOCK_COMMAND } from './commands.js'\n\nexport type InsertBlockPayload = Exclude<BlockFields, 'id'>\n\nexport const BlocksPlugin: PluginComponent<BlocksFeatureClientProps> = () => {\n  const [editor] = useLexicalComposerContext()\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                  .getParent()\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    )\n  }, [editor])\n\n  return <BlocksDrawerComponent />\n}\n"],"names":["useLexicalComposerContext","$insertNodeToNearestRoot","mergeRegister","$getPreviousSelection","$getSelection","$isParagraphNode","$isRangeSelection","COMMAND_PRIORITY_EDITOR","React","useEffect","BlocksDrawerComponent","$createBlockNode","BlockNode","INSERT_BLOCK_COMMAND","BlocksPlugin","editor","hasNodes","Error","registerCommand","payload","update","selection","blockNode","focus","focusNode","getNode","getTextContentSize","getParent","getChildren","filter","node","length","remove"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;;AACA,SAASA,yBAAyB,QAAQ,2CAA0C;AACpF,SAASC,wBAAwB,EAAEC,aAAa,QAAQ,iBAAgB;AACxE,SACEC,qBAAqB,EACrBC,aAAa,EACbC,gBAAgB,EAChBC,iBAAiB,EACjBC,uBAAuB,QAClB,UAAS;AAChB,OAAOC,SAASC,SAAS,QAAQ,QAAO;AAMxC,SAASC,qBAAqB,QAAQ,qBAAoB;AAC1D,SAASC,gBAAgB,EAAEC,SAAS,QAAQ,yBAAwB;AACpE,SAASC,oBAAoB,QAAQ,gBAAe;AAIpD,OAAO,MAAMC,eAA0D;IACrE,MAAM,CAACC,OAAO,GAAGf;IAEjBS,UAAU;QACR,IAAI,CAACM,OAAOC,QAAQ,CAAC;YAACJ;SAAU,GAAG;YACjC,MAAM,IAAIK,MAAM;QAClB;QAEA,OAAOf,cACLa,OAAOG,eAAe,CACpBL,sBACA,CAACM;YACCJ,OAAOK,MAAM,CAAC;gBACZ,MAAMC,YAAYjB,mBAAmBD;gBAErC,IAAIG,kBAAkBe,YAAY;oBAChC,MAAMC,YAAYX,iBAAiBQ;oBACnC,8HAA8H;oBAC9HlB,yBAAyBqB;oBAEzB,MAAM,EAAEC,KAAK,EAAE,GAAGF;oBAClB,MAAMG,YAAYD,MAAME,OAAO;oBAE/B,+FAA+F;oBAC/F,0FAA0F;oBAC1F,IACEpB,iBAAiBmB,cACjBA,UAAUE,kBAAkB,OAAO,KACnCF,UACGG,SAAS,GACTC,WAAW,GACXC,MAAM,CAAC,CAACC,OAASzB,iBAAiByB,OAAOC,MAAM,GAAG,GACrD;wBACAP,UAAUQ,MAAM;oBAClB;gBACF;YACF;YAEA,OAAO;QACT,GACAzB;IAGN,GAAG;QAACQ;KAAO;IAEX,qBAAO,KAACL;AACV,EAAC"}

package/dist/features/blocks/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../src/features/blocks/validate.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AACjD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AAC7D,OAAO,KAAK,EAAe,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAE7E,eAAO,MAAM,kBAAkB,UACtB,kBAAkB,KACxB,eAAe,mBAAmB,CA2CpC,CAAA"}

package/dist/features/blocks/validate.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/features/blocks/validate.ts"],"sourcesContent":["import { buildStateFromSchema } from '@payloadcms/ui/forms/buildStateFromSchema'\n\nimport type { NodeValidation } from '../types.js'\nimport type { BlocksFeatureProps } from './feature.server.js'\nimport type { BlockFields, SerializedBlockNode } from './nodes/BlocksNode.js'\n\nexport const blockValidationHOC = (\n  props: BlocksFeatureProps,\n): NodeValidation<SerializedBlockNode> => {\n  return async ({ node, validation }) => {\n    const blockFieldData = node.fields ?? ({} as BlockFields)\n\n    const {\n      options: { id, operation, preferences, req },\n    } = validation\n\n    // find block\n    const block = props.blocks.find((block) => block.slug === blockFieldData.blockType)\n\n    // validate block\n    if (!block) {\n      return 'Block not found'\n    }\n\n    /**\n     * Run buildStateFromSchema as that properly validates block and block sub-fields\n     */\n\n    const result = await buildStateFromSchema({\n      id,\n      data: blockFieldData,\n      fieldSchema: block.fields,\n      operation: operation === 'create' || operation === 'update' ? operation : 'update',\n      preferences,\n      req,\n      siblingData: blockFieldData,\n    })\n\n    let errorPaths = []\n    for (const fieldKey in result) {\n      if (result[fieldKey].errorPaths) {\n        errorPaths = errorPaths.concat(result[fieldKey].errorPaths)\n      }\n    }\n\n    if (errorPaths.length) {\n      return 'The following fields are invalid: ' + errorPaths.join(', ')\n    }\n\n    return true\n  }\n}\n"],"names":["buildStateFromSchema","blockValidationHOC","props","node","validation","blockFieldData","fields","options","id","operation","preferences","req","block","blocks","find","slug","blockType","result","data","fieldSchema","siblingData","errorPaths","fieldKey","concat","length","join"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,oBAAoB,QAAQ,4CAA2C;AAMhF,OAAO,MAAMC,qBAAqB,CAChCC;IAEA,OAAO,OAAO,EAAEC,IAAI,EAAEC,UAAU,EAAE;QAChC,MAAMC,iBAAiBF,KAAKG,MAAM,IAAK,CAAC;QAExC,MAAM,EACJC,SAAS,EAAEC,EAAE,EAAEC,SAAS,EAAEC,WAAW,EAAEC,GAAG,EAAE,EAC7C,GAAGP;QAEJ,aAAa;QACb,MAAMQ,QAAQV,MAAMW,MAAM,CAACC,IAAI,CAAC,CAACF,QAAUA,MAAMG,IAAI,KAAKV,eAAeW,SAAS;QAElF,iBAAiB;QACjB,IAAI,CAACJ,OAAO;YACV,OAAO;QACT;QAEA;;KAEC,GAED,MAAMK,SAAS,MAAMjB,qBAAqB;YACxCQ;YACAU,MAAMb;YACNc,aAAaP,MAAMN,MAAM;YACzBG,WAAWA,cAAc,YAAYA,cAAc,WAAWA,YAAY;YAC1EC;YACAC;YACAS,aAAaf;QACf;QAEA,IAAIgB,aAAa,EAAE;QACnB,IAAK,MAAMC,YAAYL,OAAQ;YAC7B,IAAIA,MAAM,CAACK,SAAS,CAACD,UAAU,EAAE;gBAC/BA,aAAaA,WAAWE,MAAM,CAACN,MAAM,CAACK,SAAS,CAACD,UAAU;YAC5D;QACF;QAEA,IAAIA,WAAWG,MAAM,EAAE;YACrB,OAAO,uCAAuCH,WAAWI,IAAI,CAAC;QAChE;QAEA,OAAO;IACT;AACF,EAAC"}

package/dist/features/converters/html/converter/converters/linebreak.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linebreak.d.ts","sourceRoot":"","sources":["../../../../../../src/features/converters/html/converter/converters/linebreak.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAA;AAEtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAEhD,eAAO,MAAM,sBAAsB,EAAE,aAAa,CAAC,uBAAuB,CAKzE,CAAA"}

package/dist/features/converters/html/converter/converters/linebreak.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/features/converters/html/converter/converters/linebreak.ts"],"sourcesContent":["import type { SerializedParagraphNode } from 'lexical'\n\nimport type { HTMLConverter } from '../types.js'\n\nexport const LinebreakHTMLConverter: HTMLConverter<SerializedParagraphNode> = {\n  converter() {\n    return `<br>`\n  },\n  nodeTypes: ['linebreak'],\n}\n"],"names":["LinebreakHTMLConverter","converter","nodeTypes"],"rangeMappings":";;;;;;;","mappings":"AAIA,OAAO,MAAMA,yBAAiE;IAC5EC;QACE,OAAO,CAAC,IAAI,CAAC;IACf;IACAC,WAAW;QAAC;KAAY;AAC1B,EAAC"}

package/dist/features/converters/html/converter/converters/paragraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paragraph.d.ts","sourceRoot":"","sources":["../../../../../../src/features/converters/html/converter/converters/paragraph.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAA;AAEtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAIhD,eAAO,MAAM,sBAAsB,EAAE,aAAa,CAAC,uBAAuB,CAczE,CAAA"}

package/dist/features/converters/html/converter/converters/paragraph.js

@@ -0,0 +1,20 @@
+import { convertLexicalNodesToHTML } from '../index.js';
+export const ParagraphHTMLConverter = {
+    async converter ({ converters, node, parent, req }) {
+        const childrenText = await convertLexicalNodesToHTML({
+            converters,
+            lexicalNodes: node.children,
+            parent: {
+                ...node,
+                parent
+            },
+            req
+        });
+        return `<p>${childrenText}</p>`;
+    },
+    nodeTypes: [
+        'paragraph'
+    ]
+};
+
+//# sourceMappingURL=paragraph.js.map

package/dist/features/converters/html/converter/converters/paragraph.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/features/converters/html/converter/converters/paragraph.ts"],"sourcesContent":["import type { SerializedParagraphNode } from 'lexical'\n\nimport type { HTMLConverter } from '../types.js'\n\nimport { convertLexicalNodesToHTML } from '../index.js'\n\nexport const ParagraphHTMLConverter: HTMLConverter<SerializedParagraphNode> = {\n  async converter({ converters, node, parent, req }) {\n    const childrenText = await convertLexicalNodesToHTML({\n      converters,\n      lexicalNodes: node.children,\n      parent: {\n        ...node,\n        parent,\n      },\n      req,\n    })\n    return `<p>${childrenText}</p>`\n  },\n  nodeTypes: ['paragraph'],\n}\n"],"names":["convertLexicalNodesToHTML","ParagraphHTMLConverter","converter","converters","node","parent","req","childrenText","lexicalNodes","children","nodeTypes"],"rangeMappings":";;;;;;;;;;;;;;;;;","mappings":"AAIA,SAASA,yBAAyB,QAAQ,cAAa;AAEvD,OAAO,MAAMC,yBAAiE;IAC5E,MAAMC,WAAU,EAAEC,UAAU,EAAEC,IAAI,EAAEC,MAAM,EAAEC,GAAG,EAAE;QAC/C,MAAMC,eAAe,MAAMP,0BAA0B;YACnDG;YACAK,cAAcJ,KAAKK,QAAQ;YAC3BJ,QAAQ;gBACN,GAAGD,IAAI;gBACPC;YACF;YACAC;QACF;QACA,OAAO,CAAC,GAAG,EAAEC,aAAa,IAAI,CAAC;IACjC;IACAG,WAAW;QAAC;KAAY;AAC1B,EAAC"}

package/dist/features/converters/html/converter/converters/text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../../../../../src/features/converters/html/converter/converters/text.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AAEjD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAIhD,eAAO,MAAM,iBAAiB,EAAE,aAAa,CAAC,kBAAkB,CA6B/D,CAAA"}

package/dist/features/converters/html/converter/converters/text.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/features/converters/html/converter/converters/text.ts"],"sourcesContent":["import type { SerializedTextNode } from 'lexical'\n\nimport type { HTMLConverter } from '../types.js'\n\nimport { NodeFormat } from '../../../../../lexical/utils/nodeFormat.js'\n\nexport const TextHTMLConverter: HTMLConverter<SerializedTextNode> = {\n  converter({ node }) {\n    let text = node.text\n\n    if (node.format & NodeFormat.IS_BOLD) {\n      text = `<strong>${text}</strong>`\n    }\n    if (node.format & NodeFormat.IS_ITALIC) {\n      text = `<em>${text}</em>`\n    }\n    if (node.format & NodeFormat.IS_STRIKETHROUGH) {\n      text = `<span style=\"text-decoration: line-through\">${text}</span>`\n    }\n    if (node.format & NodeFormat.IS_UNDERLINE) {\n      text = `<span style=\"text-decoration: underline\">${text}</span>`\n    }\n    if (node.format & NodeFormat.IS_CODE) {\n      text = `<code>${text}</code>`\n    }\n    if (node.format & NodeFormat.IS_SUBSCRIPT) {\n      text = `<sub>${text}</sub>`\n    }\n    if (node.format & NodeFormat.IS_SUPERSCRIPT) {\n      text = `<sup>${text}</sup>`\n    }\n\n    return text\n  },\n  nodeTypes: ['text'],\n}\n"],"names":["NodeFormat","TextHTMLConverter","converter","node","text","format","IS_BOLD","IS_ITALIC","IS_STRIKETHROUGH","IS_UNDERLINE","IS_CODE","IS_SUBSCRIPT","IS_SUPERSCRIPT","nodeTypes"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAIA,SAASA,UAAU,QAAQ,6CAA4C;AAEvE,OAAO,MAAMC,oBAAuD;IAClEC,WAAU,EAAEC,IAAI,EAAE;QAChB,IAAIC,OAAOD,KAAKC,IAAI;QAEpB,IAAID,KAAKE,MAAM,GAAGL,WAAWM,OAAO,EAAE;YACpCF,OAAO,CAAC,QAAQ,EAAEA,KAAK,SAAS,CAAC;QACnC;QACA,IAAID,KAAKE,MAAM,GAAGL,WAAWO,SAAS,EAAE;YACtCH,OAAO,CAAC,IAAI,EAAEA,KAAK,KAAK,CAAC;QAC3B;QACA,IAAID,KAAKE,MAAM,GAAGL,WAAWQ,gBAAgB,EAAE;YAC7CJ,OAAO,CAAC,4CAA4C,EAAEA,KAAK,OAAO,CAAC;QACrE;QACA,IAAID,KAAKE,MAAM,GAAGL,WAAWS,YAAY,EAAE;YACzCL,OAAO,CAAC,yCAAyC,EAAEA,KAAK,OAAO,CAAC;QAClE;QACA,IAAID,KAAKE,MAAM,GAAGL,WAAWU,OAAO,EAAE;YACpCN,OAAO,CAAC,MAAM,EAAEA,KAAK,OAAO,CAAC;QAC/B;QACA,IAAID,KAAKE,MAAM,GAAGL,WAAWW,YAAY,EAAE;YACzCP,OAAO,CAAC,KAAK,EAAEA,KAAK,MAAM,CAAC;QAC7B;QACA,IAAID,KAAKE,MAAM,GAAGL,WAAWY,cAAc,EAAE;YAC3CR,OAAO,CAAC,KAAK,EAAEA,KAAK,MAAM,CAAC;QAC7B;QAEA,OAAOA;IACT;IACAS,WAAW;QAAC;KAAO;AACrB,EAAC"}