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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1 +0,0 @@
-{"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;AAEhF,OAAc,EAAE,KAAK,GAAG,EAAE,MAAM,OAAO,CAAA;AAEvC,MAAM,MAAM,WAAW,GAAG;IACxB,sBAAsB;IACtB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,EAAE,EAAE,MAAM,CAAA;CACX,CAAA;AAQD,MAAM,MAAM,mBAAmB,GAAG,MAAM,CACtC;IACE,MAAM,EAAE,WAAW,CAAA;CACpB,EACD,4BAA4B,CAC7B,CAAA;AAED,qBAAa,SAAU,SAAQ,kBAAkB;IAC/C,QAAQ,EAAE,WAAW,CAAA;gBAET,EACV,MAAM,EACN,MAAM,EACN,GAAG,GACJ,EAAE;QACD,MAAM,EAAE,WAAW,CAAA;QACnB,MAAM,CAAC,EAAE,iBAAiB,CAAA;QAC1B,GAAG,CAAC,EAAE,OAAO,CAAA;KACd;IAKD,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS;IAQxC,MAAM,CAAC,OAAO,IAAI,MAAM;IAIxB,MAAM,CAAC,SAAS,IAAI,gBAAgB,CAAC,cAAc,CAAC,GAAG,IAAI;IAI3D,MAAM,CAAC,UAAU,CAAC,cAAc,EAAE,mBAAmB,GAAG,SAAS;IAgBjE,MAAM,CAAC,QAAQ,IAAI,KAAK;IAGxB,QAAQ,CAAC,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,YAAY,GAAG,GAAG,CAAC,OAAO;IAKlE,SAAS,IAAI,eAAe;IAQ5B,UAAU,IAAI,mBAAmB;IASjC,SAAS,IAAI,WAAW;IAIxB,cAAc,IAAI,MAAM;IAIxB,SAAS,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI;CAMrC;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,OAAO,CAAC,WAAW,EAAE,IAAI,CAAC,GAAG,SAAS,CAO9E;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,SAAS,GAAG,WAAW,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,IAAI,SAAS,CAEhG"}

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

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

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

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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 selection = $getSelection() || $getPreviousSelection()\n\n            if ($isRangeSelection(selection)) {\n              const blockNode = $createBlockNode(payload)\n              // Insert blocks node BEFORE potentially removing focusNode, as $insertNodeToNearestRoot errors if the focusNode doesn't exist\n              $insertNodeToNearestRoot(blockNode)\n\n              const { focus } = selection\n              const focusNode = focus.getNode()\n\n              // First, delete currently selected node if it's an empty paragraph and if there are sufficient\n              // paragraph nodes (more than 1) left in the parent node, so that we don't \"trap\" the user\n              if (\n                $isParagraphNode(focusNode) &&\n                focusNode.getTextContentSize() === 0 &&\n                focusNode\n                  .getParent()\n                  .getChildren()\n                  .filter((node) => $isParagraphNode(node)).length > 1\n              ) {\n                focusNode.remove()\n              }\n            }\n          })\n\n          return true\n        },\n        COMMAND_PRIORITY_EDITOR,\n      ),\n    )\n  }, [editor])\n\n  return <BlocksDrawerComponent />\n}\n"],"names":["useLexicalComposerContext","$insertNodeToNearestRoot","mergeRegister","$getPreviousSelection","$getSelection","$isParagraphNode","$isRangeSelection","COMMAND_PRIORITY_EDITOR","React","useEffect","BlocksDrawerComponent","$createBlockNode","BlockNode","INSERT_BLOCK_COMMAND","BlocksPlugin","editor","hasNodes","Error","registerCommand","payload","update","selection","blockNode","focus","focusNode","getNode","getTextContentSize","getParent","getChildren","filter","node","length","remove"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;;AACA,SAASA,yBAAyB,QAAQ,2CAA0C;AACpF,SAASC,wBAAwB,EAAEC,aAAa,QAAQ,iBAAgB;AACxE,SACEC,qBAAqB,EACrBC,aAAa,EACbC,gBAAgB,EAChBC,iBAAiB,EACjBC,uBAAuB,QAClB,UAAS;AAChB,OAAOC,SAASC,SAAS,QAAQ,QAAO;AAMxC,SAASC,qBAAqB,QAAQ,qBAAoB;AAC1D,SAASC,gBAAgB,EAAEC,SAAS,QAAQ,yBAAwB;AACpE,SAASC,oBAAoB,QAAQ,gBAAe;AAIpD,OAAO,MAAMC,eAA0D;IACrE,MAAM,CAACC,OAAO,GAAGf;IAEjBS,UAAU;QACR,IAAI,CAACM,OAAOC,QAAQ,CAAC;YAACJ;SAAU,GAAG;YACjC,MAAM,IAAIK,MAAM;QAClB;QAEA,OAAOf,cACLa,OAAOG,eAAe,CACpBL,sBACA,CAACM;YACCJ,OAAOK,MAAM,CAAC;gBACZ,MAAMC,YAAYjB,mBAAmBD;gBAErC,IAAIG,kBAAkBe,YAAY;oBAChC,MAAMC,YAAYX,iBAAiBQ;oBACnC,8HAA8H;oBAC9HlB,yBAAyBqB;oBAEzB,MAAM,EAAEC,KAAK,EAAE,GAAGF;oBAClB,MAAMG,YAAYD,MAAME,OAAO;oBAE/B,+FAA+F;oBAC/F,0FAA0F;oBAC1F,IACEpB,iBAAiBmB,cACjBA,UAAUE,kBAAkB,OAAO,KACnCF,UACGG,SAAS,GACTC,WAAW,GACXC,MAAM,CAAC,CAACC,OAASzB,iBAAiByB,OAAOC,MAAM,GAAG,GACrD;wBACAP,UAAUQ,MAAM;oBAClB;gBACF;YACF;YAEA,OAAO;QACT,GACAzB;IAGN,GAAG;QAACQ;KAAO;IAEX,qBAAO,KAACL;AACV,EAAC"}

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

@@ -1 +0,0 @@
-{"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"}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/field/features/converters/html/converter/defaultConverters.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"defaultConverters.d.ts","sourceRoot":"","sources":["../../../../../../src/field/features/converters/html/converter/defaultConverters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAM/C,eAAO,MAAM,qBAAqB,EAAE,aAAa,EAIhD,CAAA"}

package/dist/field/features/converters/html/converter/defaultConverters.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../src/field/features/converters/html/converter/defaultConverters.ts"],"sourcesContent":["import type { HTMLConverter } from './types.js'\n\nimport { LinebreakHTMLConverter } from './converters/linebreak.js'\nimport { ParagraphHTMLConverter } from './converters/paragraph.js'\nimport { TextHTMLConverter } from './converters/text.js'\n\nexport const defaultHTMLConverters: HTMLConverter[] = [\n  ParagraphHTMLConverter,\n  TextHTMLConverter,\n  LinebreakHTMLConverter,\n]\n"],"names":["LinebreakHTMLConverter","ParagraphHTMLConverter","TextHTMLConverter","defaultHTMLConverters"],"rangeMappings":";;;;;;;","mappings":"AAEA,SAASA,sBAAsB,QAAQ,4BAA2B;AAClE,SAASC,sBAAsB,QAAQ,4BAA2B;AAClE,SAASC,iBAAiB,QAAQ,uBAAsB;AAExD,OAAO,MAAMC,wBAAyC;IACpDF;IACAC;IACAF;CACD,CAAA"}

package/dist/field/features/converters/html/converter/index.d.ts

@@ -1,21 +0,0 @@
-import type { SerializedEditorState, SerializedLexicalNode } from 'lexical';
-import type { Payload } from 'payload';
-import type { HTMLConverter, SerializedLexicalNodeWithParent } from './types.js';
-export declare function convertLexicalToHTML({ converters, data, payload, }: {
-    converters: HTMLConverter[];
-    data: SerializedEditorState;
-    /**
-     * When the converter is called, payload CAN be passed in depending on where it's run.
-     */
-    payload: Payload | null;
-}): Promise<string>;
-export declare function convertLexicalNodesToHTML({ converters, lexicalNodes, parent, payload, }: {
-    converters: HTMLConverter[];
-    lexicalNodes: SerializedLexicalNode[];
-    parent: SerializedLexicalNodeWithParent;
-    /**
-     * When the converter is called, payload CAN be passed in depending on where it's run.
-     */
-    payload: Payload | null;
-}): Promise<string>;
-//# sourceMappingURL=index.d.ts.map

package/dist/field/features/converters/html/converter/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/field/features/converters/html/converter/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAC3E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AAEtC,OAAO,KAAK,EAAE,aAAa,EAAE,+BAA+B,EAAE,MAAM,YAAY,CAAA;AAEhF,wBAAsB,oBAAoB,CAAC,EACzC,UAAU,EACV,IAAI,EACJ,OAAO,GACR,EAAE;IACD,UAAU,EAAE,aAAa,EAAE,CAAA;IAC3B,IAAI,EAAE,qBAAqB,CAAA;IAC3B;;OAEG;IACH,OAAO,EAAE,OAAO,GAAG,IAAI,CAAA;CACxB,GAAG,OAAO,CAAC,MAAM,CAAC,CAUlB;AAED,wBAAsB,yBAAyB,CAAC,EAC9C,UAAU,EACV,YAAY,EACZ,MAAM,EACN,OAAO,GACR,EAAE;IACD,UAAU,EAAE,aAAa,EAAE,CAAA;IAC3B,YAAY,EAAE,qBAAqB,EAAE,CAAA;IACrC,MAAM,EAAE,+BAA+B,CAAA;IACvC;;OAEG;IACH,OAAO,EAAE,OAAO,GAAG,IAAI,CAAA;CACxB,GAAG,OAAO,CAAC,MAAM,CAAC,CAoClB"}

package/dist/field/features/converters/html/converter/index.js

@@ -1,44 +0,0 @@
-export async function convertLexicalToHTML({ converters, data, payload }) {
-    if (data?.root?.children?.length) {
-        return await convertLexicalNodesToHTML({
-            converters,
-            lexicalNodes: data?.root?.children,
-            parent: data?.root,
-            payload
-        });
-    }
-    return '';
-}
-export async function convertLexicalNodesToHTML({ converters, lexicalNodes, parent, payload }) {
-    const unknownConverter = converters.find((converter)=>converter.nodeTypes.includes('unknown'));
-    const htmlArray = await Promise.all(lexicalNodes.map(async (node, i)=>{
-        const converterForNode = converters.find((converter)=>converter.nodeTypes.includes(node.type));
-        try {
-            if (!converterForNode) {
-                if (unknownConverter) {
-                    return await unknownConverter.converter({
-                        childIndex: i,
-                        converters,
-                        node,
-                        parent,
-                        payload
-                    });
-                }
-                return '<span>unknown node</span>';
-            }
-            return await converterForNode.converter({
-                childIndex: i,
-                converters,
-                node,
-                parent,
-                payload
-            });
-        } catch (error) {
-            console.error('Error converting lexical node to HTML:', error, 'node:', node);
-            return '';
-        }
-    }));
-    return htmlArray.join('') || '';
-}
-
-//# sourceMappingURL=index.js.map

package/dist/field/features/converters/html/converter/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../src/field/features/converters/html/converter/index.ts"],"sourcesContent":["import type { SerializedEditorState, SerializedLexicalNode } from 'lexical'\nimport type { Payload } from 'payload'\n\nimport type { HTMLConverter, SerializedLexicalNodeWithParent } from './types.js'\n\nexport async function convertLexicalToHTML({\n  converters,\n  data,\n  payload,\n}: {\n  converters: HTMLConverter[]\n  data: SerializedEditorState\n  /**\n   * When the converter is called, payload CAN be passed in depending on where it's run.\n   */\n  payload: Payload | null\n}): Promise<string> {\n  if (data?.root?.children?.length) {\n    return await convertLexicalNodesToHTML({\n      converters,\n      lexicalNodes: data?.root?.children,\n      parent: data?.root,\n      payload,\n    })\n  }\n  return ''\n}\n\nexport async function convertLexicalNodesToHTML({\n  converters,\n  lexicalNodes,\n  parent,\n  payload,\n}: {\n  converters: HTMLConverter[]\n  lexicalNodes: SerializedLexicalNode[]\n  parent: SerializedLexicalNodeWithParent\n  /**\n   * When the converter is called, payload CAN be passed in depending on where it's run.\n   */\n  payload: Payload | null\n}): Promise<string> {\n  const unknownConverter = converters.find((converter) => converter.nodeTypes.includes('unknown'))\n\n  const htmlArray = await Promise.all(\n    lexicalNodes.map(async (node, i) => {\n      const converterForNode = converters.find((converter) =>\n        converter.nodeTypes.includes(node.type),\n      )\n      try {\n        if (!converterForNode) {\n          if (unknownConverter) {\n            return await unknownConverter.converter({\n              childIndex: i,\n              converters,\n              node,\n              parent,\n              payload,\n            })\n          }\n          return '<span>unknown node</span>'\n        }\n        return await converterForNode.converter({\n          childIndex: i,\n          converters,\n          node,\n          parent,\n          payload,\n        })\n      } catch (error) {\n        console.error('Error converting lexical node to HTML:', error, 'node:', node)\n        return ''\n      }\n    }),\n  )\n\n  return htmlArray.join('') || ''\n}\n"],"names":["convertLexicalToHTML","converters","data","payload","root","children","length","convertLexicalNodesToHTML","lexicalNodes","parent","unknownConverter","find","converter","nodeTypes","includes","htmlArray","Promise","all","map","node","i","converterForNode","type","childIndex","error","console","join"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAKA,OAAO,eAAeA,qBAAqB,EACzCC,UAAU,EACVC,IAAI,EACJC,OAAO,EAQR;IACC,IAAID,MAAME,MAAMC,UAAUC,QAAQ;QAChC,OAAO,MAAMC,0BAA0B;YACrCN;YACAO,cAAcN,MAAME,MAAMC;YAC1BI,QAAQP,MAAME;YACdD;QACF;IACF;IACA,OAAO;AACT;AAEA,OAAO,eAAeI,0BAA0B,EAC9CN,UAAU,EACVO,YAAY,EACZC,MAAM,EACNN,OAAO,EASR;IACC,MAAMO,mBAAmBT,WAAWU,IAAI,CAAC,CAACC,YAAcA,UAAUC,SAAS,CAACC,QAAQ,CAAC;IAErF,MAAMC,YAAY,MAAMC,QAAQC,GAAG,CACjCT,aAAaU,GAAG,CAAC,OAAOC,MAAMC;QAC5B,MAAMC,mBAAmBpB,WAAWU,IAAI,CAAC,CAACC,YACxCA,UAAUC,SAAS,CAACC,QAAQ,CAACK,KAAKG,IAAI;QAExC,IAAI;YACF,IAAI,CAACD,kBAAkB;gBACrB,IAAIX,kBAAkB;oBACpB,OAAO,MAAMA,iBAAiBE,SAAS,CAAC;wBACtCW,YAAYH;wBACZnB;wBACAkB;wBACAV;wBACAN;oBACF;gBACF;gBACA,OAAO;YACT;YACA,OAAO,MAAMkB,iBAAiBT,SAAS,CAAC;gBACtCW,YAAYH;gBACZnB;gBACAkB;gBACAV;gBACAN;YACF;QACF,EAAE,OAAOqB,OAAO;YACdC,QAAQD,KAAK,CAAC,0CAA0CA,OAAO,SAASL;YACxE,OAAO;QACT;IACF;IAGF,OAAOJ,UAAUW,IAAI,CAAC,OAAO;AAC/B"}

