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

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,172 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "BlockComponent", {
+    enumerable: true,
+    get: function() {
+        return BlockComponent;
+    }
+});
+const _ui = require("@payloadcms/ui");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _uuid = require("uuid");
+const _EditorConfigProvider = require("../../../lexical/config/client/EditorConfigProvider");
+const _BlockContent = require("./BlockContent");
+require("./index.scss");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const baseClass = 'lexical-block';
+const BlockComponent = (props)=>{
+    const { blockFieldWrapperName, formData, nodeKey } = props;
+    const config = (0, _ui.useConfig)();
+    const submitted = (0, _ui.useFormSubmitted)();
+    const { id } = (0, _ui.useDocumentInfo)();
+    const { schemaPath } = (0, _ui.useFieldPath)();
+    const { editorConfig, field: parentLexicalRichTextField } = (0, _EditorConfigProvider.useEditorConfigContext)();
+    const [initialState, setInitialState] = (0, _react.useState)(false);
+    const { field: { richTextComponentMap } } = (0, _EditorConfigProvider.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
+    (0, _react.useEffect)(()=>{
+        const awaitInitialState = async ()=>{
+            const state = await (0, _ui.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 = (0, _react.useCallback)(async ({ formState: prevFormState })=>{
+        const formState = await (0, _ui.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 = (0, _react.useMemo)(()=>{
+        return reducedBlock && initialState !== false && /*#__PURE__*/ _react.default.createElement(_ui.FieldPathProvider, {
+            path: "",
+            schemaPath: ""
+        }, /*#__PURE__*/ _react.default.createElement(_ui.Form, {
+            // @ts-expect-error // TODO: Fix this type. Is this correct?
+            fields: fieldMap,
+            initialState: initialState,
+            onChange: [
+                onChange
+            ],
+            submitted: submitted,
+            uuid: (0, _uuid.v4)()
+        }, /*#__PURE__*/ _react.default.createElement(_BlockContent.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.default.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":["BlockComponent","baseClass","props","blockFieldWrapperName","formData","nodeKey","config","useConfig","submitted","useFormSubmitted","id","useDocumentInfo","schemaPath","useFieldPath","editorConfig","field","parentLexicalRichTextField","useEditorConfigContext","initialState","setInitialState","useState","richTextComponentMap","componentMapRenderedFieldsPath","blockType","schemaFieldsPath","reducedBlock","resolvedFeatureMap","get","clientFeatureProps","reducedBlocks","find","block","slug","fieldMap","useEffect","awaitInitialState","state","getFormState","apiRoute","routes","api","body","data","JSON","parse","stringify","operation","serverURL","blockName2","initialValue","passesCondition","valid","value","blockName","onChange","useCallback","formState","prevFormState","formContent","useMemo","FieldPathProvider","path","Form","fields","uuid","BlockContent","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,137 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    BlocksDrawerComponent: function() {
+        return BlocksDrawerComponent;
+    },
+    INSERT_BLOCK_WITH_DRAWER_COMMAND: function() {
+        return INSERT_BLOCK_WITH_DRAWER_COMMAND;
+    }
+});
+const _modal = require("@faceless-ui/modal");
+const _LexicalComposerContext = require("@lexical/react/LexicalComposerContext");
+const _ui = require("@payloadcms/ui");
+const _lexical = require("lexical");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _EditorConfigProvider = require("../../../lexical/config/client/EditorConfigProvider");
+const _BlocksNode = require("../nodes/BlocksNode");
+const _commands = require("../plugin/commands");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const baseClass = 'lexical-blocks-drawer';
+const INSERT_BLOCK_WITH_DRAWER_COMMAND = (0, _lexical.createCommand)('INSERT_BLOCK_WITH_DRAWER_COMMAND');
+const insertBlock = ({ blockType, editor, replaceNodeKey })=>{
+    if (!replaceNodeKey) {
+        editor.dispatchCommand(_commands.INSERT_BLOCK_COMMAND, {
+            id: null,
+            blockName: '',
+            blockType
+        });
+    } else {
+        editor.update(()=>{
+            const node = (0, _lexical.$getNodeByKey)(replaceNodeKey);
+            if (node) {
+                node.replace((0, _BlocksNode.$createBlockNode)({
+                    id: null,
+                    blockName: '',
+                    blockType
+                }));
+            }
+        });
+    }
+};
+const BlocksDrawerComponent = ()=>{
+    const [editor] = (0, _LexicalComposerContext.useLexicalComposerContext)();
+    const { editorConfig, uuid } = (0, _EditorConfigProvider.useEditorConfigContext)();
+    const [replaceNodeKey, setReplaceNodeKey] = (0, _react.useState)(null);
+    const editDepth = (0, _ui.useEditDepth)();
+    const { t } = (0, _ui.useTranslation)();
+    const { openModal } = (0, _modal.useModal)();
+    const labels = {
+        plural: t('fields:blocks') || 'Blocks',
+        singular: t('fields:block') || 'Block'
+    };
+    const addRow = (0, _react.useCallback)((rowIndex, blockType)=>{
+        insertBlock({
+            blockType,
+            editor,
+            replaceNodeKey
+        });
+    }, [
+        editor,
+        replaceNodeKey
+    ]);
+    const drawerSlug = (0, _ui.formatDrawerSlug)({
+        slug: `lexical-rich-text-blocks-` + uuid,
+        depth: editDepth
+    });
+    const reducedBlocks = editorConfig?.resolvedFeatureMap?.get('blocks')?.clientFeatureProps?.reducedBlocks;
+    (0, _react.useEffect)(()=>{
+        return editor.registerCommand(INSERT_BLOCK_WITH_DRAWER_COMMAND, (payload)=>{
+            setReplaceNodeKey(payload?.replace ? payload?.replace.nodeKey : null);
+            openModal(drawerSlug);
+            return true;
+        }, _lexical.COMMAND_PRIORITY_EDITOR);
+    }, [
+        editor,
+        drawerSlug,
+        openModal
+    ]);
+    return /*#__PURE__*/ _react.default.createElement(_ui.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,71 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "BlocksFeatureClientComponent", {
+    enumerable: true,
+    get: function() {
+        return BlocksFeatureClientComponent;
+    }
+});
+const _translations = require("@payloadcms/translations");
+const _types = require("../../lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/types");
+const _Block = require("../../lexical/ui/icons/Block");
+const _createClientComponent = require("../createClientComponent");
+const _BlocksNode = require("./nodes/BlocksNode");
+const _plugin = require("./plugin");
+const _commands = require("./plugin/commands");
+const BlocksFeatureClient = (props)=>{
+    return {
+        clientFeatureProps: props,
+        feature: ()=>({
+                clientFeatureProps: props,
+                nodes: [
+                    _BlocksNode.BlockNode
+                ],
+                plugins: [
+                    {
+                        Component: _plugin.BlocksPlugin,
+                        position: 'normal'
+                    }
+                ],
+                slashMenu: {
+                    options: [
+                        {
+                            displayName: 'Blocks',
+                            key: 'blocks',
+                            options: [
+                                ...props.reducedBlocks.map((block)=>{
+                                    return new _types.SlashMenuOption('block-' + block.slug, {
+                                        Icon: _Block.BlockIcon,
+                                        displayName: ({ i18n })=>{
+                                            if (!block.labels.singular) {
+                                                return block.slug;
+                                            }
+                                            return (0, _translations.getTranslation)(block.labels.singular, i18n);
+                                        },
+                                        keywords: [
+                                            'block',
+                                            'blocks',
+                                            block.slug
+                                        ],
+                                        onSelect: ({ editor })=>{
+                                            editor.dispatchCommand(_commands.INSERT_BLOCK_COMMAND, {
+                                                id: null,
+                                                blockName: '',
+                                                blockType: block.slug
+                                            });
+                                        }
+                                    });
+                                })
+                            ]
+                        }
+                    ]
+                }
+            })
+    };
+};
+const BlocksFeatureClientComponent = (0, _createClientComponent.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"}