@payloadcms/richtext-lexical 0.7.0 → 3.0.0-alpha.19

package/dist/field/features/blocks/component/FormSavePlugin.js

@@ -0,0 +1,24 @@
+import { reduceFieldsToValues, useAllFormFields } from '@payloadcms/ui';
+import { useEffect } from 'react';
+export const FormSavePlugin = (props)=>{
+    const { onChange } = props;
+    const [fields, dispatchFields] = useAllFormFields();
+    // Pass in fields, and indicate if you'd like to "unflatten" field data.
+    // The result below will reflect the data stored in the form at the given time
+    const newFormData = reduceFieldsToValues(fields, true);
+    useEffect(()=>{
+        if (onChange) {
+            onChange({
+                fullFieldsWithValues: fields,
+                newFormData
+            });
+        }
+    }, [
+        newFormData,
+        onChange,
+        fields
+    ]);
+    return null;
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/field/features/blocks/component/index.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import { type BlockFields } from '../nodes/BlocksNode';
+import './index.scss';
+type Props = {
+    blockFieldWrapperName: string;
+    children?: React.ReactNode;
+    formData: BlockFields;
+    nodeKey?: string;
+    /**
+     * This transformedFormData already comes wrapped in blockFieldWrapperName
+     */
+    transformedFormData: BlockFields;
+};
+export declare const BlockComponent: React.FC<Props>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/field/features/blocks/component/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/blocks/component/index.tsx"],"names":[],"mappings":"AAWA,OAAO,KAAoD,MAAM,OAAO,CAAA;AAExE,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,qBAAqB,CAAA;AAatD,OAAO,cAAc,CAAA;AAErB,KAAK,KAAK,GAAG;IACX,qBAAqB,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IAE1B,QAAQ,EAAE,WAAW,CAAA;IACrB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB;;OAEG;IACH,mBAAmB,EAAE,WAAW,CAAA;CACjC,CAAA;AAED,eAAO,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC,KAAK,CAuH1C,CAAA"}

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

@@ -0,0 +1,121 @@
+'use client';
+import { FieldPathProvider, Form, getFormState, useConfig, useDocumentInfo, useFieldPath, useFormSubmitted } from '@payloadcms/ui';
+import React, { useCallback, useEffect, useMemo, useState } from 'react';
+const baseClass = 'lexical-block';
+import { v4 as uuid } from 'uuid';
+import { useEditorConfigContext } from '../../../lexical/config/client/EditorConfigProvider';
+import { BlockContent } from './BlockContent';
+import './index.scss';
+export const BlockComponent = (props)=>{
+    const { blockFieldWrapperName, formData, nodeKey } = props;
+    const config = useConfig();
+    const submitted = useFormSubmitted();
+    const { id } = useDocumentInfo();
+    const { schemaPath } = useFieldPath();
+    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,
+                    blockName2: {
+                        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,
+            blockName2: {
+                initialValue: '',
+                passesCondition: true,
+                valid: true,
+                value: formData.blockName
+            }
+        };
+    }, [
+        config.routes.api,
+        config.serverURL,
+        schemaFieldsPath,
+        id,
+        formData.blockName
+    ]);
+    // Memoized Form JSX
+    const formContent = useMemo(()=>{
+        return reducedBlock && initialState !== false && /*#__PURE__*/ React.createElement(FieldPathProvider, {
+            path: "",
+            schemaPath: ""
+        }, /*#__PURE__*/ React.createElement(Form, {
+            // @ts-expect-error // TODO: Fix this type. Is this correct?
+            fields: fieldMap,
+            initialState: initialState,
+            onChange: [
+                onChange
+            ],
+            submitted: submitted,
+            uuid: uuid()
+        }, /*#__PURE__*/ React.createElement(BlockContent, {
+            baseClass: baseClass,
+            field: parentLexicalRichTextField,
+            formData: formData,
+            formSchema: Array.isArray(fieldMap) ? fieldMap : [],
+            nodeKey: nodeKey,
+            reducedBlock: reducedBlock
+        })));
+    }, [
+        fieldMap,
+        parentLexicalRichTextField,
+        nodeKey,
+        submitted,
+        initialState,
+        reducedBlock,
+        blockFieldWrapperName,
+        onChange
+    ]);
+    return /*#__PURE__*/ React.createElement("div", {
+        className: baseClass
+    }, formContent);
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../src/field/features/blocks/component/index.tsx"],"sourcesContent":["'use client'\nimport {\n  FieldPathProvider,\n  Form,\n  type FormProps,\n  getFormState,\n  useConfig,\n  useDocumentInfo,\n  useFieldPath,\n  useFormSubmitted,\n} from '@payloadcms/ui'\nimport React, { useCallback, useEffect, useMemo, useState } from 'react'\n\nimport { type BlockFields } from '../nodes/BlocksNode'\nconst baseClass = 'lexical-block'\n\nimport type { ReducedBlock } from '@payloadcms/ui/types'\nimport type { FormState } from 'payload/types'\n\nimport { v4 as uuid } from 'uuid'\n\nimport type { ClientComponentProps } from '../../types'\nimport type { BlocksFeatureClientProps } from '../feature.client'\n\nimport { useEditorConfigContext } from '../../../lexical/config/client/EditorConfigProvider'\nimport { BlockContent } from './BlockContent'\nimport './index.scss'\n\ntype Props = {\n  blockFieldWrapperName: string\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 { blockFieldWrapperName, formData, nodeKey } = props\n  const config = useConfig()\n  const submitted = useFormSubmitted()\n  const { id } = useDocumentInfo()\n  const { schemaPath } = useFieldPath()\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          blockName2: {\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        blockName2: {\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\n  // Memoized Form JSX\n  const formContent = useMemo(() => {\n    return (\n      reducedBlock &&\n      initialState !== false && (\n        <FieldPathProvider path=\"\" schemaPath=\"\">\n          <Form\n            // @ts-expect-error // TODO: Fix this type. Is this correct?\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              reducedBlock={reducedBlock}\n            />\n          </Form>\n        </FieldPathProvider>\n      )\n    )\n  }, [\n    fieldMap,\n    parentLexicalRichTextField,\n    nodeKey,\n    submitted,\n    initialState,\n    reducedBlock,\n    blockFieldWrapperName,\n    onChange,\n  ])\n\n  return <div className={baseClass}>{formContent}</div>\n}\n"],"names":["FieldPathProvider","Form","getFormState","useConfig","useDocumentInfo","useFieldPath","useFormSubmitted","React","useCallback","useEffect","useMemo","useState","baseClass","v4","uuid","useEditorConfigContext","BlockContent","BlockComponent","props","blockFieldWrapperName","formData","nodeKey","config","submitted","id","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","blockName2","initialValue","passesCondition","valid","value","blockName","onChange","formState","prevFormState","formContent","path","fields","formSchema","Array","isArray","div","className"],"mappings":"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"}

package/dist/field/features/blocks/component/index.scss

@@ -0,0 +1,153 @@
+@import '../../../../scss/styles.scss';
+
+.ContentEditable__root > div:has(.lexical-block) {
+  // Fixes a bug where, if the block field has a Select field, the Select field's dropdown menu would be hidden behind the lexical editor.
+  z-index: 1;
+}
+
+.lexical-block {
+  display: flex;
+  flex-direction: column;
+  gap: calc(var(--base) / 2);
+  font-family: var(
+    --font-body
+  ); // Reset font to non-serif, body font, as the lexical editor parent uses a serif font.
+
+  margin: 0 0 1.5em;
+
+  &__header {
+    h3 {
+      margin: 0;
+    }
+  }
+
+  &__header-wrap {
+    display: flex;
+    align-items: flex-end;
+    width: 100%;
+    justify-content: space-between;
+  }
+
+  &__heading-with-error {
+    display: flex;
+    align-items: center;
+    gap: calc(var(--base) * 0.5);
+  }
+
+  &--has-no-error {
+    > .array-field__header .array-field__heading-with-error {
+      color: var(--theme-text);
+    }
+  }
+
+  &--has-error {
+    > .array-field__header {
+      color: var(--theme-error-500);
+    }
+  }
+
+  &__error-pill {
+    align-self: center;
+  }
+
+  &__header-actions {
+    list-style: none;
+    margin: 0;
+    padding: 0;
+    display: flex;
+  }
+
+  &__header-action {
+    @extend %btn-reset;
+    cursor: pointer;
+    margin-left: calc(var(--base) * 0.5);
+
+    &:hover,
+    &:focus-visible {
+      text-decoration: underline;
+    }
+  }
+
+  .collapsible {
+    &__header-wrap {
+      //  Make more space for the block header (default right: is `calc(var(--base) * 3)`) so that the remove button aligns nicely to the right
+      right: calc(var(--base) * 1.5);
+    }
+  }
+
+  &__removeButton.btn {
+    margin: 0;
+  }
+
+  &__block-header {
+    pointer-events: none;
+  }
+
+  &__block-header * {
+    pointer-events: all;
+  }
+
+  &__block-header,
+  &__block-header > div {
+    display: flex;
+    max-width: 100%;
+    overflow: hidden;
+    gap: calc(var(--base) * 0.375);
+    justify-content: space-between;
+  }
+
+  &__block-number {
+    flex-shrink: 0;
+  }
+
+  &__block-pill {
+    flex-shrink: 0;
+    display: block;
+    line-height: unset;
+  }
+
+  &__error-wrap {
+    position: relative;
+  }
+
+  &__rows {
+    display: flex;
+    flex-direction: column;
+    gap: calc(var(--base) / 2);
+  }
+
+  &__drawer-toggler {
+    background-color: transparent;
+    margin: 0;
+    padding: 0;
+    border: none;
+    align-self: flex-start;
+
+    .btn {
+      color: var(--theme-elevation-400);
+      margin: 0;
+
+      &:hover {
+        color: var(--theme-elevation-800);
+      }
+    }
+  }
+}
+
+html[data-theme='light'] {
+  .blocks-field--has-error {
+    .section-title__input,
+    .blocks-field__heading-with-error {
+      color: var(--theme-error-750);
+    }
+  }
+}
+
+html[data-theme='dark'] {
+  .blocks-field--has-error {
+    .section-title__input,
+    .blocks-field__heading-with-error {
+      color: var(--theme-error-500);
+    }
+  }
+}

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/blocks/drawer/index.tsx"],"names":[],"mappings":"AAIA,OAAO,EAGL,KAAK,cAAc,EAGpB,MAAM,SAAS,CAAA;AAChB,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/field/features/blocks/drawer/index.js

@@ -0,0 +1,78 @@
+'use client';
+import { useModal } from '@faceless-ui/modal';
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { BlocksDrawer, formatDrawerSlug, useEditDepth, 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';
+import { $createBlockNode } from '../nodes/BlocksNode';
+import { INSERT_BLOCK_COMMAND } from '../plugin/commands';
+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__*/ React.createElement(BlocksDrawer, {
+        addRow: addRow,
+        addRowIndex: 0,
+        blocks: reducedBlocks,
+        drawerSlug: drawerSlug,
+        labels: labels
+    });
+};
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import type { ReducedBlock } from '@payloadcms/ui/types';
+export type BlocksFeatureClientProps = {
+    reducedBlocks: ReducedBlock[];
+};
+export declare const BlocksFeatureClientComponent: import("react").FC<import("../types").ClientComponentProps<BlocksFeatureClientProps>>;
+//# sourceMappingURL=feature.client.d.ts.map

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

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

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

@@ -0,0 +1,61 @@
+'use client';
+import { getTranslation } from '@payloadcms/translations';
+import { SlashMenuOption } from '../../lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/types';
+import { BlockIcon } from '../../lexical/ui/icons/Block';
+import { createClientComponent } from '../createClientComponent';
+import { BlockNode } from './nodes/BlocksNode';
+import { BlocksPlugin } from './plugin';
+import { INSERT_BLOCK_COMMAND } from './plugin/commands';
+const BlocksFeatureClient = (props)=>{
+    return {
+        clientFeatureProps: props,
+        feature: ()=>({
+                clientFeatureProps: props,
+                nodes: [
+                    BlockNode
+                ],
+                plugins: [
+                    {
+                        Component: BlocksPlugin,
+                        position: 'normal'
+                    }
+                ],
+                slashMenu: {
+                    options: [
+                        {
+                            displayName: 'Blocks',
+                            key: 'blocks',
+                            options: [
+                                ...props.reducedBlocks.map((block)=>{
+                                    return new SlashMenuOption('block-' + block.slug, {
+                                        Icon: BlockIcon,
+                                        displayName: ({ i18n })=>{
+                                            if (!block.labels.singular) {
+                                                return block.slug;
+                                            }
+                                            return getTranslation(block.labels.singular, i18n);
+                                        },
+                                        keywords: [
+                                            'block',
+                                            'blocks',
+                                            block.slug
+                                        ],
+                                        onSelect: ({ editor })=>{
+                                            editor.dispatchCommand(INSERT_BLOCK_COMMAND, {
+                                                id: null,
+                                                blockName: '',
+                                                blockType: block.slug
+                                            });
+                                        }
+                                    });
+                                })
+                            ]
+                        }
+                    ]
+                }
+            })
+    };
+};
+export const BlocksFeatureClientComponent = createClientComponent(BlocksFeatureClient);
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,8 @@
+import type { Block } from 'payload/types';
+import type { FeatureProviderProviderServer } from '../types';
+import type { BlocksFeatureClientProps } from './feature.client';
+export type BlocksFeatureProps = {
+    blocks: Block[];
+};
+export declare const BlocksFeature: FeatureProviderProviderServer<BlocksFeatureProps, BlocksFeatureClientProps>;
+//# sourceMappingURL=feature.server.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"feature.server.d.ts","sourceRoot":"","sources":["../../../../src/field/features/blocks/feature.server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAqB,MAAM,eAAe,CAAA;AAK7D,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,UAAU,CAAA;AAC7D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,kBAAkB,CAAA;AAOhE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,MAAM,EAAE,KAAK,EAAE,CAAA;CAChB,CAAA;AAED,eAAO,MAAM,aAAa,EAAE,6BAA6B,CACvD,kBAAkB,EAClB,wBAAwB,CAmFzB,CAAA"}

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

@@ -0,0 +1,86 @@
+import { baseBlockFields, sanitizeFields } from 'payload/config';
+import { fieldsToJSONSchema, formatLabels } from 'payload/utilities';
+import { BlocksFeatureClientComponent } from './feature.client';
+import { BlockNode } from './nodes/BlocksNode';
+import { blockPopulationPromiseHOC } from './populationPromise';
+import { blockValidationHOC } from './validate';
+export const BlocksFeature = (props)=>{
+    // Sanitization taken from payload/src/fields/config/sanitize.ts
+    if (props?.blocks?.length) {
+        props.blocks = props.blocks.map((block)=>{
+            return {
+                ...block,
+                fields: block.fields.concat(baseBlockFields),
+                labels: !block.labels ? formatLabels(block.slug) : block.labels
+            };
+        });
+    //  unSanitizedBlock.fields are sanitized in the React component and not here.
+    // That's because we do not have access to the payload config here.
+    }
+    // Build clientProps
+    const clientProps = {
+        reducedBlocks: []
+    };
+    for (const block of props.blocks){
+        clientProps.reducedBlocks.push({
+            slug: block.slug,
+            imageAltText: block.imageAltText,
+            imageURL: block.imageURL,
+            labels: block.labels,
+            subfields: []
+        });
+    }
+    return {
+        feature: ()=>{
+            return {
+                ClientComponent: BlocksFeatureClientComponent,
+                clientFeatureProps: clientProps,
+                generateSchemaMap: ({ config, props })=>{
+                    const validRelationships = config.collections.map((c)=>c.slug) || [];
+                    const schemaMap = {};
+                    for (const block of props.blocks){
+                        const unSanitizedFormSchema = block.fields || [];
+                        const formSchema = sanitizeFields({
+                            config,
+                            fields: unSanitizedFormSchema,
+                            validRelationships
+                        });
+                        schemaMap[block.slug] = formSchema;
+                    }
+                    return schemaMap;
+                },
+                generatedTypes: {
+                    modifyOutputSchema: ({ currentSchema, field, interfaceNameDefinitions })=>{
+                        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({}, [
+                            blocksField
+                        ], interfaceNameDefinitions);
+                        return currentSchema;
+                    }
+                },
+                nodes: [
+                    {
+                        node: BlockNode,
+                        populationPromises: [
+                            blockPopulationPromiseHOC(props)
+                        ],
+                        validations: [
+                            blockValidationHOC(props)
+                        ]
+                    }
+                ],
+                serverFeatureProps: props
+            };
+        },
+        key: 'blocks',
+        serverFeatureProps: props
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1 @@
+{"version":3,"file":"BlocksNode.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/blocks/nodes/BlocksNode.tsx"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,0CAA0C,CAAA;AAC5F,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,0CAA0C,CAAA;AAI7E,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;AASD,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;IAIlE,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"}