@payloadcms/richtext-lexical 3.0.0-beta.3 → 3.0.0-beta.31

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

@@ -1,11 +1,8 @@
-import type { Block, FieldWithRichTextRequiredEditor } from 'payload/types';
+import type { Block } from 'payload/types';
 import type { FeatureProviderProviderServer } from '../types.js';
 import type { BlocksFeatureClientProps } from './feature.client.js';
-export type LexicalBlock = Omit<Block, 'fields'> & {
-    fields: FieldWithRichTextRequiredEditor[];
-};
 export type BlocksFeatureProps = {
-    blocks: LexicalBlock[];
+    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

@@ -1 +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,+BAA+B,EAAE,MAAM,eAAe,CAAA;AAK9F,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,aAAa,CAAA;AAChE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAA;AAQnE,MAAM,MAAM,YAAY,GAAG,IAAI,CAAC,KAAK,EAAE,QAAQ,CAAC,GAAG;IACjD,MAAM,EAAE,+BAA+B,EAAE,CAAA;CAC1C,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC/B,MAAM,EAAE,YAAY,EAAE,CAAA;CACvB,CAAA;AAED,eAAO,MAAM,aAAa,EAAE,6BAA6B,CACvD,kBAAkB,EAClB,wBAAwB,CAyIzB,CAAA"}
+{"version":3,"file":"feature.server.d.ts","sourceRoot":"","sources":["../../../../src/field/features/blocks/feature.server.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAqB,MAAM,eAAe,CAAA;AAM7D,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,aAAa,CAAA;AAChE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAA;AAQnE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,MAAM,EAAE,KAAK,EAAE,CAAA;CAChB,CAAA;AAED,eAAO,MAAM,aAAa,EAAE,6BAA6B,CACvD,kBAAkB,EAClB,wBAAwB,CAsKzB,CAAA"}

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

@@ -1,75 +1,59 @@
+import { traverseFields } from '@payloadcms/next/utilities';
 import { baseBlockFields, sanitizeFields } from 'payload/config';
 import { fieldsToJSONSchema, formatLabels } from 'payload/utilities';
-import { cloneDeep } from '../../lexical/utils/cloneDeep.js';
+import { createNode } from '../typeUtilities.js';
 import { BlocksFeatureClientComponent } from './feature.client.js';
 import { BlockNode } from './nodes/BlocksNode.js';
 import { blockPopulationPromiseHOC } from './populationPromise.js';
 import { blockValidationHOC } from './validate.js';
 export const BlocksFeature = (props)=>{
-    // Sanitization taken from payload/src/fields/config/sanitize.ts
-    if (props?.blocks?.length) {
-        props.blocks = props.blocks.map((block)=>{
-            const blockCopy = cloneDeep(block);
-            return {
-                ...blockCopy,
-                // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
-                fields: blockCopy.fields.concat(baseBlockFields),
-                labels: !blockCopy.labels ? formatLabels(blockCopy.slug) : blockCopy.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,
-            fieldMap: [],
-            imageAltText: block.imageAltText,
-            imageURL: block.imageURL,
-            labels: block.labels
-        });
-    }
     return {
-        feature: ()=>{
+        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, props, schemaMap: schemaMapFromProps, schemaPath })=>{
-                    const schemaMap = {};
+                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 handleFields = (parentPath, fields)=>{
-                        for (const field of fields){
-                            if ('name' in field && 'fields' in field) {
-                                schemaMap[parentPath + '.' + field.name] = field.fields;
-                                handleFields(parentPath + '.' + field.name, field.fields);
-                            }
-                            if ('blocks' in field) {
-                                for (const block of field.blocks){
-                                    schemaMap[parentPath + '.' + field.name + '.' + block.slug] = block.fields || [];
-                                    handleFields(parentPath + '.' + field.name + '.' + block.slug, block.fields);
-                                }
-                            }
-                            if ('tabs' in field) {
-                                for (const tab of field.tabs){
-                                    if ('name' in tab) {
-                                        schemaMap[parentPath + '.' + tab.name] = tab.fields || [];
-                                        handleFields(parentPath + '.' + tab.name, tab.fields);
-                                    } else {
-                                        handleFields(parentPath, tab.fields);
-                                    }
-                                }
-                            }
-                        }
-                    };
+           * 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[block.slug] = block.fields || [];
-                        handleFields(block.slug, block.fields);
+                        schemaMap.set(block.slug, block.fields || []);
+                        traverseFields({
+                            config,
+                            fields: block.fields,
+                            i18n,
+                            schemaMap,
+                            schemaPath: block.slug,
+                            validRelationships
+                        });
                     }
                     return schemaMap;
                 },
@@ -78,24 +62,10 @@ export const BlocksFeature = (props)=>{
                         if (!props?.blocks?.length) {
                             return currentSchema;
                         }
-                        // sanitize blocks
-                        const validRelationships = config.collections.map((c)=>c.slug) || [];
-                        const sanitizedBlocks = props.blocks.map((block)=>{
-                            const blockCopy = cloneDeep(block);
-                            return {
-                                ...blockCopy,
-                                fields: sanitizeFields({
-                                    config,
-                                    fields: blockCopy.fields,
-                                    requireFieldLevelRichTextEditor: true,
-                                    validRelationships
-                                })
-                            };
-                        });
                         const blocksField = {
                             name: field?.name + '_lexical_blocks',
                             type: 'blocks',
-                            blocks: sanitizedBlocks
+                            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.
@@ -106,15 +76,77 @@ export const BlocksFeature = (props)=>{
                     }
                 },
                 nodes: [
-                    {
-                        node: BlockNode,
+                    createNode({
+                        /* // TODO: Implement these hooks once docWithLocales / originalSiblingDoc => node matching has been figured out
+            hooks: {
+              beforeChange: [
+                async ({ context, findMany, node, operation, overrideAccess, req }) => {
+                  const blockType = node.fields.blockType
+
+                  const block = deepCopyObject(
+                    props.blocks.find((block) => block.slug === blockType),
+                  )
+
+
+                  await beforeChangeTraverseFields({
+                    id: null,
+                    collection: null,
+                    context,
+                    data: node.fields,
+                    doc: node.fields,
+                    fields: sanitizedBlock.fields,
+                    global: null,
+                    mergeLocaleActions: [],
+                    operation:
+                      operation === 'create' || operation === 'update' ? operation : 'update',
+                    overrideAccess,
+                    path: '',
+                    req,
+                    siblingData: node.fields,
+                    siblingDoc: node.fields,
+                  })
+
+
+                  return node
+                },
+              ],
+              beforeValidate: [
+                async ({ context, findMany, node, operation, overrideAccess, req }) => {
+                  const blockType = node.fields.blockType
+
+                  const block = deepCopyObject(
+                    props.blocks.find((block) => block.slug === blockType),
+                  )
+
+
+
+                  await beforeValidateTraverseFields({
+                    id: null,
+                    collection: null,
+                    context,
+                    data: node.fields,
+                    doc: node.fields,
+                    fields: sanitizedBlock.fields,
+                    global: null,
+                    operation:
+                      operation === 'create' || operation === 'update' ? operation : 'update',
+                    overrideAccess,
+                    req,
+                    siblingData: node.fields,
+                    siblingDoc: node.fields,
+                  })
+
+                  return node
+                },
+              ],
+            },*/ node: BlockNode,
                         populationPromises: [
                             blockPopulationPromiseHOC(props)
                         ],
                         validations: [
                             blockValidationHOC(props)
                         ]
-                    }
+                    })
                 ],
                 serverFeatureProps: props
             };

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/field/features/blocks/feature.server.ts"],"sourcesContent":["import type { Block, BlockField, Field, FieldWithRichTextRequiredEditor } from 'payload/types'\n\nimport { baseBlockFields, sanitizeFields } from 'payload/config'\nimport { fieldsToJSONSchema, formatLabels } from 'payload/utilities'\n\nimport type { FeatureProviderProviderServer } from '../types.js'\nimport type { BlocksFeatureClientProps } from './feature.client.js'\n\nimport { cloneDeep } from '../../lexical/utils/cloneDeep.js'\nimport { BlocksFeatureClientComponent } from './feature.client.js'\nimport { BlockNode } from './nodes/BlocksNode.js'\nimport { blockPopulationPromiseHOC } from './populationPromise.js'\nimport { blockValidationHOC } from './validate.js'\n\nexport type LexicalBlock = Omit<Block, 'fields'> & {\n  fields: FieldWithRichTextRequiredEditor[]\n}\n\nexport type BlocksFeatureProps = {\n  blocks: LexicalBlock[]\n}\n\nexport const BlocksFeature: FeatureProviderProviderServer<\n  BlocksFeatureProps,\n  BlocksFeatureClientProps\n> = (props) => {\n  // Sanitization taken from payload/src/fields/config/sanitize.ts\n\n  if (props?.blocks?.length) {\n    props.blocks = props.blocks.map((block) => {\n      const blockCopy = cloneDeep(block)\n\n      return {\n        ...blockCopy,\n        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion\n        fields: blockCopy.fields.concat(baseBlockFields as FieldWithRichTextRequiredEditor[]),\n        labels: !blockCopy.labels ? formatLabels(blockCopy.slug) : blockCopy.labels,\n      }\n    })\n    //  unSanitizedBlock.fields are sanitized in the React component and not here.\n    // That's because we do not have access to the payload config here.\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    feature: () => {\n      return {\n        ClientComponent: BlocksFeatureClientComponent,\n        clientFeatureProps: clientProps,\n        generateSchemaMap: ({ config, props, schemaMap: schemaMapFromProps, schemaPath }) => {\n          const schemaMap: {\n            [key: string]: Field[]\n          } = {}\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 handleFields = (parentPath: string, fields: Field[]) => {\n            for (const field of fields) {\n              if ('name' in field && 'fields' in field) {\n                schemaMap[parentPath + '.' + field.name] = field.fields\n                handleFields(parentPath + '.' + field.name, field.fields)\n              }\n              if ('blocks' in field) {\n                for (const block of field.blocks) {\n                  schemaMap[parentPath + '.' + field.name + '.' + block.slug] = block.fields || []\n                  handleFields(parentPath + '.' + field.name + '.' + block.slug, block.fields)\n                }\n              }\n              if ('tabs' in field) {\n                for (const tab of field.tabs) {\n                  if ('name' in tab) {\n                    schemaMap[parentPath + '.' + tab.name] = tab.fields || []\n                    handleFields(parentPath + '.' + tab.name, tab.fields)\n                  } else {\n                    handleFields(parentPath, tab.fields)\n                  }\n                }\n              }\n            }\n          }\n\n          for (const block of props.blocks) {\n            schemaMap[block.slug] = block.fields || []\n            handleFields(block.slug, block.fields)\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            // sanitize blocks\n            const validRelationships = config.collections.map((c) => c.slug) || []\n\n            const sanitizedBlocks = props.blocks.map((block) => {\n              const blockCopy = cloneDeep(block)\n              return {\n                ...blockCopy,\n                fields: sanitizeFields({\n                  config,\n                  fields: blockCopy.fields,\n                  requireFieldLevelRichTextEditor: true,\n                  validRelationships,\n                }),\n              }\n            })\n\n            const blocksField: BlockField = {\n              name: field?.name + '_lexical_blocks',\n              type: 'blocks',\n              blocks: sanitizedBlocks,\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        nodes: [\n          {\n            node: BlockNode,\n            populationPromises: [blockPopulationPromiseHOC(props)],\n            validations: [blockValidationHOC(props)],\n          },\n        ],\n        serverFeatureProps: props,\n      }\n    },\n    key: 'blocks',\n    serverFeatureProps: props,\n  }\n}\n"],"names":["baseBlockFields","sanitizeFields","fieldsToJSONSchema","formatLabels","cloneDeep","BlocksFeatureClientComponent","BlockNode","blockPopulationPromiseHOC","blockValidationHOC","BlocksFeature","props","blocks","length","map","block","blockCopy","fields","concat","labels","slug","clientProps","reducedBlocks","push","fieldMap","imageAltText","imageURL","feature","ClientComponent","clientFeatureProps","generateSchemaMap","config","schemaMap","schemaMapFromProps","schemaPath","handleFields","parentPath","field","name","tab","tabs","generatedTypes","modifyOutputSchema","collectionIDFieldTypes","currentSchema","interfaceNameDefinitions","validRelationships","collections","c","sanitizedBlocks","requireFieldLevelRichTextEditor","blocksField","type","nodes","node","populationPromises","validations","serverFeatureProps","key"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAEA,SAASA,eAAe,EAAEC,cAAc,QAAQ,iBAAgB;AAChE,SAASC,kBAAkB,EAAEC,YAAY,QAAQ,oBAAmB;AAKpE,SAASC,SAAS,QAAQ,mCAAkC;AAC5D,SAASC,4BAA4B,QAAQ,sBAAqB;AAClE,SAASC,SAAS,QAAQ,wBAAuB;AACjD,SAASC,yBAAyB,QAAQ,yBAAwB;AAClE,SAASC,kBAAkB,QAAQ,gBAAe;AAUlD,OAAO,MAAMC,gBAGT,CAACC;IACH,gEAAgE;IAEhE,IAAIA,OAAOC,QAAQC,QAAQ;QACzBF,MAAMC,MAAM,GAAGD,MAAMC,MAAM,CAACE,GAAG,CAAC,CAACC;YAC/B,MAAMC,YAAYX,UAAUU;YAE5B,OAAO;gBACL,GAAGC,SAAS;gBACZ,4EAA4E;gBAC5EC,QAAQD,UAAUC,MAAM,CAACC,MAAM,CAACjB;gBAChCkB,QAAQ,CAACH,UAAUG,MAAM,GAAGf,aAAaY,UAAUI,IAAI,IAAIJ,UAAUG,MAAM;YAC7E;QACF;IACA,8EAA8E;IAC9E,mEAAmE;IACrE;IAEA,oBAAoB;IACpB,MAAME,cAAwC;QAC5CC,eAAe,EAAE;IACnB;IACA,KAAK,MAAMP,SAASJ,MAAMC,MAAM,CAAE;QAChCS,YAAYC,aAAa,CAACC,IAAI,CAAC;YAC7BH,MAAML,MAAMK,IAAI;YAChBI,UAAU,EAAE;YACZC,cAAcV,MAAMU,YAAY;YAChCC,UAAUX,MAAMW,QAAQ;YACxBP,QAAQJ,MAAMI,MAAM;QACtB;IACF;IAEA,OAAO;QACLQ,SAAS;YACP,OAAO;gBACLC,iBAAiBtB;gBACjBuB,oBAAoBR;gBACpBS,mBAAmB,CAAC,EAAEC,MAAM,EAAEpB,KAAK,EAAEqB,WAAWC,kBAAkB,EAAEC,UAAU,EAAE;oBAC9E,MAAMF,YAEF,CAAC;oBAEL;;;WAGC,GACD,MAAMG,eAAe,CAACC,YAAoBnB;wBACxC,KAAK,MAAMoB,SAASpB,OAAQ;4BAC1B,IAAI,UAAUoB,SAAS,YAAYA,OAAO;gCACxCL,SAAS,CAACI,aAAa,MAAMC,MAAMC,IAAI,CAAC,GAAGD,MAAMpB,MAAM;gCACvDkB,aAAaC,aAAa,MAAMC,MAAMC,IAAI,EAAED,MAAMpB,MAAM;4BAC1D;4BACA,IAAI,YAAYoB,OAAO;gCACrB,KAAK,MAAMtB,SAASsB,MAAMzB,MAAM,CAAE;oCAChCoB,SAAS,CAACI,aAAa,MAAMC,MAAMC,IAAI,GAAG,MAAMvB,MAAMK,IAAI,CAAC,GAAGL,MAAME,MAAM,IAAI,EAAE;oCAChFkB,aAAaC,aAAa,MAAMC,MAAMC,IAAI,GAAG,MAAMvB,MAAMK,IAAI,EAAEL,MAAME,MAAM;gCAC7E;4BACF;4BACA,IAAI,UAAUoB,OAAO;gCACnB,KAAK,MAAME,OAAOF,MAAMG,IAAI,CAAE;oCAC5B,IAAI,UAAUD,KAAK;wCACjBP,SAAS,CAACI,aAAa,MAAMG,IAAID,IAAI,CAAC,GAAGC,IAAItB,MAAM,IAAI,EAAE;wCACzDkB,aAAaC,aAAa,MAAMG,IAAID,IAAI,EAAEC,IAAItB,MAAM;oCACtD,OAAO;wCACLkB,aAAaC,YAAYG,IAAItB,MAAM;oCACrC;gCACF;4BACF;wBACF;oBACF;oBAEA,KAAK,MAAMF,SAASJ,MAAMC,MAAM,CAAE;wBAChCoB,SAAS,CAACjB,MAAMK,IAAI,CAAC,GAAGL,MAAME,MAAM,IAAI,EAAE;wBAC1CkB,aAAapB,MAAMK,IAAI,EAAEL,MAAME,MAAM;oBACvC;oBAEA,OAAOe;gBACT;gBACAS,gBAAgB;oBACdC,oBAAoB,CAAC,EACnBC,sBAAsB,EACtBZ,MAAM,EACNa,aAAa,EACbP,KAAK,EACLQ,wBAAwB,EACzB;wBACC,IAAI,CAAClC,OAAOC,QAAQC,QAAQ;4BAC1B,OAAO+B;wBACT;wBAEA,kBAAkB;wBAClB,MAAME,qBAAqBf,OAAOgB,WAAW,CAACjC,GAAG,CAAC,CAACkC,IAAMA,EAAE5B,IAAI,KAAK,EAAE;wBAEtE,MAAM6B,kBAAkBtC,MAAMC,MAAM,CAACE,GAAG,CAAC,CAACC;4BACxC,MAAMC,YAAYX,UAAUU;4BAC5B,OAAO;gCACL,GAAGC,SAAS;gCACZC,QAAQf,eAAe;oCACrB6B;oCACAd,QAAQD,UAAUC,MAAM;oCACxBiC,iCAAiC;oCACjCJ;gCACF;4BACF;wBACF;wBAEA,MAAMK,cAA0B;4BAC9Bb,MAAMD,OAAOC,OAAO;4BACpBc,MAAM;4BACNxC,QAAQqC;wBACV;wBACA,wFAAwF;wBACxF,2EAA2E;wBAC3E9C,mBACEwC,wBACA;4BAACQ;yBAAY,EACbN,0BACAd;wBAGF,OAAOa;oBACT;gBACF;gBACAS,OAAO;oBACL;wBACEC,MAAM/C;wBACNgD,oBAAoB;4BAAC/C,0BAA0BG;yBAAO;wBACtD6C,aAAa;4BAAC/C,mBAAmBE;yBAAO;oBAC1C;iBACD;gBACD8C,oBAAoB9C;YACtB;QACF;QACA+C,KAAK;QACLD,oBAAoB9C;IACtB;AACF,EAAC"}
+{"version":3,"sources":["../../../../src/field/features/blocks/feature.server.ts"],"sourcesContent":["import type { Config } from 'payload/config'\nimport type { Block, BlockField, Field } from 'payload/types'\n\nimport { traverseFields } from '@payloadcms/next/utilities'\nimport { baseBlockFields, sanitizeFields } from 'payload/config'\nimport { fieldsToJSONSchema, formatLabels } from 'payload/utilities'\n\nimport type { FeatureProviderProviderServer } from '../types.js'\nimport type { BlocksFeatureClientProps } from './feature.client.js'\n\nimport { createNode } from '../typeUtilities.js'\nimport { BlocksFeatureClientComponent } from './feature.client.js'\nimport { BlockNode } from './nodes/BlocksNode.js'\nimport { blockPopulationPromiseHOC } from './populationPromise.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        nodes: [\n          createNode({\n            /* // TODO: Implement these hooks once docWithLocales / originalSiblingDoc => node matching has been figured out\n            hooks: {\n              beforeChange: [\n                async ({ context, findMany, node, operation, overrideAccess, req }) => {\n                  const blockType = node.fields.blockType\n\n                  const block = deepCopyObject(\n                    props.blocks.find((block) => block.slug === blockType),\n                  )\n\n\n                  await beforeChangeTraverseFields({\n                    id: null,\n                    collection: null,\n                    context,\n                    data: node.fields,\n                    doc: node.fields,\n                    fields: sanitizedBlock.fields,\n                    global: null,\n                    mergeLocaleActions: [],\n                    operation:\n                      operation === 'create' || operation === 'update' ? operation : 'update',\n                    overrideAccess,\n                    path: '',\n                    req,\n                    siblingData: node.fields,\n                    siblingDoc: node.fields,\n                  })\n\n\n                  return node\n                },\n              ],\n              beforeValidate: [\n                async ({ context, findMany, node, operation, overrideAccess, req }) => {\n                  const blockType = node.fields.blockType\n\n                  const block = deepCopyObject(\n                    props.blocks.find((block) => block.slug === blockType),\n                  )\n\n\n\n                  await beforeValidateTraverseFields({\n                    id: null,\n                    collection: null,\n                    context,\n                    data: node.fields,\n                    doc: node.fields,\n                    fields: sanitizedBlock.fields,\n                    global: null,\n                    operation:\n                      operation === 'create' || operation === 'update' ? operation : 'update',\n                    overrideAccess,\n                    req,\n                    siblingData: node.fields,\n                    siblingDoc: node.fields,\n                  })\n\n                  return node\n                },\n              ],\n            },*/\n            node: BlockNode,\n            populationPromises: [blockPopulationPromiseHOC(props)],\n            validations: [blockValidationHOC(props)],\n          }),\n        ],\n        serverFeatureProps: props,\n      }\n    },\n    key: 'blocks',\n    serverFeatureProps: props,\n  }\n}\n"],"names":["traverseFields","baseBlockFields","sanitizeFields","fieldsToJSONSchema","formatLabels","createNode","BlocksFeatureClientComponent","BlockNode","blockPopulationPromiseHOC","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","i18n","schemaMap","Map","set","schemaPath","generatedTypes","modifyOutputSchema","collectionIDFieldTypes","currentSchema","field","interfaceNameDefinitions","blocksField","name","type","nodes","node","populationPromises","validations","serverFeatureProps","key"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

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

@@ -1,8 +1,7 @@
 /// <reference types="react" resolution-mode="require"/>
 import type { SerializedDecoratorBlockNode } from '@lexical/react/LexicalDecoratorBlockNode.js';
 import type { DOMConversionMap, DOMExportOutput, EditorConfig, ElementFormatType, LexicalEditor, LexicalNode, NodeKey, Spread } from 'lexical';
-import lexicalDecoratorBlockNodeImport from '@lexical/react/LexicalDecoratorBlockNode.js';
-declare const DecoratorBlockNode: typeof lexicalDecoratorBlockNodeImport.DecoratorBlockNode;
+import { DecoratorBlockNode } from '@lexical/react/LexicalDecoratorBlockNode.js';
 export type BlockFields = {
     /** Block form data */
     [key: string]: any;
@@ -34,5 +33,4 @@ export declare class BlockNode extends DecoratorBlockNode {
 }
 export declare function $createBlockNode(fields: Exclude<BlockFields, 'id'>): BlockNode;
 export declare function $isBlockNode(node: BlockNode | LexicalNode | null | undefined): node is BlockNode;
-export {};
 //# sourceMappingURL=BlocksNode.d.ts.map

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

@@ -1 +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,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,+BAA+B,MAAM,6CAA6C,CAAA;AACzF,QAAA,MAAQ,kBAAkB,2DAAoC,CAAA;AAI9D,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"}
+{"version":3,"file":"BlocksNode.d.ts","sourceRoot":"","sources":["../../../../../src/field/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;AAIhF,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/field/features/blocks/nodes/BlocksNode.js

@@ -1,5 +1,4 @@
-import lexicalDecoratorBlockNodeImport from '@lexical/react/LexicalDecoratorBlockNode.js';
-const { DecoratorBlockNode } = lexicalDecoratorBlockNodeImport;
+import { DecoratorBlockNode } from '@lexical/react/LexicalDecoratorBlockNode.js';
 import ObjectID from 'bson-objectid';
 import React from 'react';
 const BlockComponent = /*#__PURE__*/ React.lazy(()=>import('../component/index.js').then((module)=>({

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/field/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 lexicalDecoratorBlockNodeImport from '@lexical/react/LexicalDecoratorBlockNode.js'\nconst { DecoratorBlockNode } = lexicalDecoratorBlockNodeImport\nimport ObjectID from 'bson-objectid'\nimport React 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":["lexicalDecoratorBlockNodeImport","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,OAAOA,qCAAqC,8CAA6C;AACzF,MAAM,EAAEC,kBAAkB,EAAE,GAAGD;AAC/B,OAAOE,cAAc,gBAAe;AACpC,OAAOC,WAAW,QAAO;AAUzB,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,oBAAC1B;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"}
+{"version":3,"sources":["../../../../../src/field/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 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,WAAW,QAAO;AAUzB,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,oBAAC1B;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/field/features/blocks/plugin/commands.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/blocks/plugin/commands.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAK7C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAEpD,eAAO,MAAM,oBAAoB,EAAE,cAAc,CAAC,kBAAkB,CAC7B,CAAA"}
+{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../../../../../src/field/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/field/features/blocks/plugin/commands.js

@@ -1,5 +1,4 @@
-import lexicalImport from 'lexical';
-const { createCommand } = lexicalImport;
+import { createCommand } from 'lexical';
 export const INSERT_BLOCK_COMMAND = createCommand('INSERT_BLOCK_COMMAND');
 
 //# sourceMappingURL=commands.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/field/features/blocks/plugin/commands.ts"],"sourcesContent":["import type { LexicalCommand } from 'lexical'\n\nimport lexicalImport from 'lexical'\nconst { createCommand } = lexicalImport\n\nimport type { InsertBlockPayload } from './index.js'\n\nexport const INSERT_BLOCK_COMMAND: LexicalCommand<InsertBlockPayload> =\n  createCommand('INSERT_BLOCK_COMMAND')\n"],"names":["lexicalImport","createCommand","INSERT_BLOCK_COMMAND"],"rangeMappings":";;","mappings":"AAEA,OAAOA,mBAAmB,UAAS;AACnC,MAAM,EAAEC,aAAa,EAAE,GAAGD;AAI1B,OAAO,MAAME,uBACXD,cAAc,wBAAuB"}
+{"version":3,"sources":["../../../../../src/field/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/field/features/blocks/plugin/index.d.ts

@@ -1,5 +1,6 @@
-import React from 'react';
+import type { PluginComponent } from '../../types.js';
+import type { BlocksFeatureClientProps } from '../feature.client.js';
 import type { BlockFields } from '../nodes/BlocksNode.js';
 export type InsertBlockPayload = Exclude<BlockFields, 'id'>;
-export declare function BlocksPlugin(): React.ReactNode;
+export declare const BlocksPlugin: PluginComponent<BlocksFeatureClientProps>;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/blocks/plugin/index.tsx"],"names":[],"mappings":"AAcA,OAAO,KAAoB,MAAM,OAAO,CAAA;AAExC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AAMzD,MAAM,MAAM,kBAAkB,GAAG,OAAO,CAAC,WAAW,EAAE,IAAI,CAAC,CAAA;AAE3D,wBAAgB,YAAY,IAAI,KAAK,CAAC,SAAS,CA8C9C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/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/field/features/blocks/plugin/index.js

@@ -1,15 +1,12 @@
 'use client';
-import lexicalComposerContextImport from '@lexical/react/LexicalComposerContext.js';
-const { useLexicalComposerContext } = lexicalComposerContextImport;
-import lexicalUtilsImport from '@lexical/utils';
-const { $insertNodeToNearestRoot, mergeRegister } = lexicalUtilsImport;
-import lexicalImport from 'lexical';
-const { $getPreviousSelection, $getSelection, $isParagraphNode, $isRangeSelection, COMMAND_PRIORITY_EDITOR } = lexicalImport;
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext.js';
+import { $insertNodeToNearestRoot, mergeRegister } from '@lexical/utils';
+import { $getPreviousSelection, $getSelection, $isParagraphNode, $isRangeSelection, COMMAND_PRIORITY_EDITOR } from 'lexical';
 import React, { useEffect } from 'react';
 import { BlocksDrawerComponent } from '../drawer/index.js';
 import { $createBlockNode, BlockNode } from '../nodes/BlocksNode.js';
 import { INSERT_BLOCK_COMMAND } from './commands.js';
-export function BlocksPlugin() {
+export const BlocksPlugin = ()=>{
     const [editor] = useLexicalComposerContext();
     useEffect(()=>{
         if (!editor.hasNodes([
@@ -38,6 +35,6 @@ export function BlocksPlugin() {
         editor
     ]);
     return /*#__PURE__*/ React.createElement(BlocksDrawerComponent, null);
-}
+};
 
 //# sourceMappingURL=index.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/field/features/blocks/plugin/index.tsx"],"sourcesContent":["'use client'\nimport lexicalComposerContextImport from '@lexical/react/LexicalComposerContext.js'\nconst { useLexicalComposerContext } = lexicalComposerContextImport\nimport lexicalUtilsImport from '@lexical/utils'\nconst { $insertNodeToNearestRoot, mergeRegister } = lexicalUtilsImport\nimport lexicalImport from 'lexical'\nconst {\n  $getPreviousSelection,\n  $getSelection,\n  $isParagraphNode,\n  $isRangeSelection,\n  COMMAND_PRIORITY_EDITOR,\n} = lexicalImport\n\nimport React, { useEffect } from 'react'\n\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 function BlocksPlugin(): React.ReactNode {\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 blockNode = $createBlockNode(payload)\n\n            const selection = $getSelection() || $getPreviousSelection()\n\n            if ($isRangeSelection(selection)) {\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              $insertNodeToNearestRoot(blockNode)\n            }\n          })\n\n          return true\n        },\n        COMMAND_PRIORITY_EDITOR,\n      ),\n    )\n  }, [editor])\n\n  return <BlocksDrawerComponent />\n}\n"],"names":["lexicalComposerContextImport","useLexicalComposerContext","lexicalUtilsImport","$insertNodeToNearestRoot","mergeRegister","lexicalImport","$getPreviousSelection","$getSelection","$isParagraphNode","$isRangeSelection","COMMAND_PRIORITY_EDITOR","React","useEffect","BlocksDrawerComponent","$createBlockNode","BlockNode","INSERT_BLOCK_COMMAND","BlocksPlugin","editor","hasNodes","Error","registerCommand","payload","update","blockNode","selection","focus","focusNode","getNode","getTextContentSize","getParent","getChildren","filter","node","length","remove"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;AACA,OAAOA,kCAAkC,2CAA0C;AACnF,MAAM,EAAEC,yBAAyB,EAAE,GAAGD;AACtC,OAAOE,wBAAwB,iBAAgB;AAC/C,MAAM,EAAEC,wBAAwB,EAAEC,aAAa,EAAE,GAAGF;AACpD,OAAOG,mBAAmB,UAAS;AACnC,MAAM,EACJC,qBAAqB,EACrBC,aAAa,EACbC,gBAAgB,EAChBC,iBAAiB,EACjBC,uBAAuB,EACxB,GAAGL;AAEJ,OAAOM,SAASC,SAAS,QAAQ,QAAO;AAIxC,SAASC,qBAAqB,QAAQ,qBAAoB;AAC1D,SAASC,gBAAgB,EAAEC,SAAS,QAAQ,yBAAwB;AACpE,SAASC,oBAAoB,QAAQ,gBAAe;AAIpD,OAAO,SAASC;IACd,MAAM,CAACC,OAAO,GAAGjB;IAEjBW,UAAU;QACR,IAAI,CAACM,OAAOC,QAAQ,CAAC;YAACJ;SAAU,GAAG;YACjC,MAAM,IAAIK,MAAM;QAClB;QAEA,OAAOhB,cACLc,OAAOG,eAAe,CACpBL,sBACA,CAACM;YACCJ,OAAOK,MAAM,CAAC;gBACZ,MAAMC,YAAYV,iBAAiBQ;gBAEnC,MAAMG,YAAYlB,mBAAmBD;gBAErC,IAAIG,kBAAkBgB,YAAY;oBAChC,MAAM,EAAEC,KAAK,EAAE,GAAGD;oBAClB,MAAME,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;oBAEAhC,yBAAyBqB;gBAC3B;YACF;YAEA,OAAO;QACT,GACAd;IAGN,GAAG;QAACQ;KAAO;IAEX,qBAAO,oBAACL;AACV"}
+{"version":3,"sources":["../../../../../src/field/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 blockNode = $createBlockNode(payload)\n\n            const selection = $getSelection() || $getPreviousSelection()\n\n            if ($isRangeSelection(selection)) {\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              $insertNodeToNearestRoot(blockNode)\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","blockNode","selection","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,YAAYV,iBAAiBQ;gBAEnC,MAAMG,YAAYlB,mBAAmBD;gBAErC,IAAIG,kBAAkBgB,YAAY;oBAChC,MAAM,EAAEC,KAAK,EAAE,GAAGD;oBAClB,MAAME,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;oBAEA/B,yBAAyBoB;gBAC3B;YACF;YAEA,OAAO;QACT,GACAd;IAGN,GAAG;QAACQ;KAAO;IAEX,qBAAO,oBAACL;AACV,EAAC"}

package/dist/field/features/blocks/populationPromise.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"populationPromise.d.ts","sourceRoot":"","sources":["../../../../src/field/features/blocks/populationPromise.ts"],"names":[],"mappings":"AAIA,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,CA4DvC,CAAA"}
+{"version":3,"file":"populationPromise.d.ts","sourceRoot":"","sources":["../../../../src/field/features/blocks/populationPromise.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,CA8CvC,CAAA"}

package/dist/field/features/blocks/populationPromise.js

@@ -1,25 +1,11 @@
-import { sanitizeFields } from 'payload/config';
 import { recurseNestedFields } from '../../../populate/recurseNestedFields.js';
 export const blockPopulationPromiseHOC = (props)=>{
-    const blockPopulationPromise = ({ context, currentDepth, depth, editorPopulationPromises, findMany, flattenLocales, node, overrideAccess, populationPromises, req, showHiddenFields, siblingDoc })=>{
-        const blocks = props.blocks;
+    const blockPopulationPromise = ({ context, currentDepth, depth, draft, editorPopulationPromises, fieldPromises, findMany, flattenLocales, node, overrideAccess, populationPromises, req, showHiddenFields, siblingDoc })=>{
         const blockFieldData = node.fields;
-        const promises = [];
-        // Sanitize block's fields here. This is done here and not in the feature, because the payload config is available here
-        const payloadConfig = req.payload.config;
-        const validRelationships = payloadConfig.collections.map((c)=>c.slug) || [];
-        blocks.forEach((block)=>{
-            block.fields = sanitizeFields({
-                config: payloadConfig,
-                fields: block.fields,
-                requireFieldLevelRichTextEditor: true,
-                validRelationships
-            });
-        });
         // find block used in this node
         const block = props.blocks.find((block)=>block.slug === blockFieldData.blockType);
         if (!block || !block?.fields?.length || !blockFieldData) {
-            return promises;
+            return;
         }
         recurseNestedFields({
             context,
@@ -27,18 +13,18 @@ export const blockPopulationPromiseHOC = (props)=>{
             data: blockFieldData,
             depth,
             editorPopulationPromises,
+            fieldPromises,
             fields: block.fields,
             findMany,
             flattenLocales,
             overrideAccess,
             populationPromises,
-            promises,
             req,
             showHiddenFields,
             // The afterReadPromise gets its data from looking for field.name inside the siblingDoc. Thus, here we cannot pass the whole document's siblingDoc, but only the siblingDoc (sibling fields) of the current field.
+            draft,
             siblingDoc: blockFieldData
         });
-        return promises;
     };
     return blockPopulationPromise;
 };

package/dist/field/features/blocks/populationPromise.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/field/features/blocks/populationPromise.ts"],"sourcesContent":["import type { Block } from 'payload/types'\n\nimport { sanitizeFields } from 'payload/config'\n\nimport type { PopulationPromise } from '../types.js'\nimport type { BlocksFeatureProps } from './feature.server.js'\nimport type { SerializedBlockNode } from './nodes/BlocksNode.js'\n\nimport { recurseNestedFields } from '../../../populate/recurseNestedFields.js'\n\nexport const blockPopulationPromiseHOC = (\n  props: BlocksFeatureProps,\n): PopulationPromise<SerializedBlockNode> => {\n  const blockPopulationPromise: PopulationPromise<SerializedBlockNode> = ({\n    context,\n    currentDepth,\n    depth,\n    editorPopulationPromises,\n    findMany,\n    flattenLocales,\n    node,\n    overrideAccess,\n    populationPromises,\n    req,\n    showHiddenFields,\n    siblingDoc,\n  }) => {\n    const blocks: Block[] = props.blocks\n    const blockFieldData = node.fields\n\n    const promises: Promise<void>[] = []\n\n    // Sanitize block's fields here. This is done here and not in the feature, because the payload config is available here\n    const payloadConfig = req.payload.config\n    const validRelationships = payloadConfig.collections.map((c) => c.slug) || []\n    blocks.forEach((block) => {\n      block.fields = sanitizeFields({\n        config: payloadConfig,\n        fields: block.fields,\n        requireFieldLevelRichTextEditor: true,\n        validRelationships,\n      })\n    })\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 promises\n    }\n\n    recurseNestedFields({\n      context,\n      currentDepth,\n      data: blockFieldData,\n      depth,\n      editorPopulationPromises,\n      fields: block.fields,\n      findMany,\n      flattenLocales,\n      overrideAccess,\n      populationPromises,\n      promises,\n      req,\n      showHiddenFields,\n      // The afterReadPromise gets its data from looking for field.name inside the siblingDoc. Thus, here we cannot pass the whole document's siblingDoc, but only the siblingDoc (sibling fields) of the current field.\n      siblingDoc: blockFieldData,\n    })\n\n    return promises\n  }\n\n  return blockPopulationPromise\n}\n"],"names":["sanitizeFields","recurseNestedFields","blockPopulationPromiseHOC","props","blockPopulationPromise","context","currentDepth","depth","editorPopulationPromises","findMany","flattenLocales","node","overrideAccess","populationPromises","req","showHiddenFields","siblingDoc","blocks","blockFieldData","fields","promises","payloadConfig","payload","config","validRelationships","collections","map","c","slug","forEach","block","requireFieldLevelRichTextEditor","find","blockType","length","data"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAEA,SAASA,cAAc,QAAQ,iBAAgB;AAM/C,SAASC,mBAAmB,QAAQ,2CAA0C;AAE9E,OAAO,MAAMC,4BAA4B,CACvCC;IAEA,MAAMC,yBAAiE,CAAC,EACtEC,OAAO,EACPC,YAAY,EACZC,KAAK,EACLC,wBAAwB,EACxBC,QAAQ,EACRC,cAAc,EACdC,IAAI,EACJC,cAAc,EACdC,kBAAkB,EAClBC,GAAG,EACHC,gBAAgB,EAChBC,UAAU,EACX;QACC,MAAMC,SAAkBd,MAAMc,MAAM;QACpC,MAAMC,iBAAiBP,KAAKQ,MAAM;QAElC,MAAMC,WAA4B,EAAE;QAEpC,uHAAuH;QACvH,MAAMC,gBAAgBP,IAAIQ,OAAO,CAACC,MAAM;QACxC,MAAMC,qBAAqBH,cAAcI,WAAW,CAACC,GAAG,CAAC,CAACC,IAAMA,EAAEC,IAAI,KAAK,EAAE;QAC7EX,OAAOY,OAAO,CAAC,CAACC;YACdA,MAAMX,MAAM,GAAGnB,eAAe;gBAC5BuB,QAAQF;gBACRF,QAAQW,MAAMX,MAAM;gBACpBY,iCAAiC;gBACjCP;YACF;QACF;QAEA,+BAA+B;QAC/B,MAAMM,QAAQ3B,MAAMc,MAAM,CAACe,IAAI,CAAC,CAACF,QAAUA,MAAMF,IAAI,KAAKV,eAAee,SAAS;QAClF,IAAI,CAACH,SAAS,CAACA,OAAOX,QAAQe,UAAU,CAAChB,gBAAgB;YACvD,OAAOE;QACT;QAEAnB,oBAAoB;YAClBI;YACAC;YACA6B,MAAMjB;YACNX;YACAC;YACAW,QAAQW,MAAMX,MAAM;YACpBV;YACAC;YACAE;YACAC;YACAO;YACAN;YACAC;YACA,kNAAkN;YAClNC,YAAYE;QACd;QAEA,OAAOE;IACT;IAEA,OAAOhB;AACT,EAAC"}
+{"version":3,"sources":["../../../../src/field/features/blocks/populationPromise.ts"],"sourcesContent":["import type { PopulationPromise } from '../types.js'\nimport type { BlocksFeatureProps } from './feature.server.js'\nimport type { SerializedBlockNode } from './nodes/BlocksNode.js'\n\nimport { recurseNestedFields } from '../../../populate/recurseNestedFields.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    siblingDoc,\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    recurseNestedFields({\n      context,\n      currentDepth,\n      data: blockFieldData,\n      depth,\n      editorPopulationPromises,\n      fieldPromises,\n      fields: block.fields,\n      findMany,\n      flattenLocales,\n      overrideAccess,\n      populationPromises,\n      req,\n      showHiddenFields,\n      // The afterReadPromise gets its data from looking for field.name inside the siblingDoc. Thus, here we cannot pass the whole document's siblingDoc, but only the siblingDoc (sibling fields) of the current field.\n      draft,\n      siblingDoc: blockFieldData,\n    })\n  }\n\n  return blockPopulationPromise\n}\n"],"names":["recurseNestedFields","blockPopulationPromiseHOC","props","blockPopulationPromise","context","currentDepth","depth","draft","editorPopulationPromises","fieldPromises","findMany","flattenLocales","node","overrideAccess","populationPromises","req","showHiddenFields","siblingDoc","blockFieldData","fields","block","blocks","find","slug","blockType","length","data"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAIA,SAASA,mBAAmB,QAAQ,2CAA0C;AAE9E,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,EAChBC,UAAU,EACX;QACC,MAAMC,iBAAiBN,KAAKO,MAAM;QAElC,+BAA+B;QAC/B,MAAMC,QAAQlB,MAAMmB,MAAM,CAACC,IAAI,CAAC,CAACF,QAAUA,MAAMG,IAAI,KAAKL,eAAeM,SAAS;QAClF,IAAI,CAACJ,SAAS,CAACA,OAAOD,QAAQM,UAAU,CAACP,gBAAgB;YACvD;QACF;QAEAlB,oBAAoB;YAClBI;YACAC;YACAqB,MAAMR;YACNZ;YACAE;YACAC;YACAU,QAAQC,MAAMD,MAAM;YACpBT;YACAC;YACAE;YACAC;YACAC;YACAC;YACA,kNAAkN;YAClNT;YACAU,YAAYC;QACd;IACF;IAEA,OAAOf;AACT,EAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../../src/field/features/blocks/validate.ts"],"names":[],"mappings":"AAIA,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;AAEhE,eAAO,MAAM,kBAAkB,UACtB,kBAAkB,KACxB,eAAe,mBAAmB,CAmEpC,CAAA"}
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../../src/field/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"}