package/dist/field/features/converters/html/converter/types.d.ts

@@ -1,19 +0,0 @@
-import type { SerializedLexicalNode } from 'lexical';
-import type { Payload } from 'payload';
-export type HTMLConverter<T extends SerializedLexicalNode = SerializedLexicalNode> = {
-    converter: ({ childIndex, converters, node, parent, payload, }: {
-        childIndex: number;
-        converters: HTMLConverter[];
-        node: T;
-        parent: SerializedLexicalNodeWithParent;
-        /**
-         * When the converter is called, payload CAN be passed in depending on where it's run.
-         */
-        payload: Payload | null;
-    }) => Promise<string> | string;
-    nodeTypes: string[];
-};
-export type SerializedLexicalNodeWithParent = SerializedLexicalNode & {
-    parent?: SerializedLexicalNode;
-};
-//# sourceMappingURL=types.d.ts.map

package/dist/field/features/converters/html/converter/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../src/field/features/converters/html/converter/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AACpD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AAEtC,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,qBAAqB,GAAG,qBAAqB,IAAI;IACnF,SAAS,EAAE,CAAC,EACV,UAAU,EACV,UAAU,EACV,IAAI,EACJ,MAAM,EACN,OAAO,GACR,EAAE;QACD,UAAU,EAAE,MAAM,CAAA;QAClB,UAAU,EAAE,aAAa,EAAE,CAAA;QAC3B,IAAI,EAAE,CAAC,CAAA;QACP,MAAM,EAAE,+BAA+B,CAAA;QACvC;;WAEG;QACH,OAAO,EAAE,OAAO,GAAG,IAAI,CAAA;KACxB,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAA;IAC9B,SAAS,EAAE,MAAM,EAAE,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,+BAA+B,GAAG,qBAAqB,GAAG;IACpE,MAAM,CAAC,EAAE,qBAAqB,CAAA;CAC/B,CAAA"}

package/dist/field/features/converters/html/converter/types.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../src/field/features/converters/html/converter/types.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\nimport type { Payload } from 'payload'\n\nexport type HTMLConverter<T extends SerializedLexicalNode = SerializedLexicalNode> = {\n  converter: ({\n    childIndex,\n    converters,\n    node,\n    parent,\n    payload,\n  }: {\n    childIndex: number\n    converters: HTMLConverter[]\n    node: T\n    parent: SerializedLexicalNodeWithParent\n    /**\n     * When the converter is called, payload CAN be passed in depending on where it's run.\n     */\n    payload: Payload | null\n  }) => Promise<string> | string\n  nodeTypes: string[]\n}\n\nexport type SerializedLexicalNodeWithParent = SerializedLexicalNode & {\n  parent?: SerializedLexicalNode\n}\n"],"names":[],"rangeMappings":"","mappings":"AAuBA,WAEC"}

package/dist/field/features/converters/html/feature.server.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"feature.server.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/converters/html/feature.server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,gBAAgB,CAAA;AACnE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAEzD,MAAM,MAAM,yBAAyB,GAAG;IACtC,UAAU,CAAC,EACP,CAAC,CAAC,EAAE,iBAAiB,EAAE,EAAE;QAAE,iBAAiB,EAAE,aAAa,EAAE,CAAA;KAAE,KAAK,aAAa,EAAE,CAAC,GACpF,aAAa,EAAE,CAAA;CACpB,CAAA;AAED,eAAO,MAAM,oBAAoB,EAAE,6BAA6B,CAC9D,yBAAyB,EACzB,SAAS,CAYV,CAAA"}

package/dist/field/features/converters/html/feature.server.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../src/field/features/converters/html/feature.server.ts"],"sourcesContent":["import type { FeatureProviderProviderServer } from '../../types.js'\nimport type { HTMLConverter } from './converter/types.js'\n\nexport type HTMLConverterFeatureProps = {\n  converters?:\n    | (({ defaultConverters }: { defaultConverters: HTMLConverter[] }) => HTMLConverter[])\n    | HTMLConverter[]\n}\n\nexport const HTMLConverterFeature: FeatureProviderProviderServer<\n  HTMLConverterFeatureProps,\n  undefined\n> = (props) => {\n  return {\n    feature: () => {\n      return {\n        clientFeatureProps: null,\n        serverFeatureProps: props,\n      }\n    },\n    key: 'htmlConverter',\n    serverFeatureProps: props,\n  }\n}\n"],"names":["HTMLConverterFeature","props","feature","clientFeatureProps","serverFeatureProps","key"],"rangeMappings":";;;;;;;;;;;","mappings":"AASA,OAAO,MAAMA,uBAGT,CAACC;IACH,OAAO;QACLC,SAAS;YACP,OAAO;gBACLC,oBAAoB;gBACpBC,oBAAoBH;YACtB;QACF;QACAI,KAAK;QACLD,oBAAoBH;IACtB;AACF,EAAC"}

package/dist/field/features/converters/html/field/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/field/features/converters/html/field/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAqC,MAAM,SAAS,CAAA;AAGvE,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,qCAAqC,CAAA;AACtF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA;AAM1D,KAAK,KAAK,GAAG;IACX;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,sBAEnC;IACD,YAAY,EAAE,2BAA2B,CAAA;CAC1C,KAAG,aAAa,EA+ChB,CAAA;AA0DD,eAAO,MAAM,WAAW,EAAE;AACxB;;;;IAII;AACJ,gBAAgB,EAAE,MAAM,EACxB,KAAK,EAAE,KAAK,KACT,KA6EJ,CAAA"}

package/dist/field/features/converters/html/field/index.js

@@ -1,154 +0,0 @@
-import { defaultHTMLConverters } from '../converter/defaultConverters.js';
-import { convertLexicalToHTML } from '../converter/index.js';
-/**
- * Combines the default HTML converters with HTML converters found in the features, and with HTML converters configured in the htmlConverter feature.
- *
- * @param editorConfig
- */ export const consolidateHTMLConverters = ({ editorConfig })=>{
-    const htmlConverterFeature = editorConfig.resolvedFeatureMap.get('htmlConverter');
-    const htmlConverterFeatureProps = htmlConverterFeature?.serverFeatureProps;
-    const defaultConvertersWithConvertersFromFeatures = [
-        ...defaultHTMLConverters
-    ];
-    for (const converter of editorConfig.features.converters.html){
-        defaultConvertersWithConvertersFromFeatures.push(converter);
-    }
-    const finalConverters = htmlConverterFeatureProps?.converters && typeof htmlConverterFeatureProps?.converters === 'function' ? htmlConverterFeatureProps.converters({
-        defaultConverters: defaultConvertersWithConvertersFromFeatures
-    }) : htmlConverterFeatureProps?.converters || defaultConvertersWithConvertersFromFeatures;
-    // filter converters by nodeTypes. The last converter in the list wins. If there are multiple converters for the same nodeType, the last one will be used and the node types will be removed from
-    // previous converters. If previous converters do not have any nodeTypes left, they will be removed from the list.
-    // This guarantees that user-added converters which are added after the default ones will always have precedence
-    const foundNodeTypes = [];
-    const filteredConverters = [];
-    for (const converter of finalConverters.reverse()){
-        if (!converter.nodeTypes?.length) {
-            continue;
-        }
-        const newConverter = {
-            converter: converter.converter,
-            nodeTypes: [
-                ...converter.nodeTypes
-            ]
-        };
-        newConverter.nodeTypes = newConverter.nodeTypes.filter((nodeType)=>{
-            if (foundNodeTypes.includes(nodeType)) {
-                return false;
-            }
-            foundNodeTypes.push(nodeType);
-            return true;
-        });
-        if (newConverter.nodeTypes.length) {
-            filteredConverters.push(newConverter);
-        }
-    }
-    return filteredConverters;
-};
-// find the path of this field, as well as its sibling fields, by looking for this `field` in fields and traversing it recursively
-function findFieldPathAndSiblingFields(fields, path, field) {
-    for (const curField of fields){
-        if (curField === field) {
-            return {
-                path: [
-                    ...path,
-                    curField.name
-                ],
-                siblingFields: fields
-            };
-        }
-        if ('fields' in curField) {
-            const result = findFieldPathAndSiblingFields(curField.fields, 'name' in curField ? [
-                ...path,
-                curField.name
-            ] : [
-                ...path
-            ], field);
-            if (result) {
-                return result;
-            }
-        } else if ('tabs' in curField) {
-            for (const tab of curField.tabs){
-                const result = findFieldPathAndSiblingFields(tab.fields, 'name' in tab ? [
-                    ...path,
-                    tab.name
-                ] : [
-                    ...path
-                ], field);
-                if (result) {
-                    return result;
-                }
-            }
-        } else if ('blocks' in curField) {
-            for (const block of curField.blocks){
-                if (block?.fields?.length) {
-                    const result = findFieldPathAndSiblingFields(block.fields, [
-                        ...path,
-                        curField.name,
-                        block.slug
-                    ], field);
-                    if (result) {
-                        return result;
-                    }
-                }
-            }
-        }
-    }
-    return null;
-}
-export const lexicalHTML = (lexicalFieldName, props)=>{
-    const { name = 'lexicalHTML', hidden = true, storeInDB = false } = props;
-    return {
-        name,
-        type: 'code',
-        admin: {
-            editorOptions: {
-                language: 'html'
-            },
-            hidden
-        },
-        hooks: {
-            afterRead: [
-                async ({ collection, field, global, req, siblingData })=>{
-                    const fields = collection ? collection.fields : global.fields;
-                    const foundSiblingFields = findFieldPathAndSiblingFields(fields, [], field);
-                    if (!foundSiblingFields) throw new Error(`Could not find sibling fields of current lexicalHTML field with name ${field?.name}`);
-                    const { siblingFields } = foundSiblingFields;
-                    const lexicalField = siblingFields.find((field)=>'name' in field && field.name === lexicalFieldName);
-                    const lexicalFieldData = siblingData[lexicalFieldName];
-                    if (!lexicalFieldData) {
-                        return '';
-                    }
-                    if (!lexicalField) {
-                        throw new Error('You cannot use the lexicalHTML field because the referenced lexical field was not found');
-                    }
-                    const config = lexicalField?.editor?.editorConfig;
-                    if (!config) {
-                        throw new Error('The linked lexical field does not have an editorConfig. This is needed for the lexicalHTML field.');
-                    }
-                    if (!config?.resolvedFeatureMap?.has('htmlConverter')) {
-                        throw new Error('You cannot use the lexicalHTML field because the linked lexical field does not have a HTMLConverterFeature');
-                    }
-                    const finalConverters = consolidateHTMLConverters({
-                        editorConfig: config
-                    });
-                    return await convertLexicalToHTML({
-                        converters: finalConverters,
-                        data: lexicalFieldData,
-                        payload: req.payload
-                    });
-                }
-            ],
-            beforeChange: [
-                ({ siblingData, value })=>{
-                    if (storeInDB) {
-                        return value;
-                    }
-                    delete siblingData[name];
-                    return null;
-                }
-            ]
-        }
-    };
-};
-
-//# sourceMappingURL=index.js.map