@payloadcms/richtext-lexical 3.0.0-beta.10 → 3.0.0-beta.12

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/field/features/upload/feature.server.ts"],"sourcesContent":["import type { Field, FieldWithRichTextRequiredEditor, Payload } from 'payload/types'\n\nimport type { HTMLConverter } from '../converters/html/converter/types.js'\nimport type { FeatureProviderProviderServer } from '../types.js'\nimport type { UploadFeaturePropsClient } from './feature.client.js'\n\nimport { UploadFeatureClientComponent } from './feature.client.js'\nimport { type SerializedUploadNode, UploadNode } from './nodes/UploadNode.js'\nimport { uploadPopulationPromiseHOC } from './populationPromise.js'\nimport { uploadValidation } from './validate.js'\n\nexport type UploadFeatureProps = {\n  collections: {\n    [collection: string]: {\n      fields: FieldWithRichTextRequiredEditor[]\n    }\n  }\n}\n\n/**\n * Get the absolute URL for an upload URL by potentially prepending the serverURL\n */\nfunction getAbsoluteURL(url: string, payload: Payload): string {\n  return url?.startsWith('http') ? url : (payload?.config?.serverURL || '') + url\n}\n\nexport const UploadFeature: FeatureProviderProviderServer<\n  UploadFeatureProps,\n  UploadFeaturePropsClient\n> = (props) => {\n  if (!props) {\n    props = { collections: {} }\n  }\n\n  const clientProps: UploadFeaturePropsClient = { collections: {} }\n  if (props.collections) {\n    for (const collection in props.collections) {\n      clientProps.collections[collection] = {\n        hasExtraFields: props.collections[collection].fields.length >= 1,\n      }\n    }\n  }\n\n  return {\n    feature: () => {\n      return {\n        ClientComponent: UploadFeatureClientComponent,\n        clientFeatureProps: clientProps,\n        generateSchemaMap: ({ props }) => {\n          if (!props?.collections) return {}\n\n          const map: {\n            [key: string]: Field[]\n          } = {}\n\n          for (const collection in props.collections) {\n            map[collection] = props.collections[collection].fields\n          }\n\n          return map\n        },\n        nodes: [\n          {\n            converters: {\n              html: {\n                converter: async ({ node, payload }) => {\n                  if (payload) {\n                    let uploadDocument: any\n                    try {\n                      uploadDocument = await payload.findByID({\n                        id: node.value.id,\n                        collection: node.relationTo,\n                      })\n                    } catch (ignored) {\n                      // eslint-disable-next-line no-console\n                      console.error(\n                        'Lexical upload node HTML converter: error fetching upload file',\n                        ignored,\n                        'Node:',\n                        node,\n                      )\n                      return `<img />`\n                    }\n\n                    const url: string = getAbsoluteURL(uploadDocument?.url as string, payload)\n\n                    /**\n                     * If the upload is not an image, return a link to the upload\n                     */\n                    if (!(uploadDocument?.mimeType as string)?.startsWith('image')) {\n                      return `<a href=\"${url}\" rel=\"noopener noreferrer\">${uploadDocument.filename}</a>`\n                    }\n\n                    /**\n                     * If the upload is a simple image with no different sizes, return a simple img tag\n                     */\n                    if (!uploadDocument?.sizes || !Object.keys(uploadDocument?.sizes).length) {\n                      return `<img src=\"${url}\" alt=\"${uploadDocument?.filename}\" width=\"${uploadDocument?.width}\"  height=\"${uploadDocument?.height}\"/>`\n                    }\n\n                    /**\n                     * If the upload is an image with different sizes, return a picture element\n                     */\n                    let pictureHTML = '<picture>'\n\n                    // Iterate through each size in the data.sizes object\n                    for (const size in uploadDocument.sizes) {\n                      const imageSize = uploadDocument.sizes[size]\n\n                      // Skip if any property of the size object is null\n                      if (\n                        !imageSize.width ||\n                        !imageSize.height ||\n                        !imageSize.mimeType ||\n                        !imageSize.filesize ||\n                        !imageSize.filename ||\n                        !imageSize.url\n                      ) {\n                        continue\n                      }\n                      const imageSizeURL: string = getAbsoluteURL(imageSize?.url as string, payload)\n\n                      pictureHTML += `<source srcset=\"${imageSizeURL}\" media=\"(max-width: ${imageSize.width}px)\" type=\"${imageSize.mimeType}\">`\n                    }\n\n                    // Add the default img tag\n                    pictureHTML += `<img src=\"${url}\" alt=\"Image\" width=\"${uploadDocument.width}\" height=\"${uploadDocument.height}\">`\n                    pictureHTML += '</picture>'\n                    return pictureHTML\n                  } else {\n                    return `<img src=\"${node.value.id}\" />`\n                  }\n                },\n                nodeTypes: [UploadNode.getType()],\n              } as HTMLConverter<SerializedUploadNode>,\n            },\n            node: UploadNode,\n            populationPromises: [uploadPopulationPromiseHOC(props)],\n            validations: [uploadValidation()],\n          },\n        ],\n        serverFeatureProps: props,\n      }\n    },\n    key: 'upload',\n    serverFeatureProps: props,\n  }\n}\n"],"names":["UploadFeatureClientComponent","UploadNode","uploadPopulationPromiseHOC","uploadValidation","getAbsoluteURL","url","payload","startsWith","config","serverURL","UploadFeature","props","collections","clientProps","collection","hasExtraFields","fields","length","feature","ClientComponent","clientFeatureProps","generateSchemaMap","map","nodes","converters","html","converter","node","uploadDocument","findByID","id","value","relationTo","ignored","console","error","mimeType","filename","sizes","Object","keys","width","height","pictureHTML","size","imageSize","filesize","imageSizeURL","nodeTypes","getType","populationPromises","validations","serverFeatureProps","key"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}
+{"version":3,"sources":["../../../../src/field/features/upload/feature.server.ts"],"sourcesContent":["import type { Field, FieldWithRichTextRequiredEditor, Payload } from 'payload/types'\n\nimport { traverseFields } from '@payloadcms/next/utilities'\n\nimport type { HTMLConverter } from '../converters/html/converter/types.js'\nimport type { FeatureProviderProviderServer } from '../types.js'\nimport type { UploadFeaturePropsClient } from './feature.client.js'\n\nimport { UploadFeatureClientComponent } from './feature.client.js'\nimport { type SerializedUploadNode, UploadNode } from './nodes/UploadNode.js'\nimport { uploadPopulationPromiseHOC } from './populationPromise.js'\nimport { uploadValidation } from './validate.js'\n\nexport type UploadFeatureProps = {\n  collections: {\n    [collection: string]: {\n      fields: FieldWithRichTextRequiredEditor[]\n    }\n  }\n}\n\n/**\n * Get the absolute URL for an upload URL by potentially prepending the serverURL\n */\nfunction getAbsoluteURL(url: string, payload: Payload): string {\n  return url?.startsWith('http') ? url : (payload?.config?.serverURL || '') + url\n}\n\nexport const UploadFeature: FeatureProviderProviderServer<\n  UploadFeatureProps,\n  UploadFeaturePropsClient\n> = (props) => {\n  if (!props) {\n    props = { collections: {} }\n  }\n\n  const clientProps: UploadFeaturePropsClient = { collections: {} }\n  if (props.collections) {\n    for (const collection in props.collections) {\n      clientProps.collections[collection] = {\n        hasExtraFields: props.collections[collection].fields.length >= 1,\n      }\n    }\n  }\n\n  return {\n    feature: () => {\n      return {\n        ClientComponent: UploadFeatureClientComponent,\n        clientFeatureProps: clientProps,\n        generateSchemaMap: ({ config, i18n, props }) => {\n          if (!props?.collections) return null\n\n          const schemaMap = new Map<string, Field[]>()\n          const validRelationships = config.collections.map((c) => c.slug) || []\n\n          for (const collection in props.collections) {\n            if (props.collections[collection].fields?.length) {\n              schemaMap.set(collection, props.collections[collection].fields)\n              traverseFields({\n                config,\n                fields: props.collections[collection].fields,\n                i18n,\n                schemaMap,\n                schemaPath: collection,\n                validRelationships,\n              })\n            }\n          }\n\n          return schemaMap\n        },\n        nodes: [\n          {\n            converters: {\n              html: {\n                converter: async ({ node, payload }) => {\n                  if (payload) {\n                    let uploadDocument: any\n                    try {\n                      uploadDocument = await payload.findByID({\n                        id: node.value.id,\n                        collection: node.relationTo,\n                      })\n                    } catch (ignored) {\n                      // eslint-disable-next-line no-console\n                      console.error(\n                        'Lexical upload node HTML converter: error fetching upload file',\n                        ignored,\n                        'Node:',\n                        node,\n                      )\n                      return `<img />`\n                    }\n\n                    const url: string = getAbsoluteURL(uploadDocument?.url as string, payload)\n\n                    /**\n                     * If the upload is not an image, return a link to the upload\n                     */\n                    if (!(uploadDocument?.mimeType as string)?.startsWith('image')) {\n                      return `<a href=\"${url}\" rel=\"noopener noreferrer\">${uploadDocument.filename}</a>`\n                    }\n\n                    /**\n                     * If the upload is a simple image with no different sizes, return a simple img tag\n                     */\n                    if (!uploadDocument?.sizes || !Object.keys(uploadDocument?.sizes).length) {\n                      return `<img src=\"${url}\" alt=\"${uploadDocument?.filename}\" width=\"${uploadDocument?.width}\"  height=\"${uploadDocument?.height}\"/>`\n                    }\n\n                    /**\n                     * If the upload is an image with different sizes, return a picture element\n                     */\n                    let pictureHTML = '<picture>'\n\n                    // Iterate through each size in the data.sizes object\n                    for (const size in uploadDocument.sizes) {\n                      const imageSize = uploadDocument.sizes[size]\n\n                      // Skip if any property of the size object is null\n                      if (\n                        !imageSize.width ||\n                        !imageSize.height ||\n                        !imageSize.mimeType ||\n                        !imageSize.filesize ||\n                        !imageSize.filename ||\n                        !imageSize.url\n                      ) {\n                        continue\n                      }\n                      const imageSizeURL: string = getAbsoluteURL(imageSize?.url as string, payload)\n\n                      pictureHTML += `<source srcset=\"${imageSizeURL}\" media=\"(max-width: ${imageSize.width}px)\" type=\"${imageSize.mimeType}\">`\n                    }\n\n                    // Add the default img tag\n                    pictureHTML += `<img src=\"${url}\" alt=\"Image\" width=\"${uploadDocument.width}\" height=\"${uploadDocument.height}\">`\n                    pictureHTML += '</picture>'\n                    return pictureHTML\n                  } else {\n                    return `<img src=\"${node.value.id}\" />`\n                  }\n                },\n                nodeTypes: [UploadNode.getType()],\n              } as HTMLConverter<SerializedUploadNode>,\n            },\n            node: UploadNode,\n            populationPromises: [uploadPopulationPromiseHOC(props)],\n            validations: [uploadValidation()],\n          },\n        ],\n        serverFeatureProps: props,\n      }\n    },\n    key: 'upload',\n    serverFeatureProps: props,\n  }\n}\n"],"names":["traverseFields","UploadFeatureClientComponent","UploadNode","uploadPopulationPromiseHOC","uploadValidation","getAbsoluteURL","url","payload","startsWith","config","serverURL","UploadFeature","props","collections","clientProps","collection","hasExtraFields","fields","length","feature","ClientComponent","clientFeatureProps","generateSchemaMap","i18n","schemaMap","Map","validRelationships","map","c","slug","set","schemaPath","nodes","converters","html","converter","node","uploadDocument","findByID","id","value","relationTo","ignored","console","error","mimeType","filename","sizes","Object","keys","width","height","pictureHTML","size","imageSize","filesize","imageSizeURL","nodeTypes","getType","populationPromises","validations","serverFeatureProps","key"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/dist/generateComponentMap.js

@@ -41,24 +41,25 @@ export const getGenerateComponentMap = (args)=>({ WithServerSideProps, config, i
                     schemaMap: new Map(),
                     schemaPath
                 });
-                for(const schemaKey in schemas){
-                    const fields = schemas[schemaKey];
-                    const sanitizedFields = sanitizeFields({
-                        config,
-                        fields: cloneDeep(fields),
-                        requireFieldLevelRichTextEditor: true,
-                        validRelationships
-                    });
-                    const mappedFields = mapFields({
-                        WithServerSideProps,
-                        config,
-                        disableAddingID: true,
-                        fieldSchema: sanitizedFields,
-                        i18n,
-                        parentPath: `${schemaPath}.feature.${featureKey}.fields.${schemaKey}`,
-                        readOnly: false
-                    });
-                    componentMap.set(`feature.${featureKey}.fields.${schemaKey}`, mappedFields);
+                if (schemas) {
+                    for (const [schemaKey, fields] of schemas.entries()){
+                        const sanitizedFields = sanitizeFields({
+                            config,
+                            fields: cloneDeep(fields),
+                            requireFieldLevelRichTextEditor: true,
+                            validRelationships
+                        });
+                        const mappedFields = mapFields({
+                            WithServerSideProps,
+                            config,
+                            disableAddingID: true,
+                            fieldSchema: sanitizedFields,
+                            i18n,
+                            parentPath: `${schemaPath}.feature.${featureKey}.fields.${schemaKey}`,
+                            readOnly: false
+                        });
+                        componentMap.set(`feature.${featureKey}.fields.${schemaKey}`, mappedFields);
+                    }
                 }
             }
             if (!ClientComponent) {

package/dist/generateComponentMap.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/generateComponentMap.tsx"],"sourcesContent":["import type { RichTextAdapter } from 'payload/types'\n\nimport { mapFields } from '@payloadcms/ui/utilities/buildComponentMap'\nimport { sanitizeFields } from 'payload/config'\nimport React from 'react'\n\nimport type { ResolvedServerFeatureMap } from './field/features/types.js'\nimport type { GeneratedFeatureProviderComponent } from './types.js'\n\nimport { cloneDeep } from './field/lexical/utils/cloneDeep.js'\n\nexport const getGenerateComponentMap =\n  (args: {\n    resolvedFeatureMap: ResolvedServerFeatureMap\n  }): RichTextAdapter['generateComponentMap'] =>\n  ({ WithServerSideProps, config, i18n, schemaPath }) => {\n    const validRelationships = config.collections.map((c) => c.slug) || []\n\n    const componentMap = new Map()\n\n    // turn args.resolvedFeatureMap into an array of [key, value] pairs, ordered by value.order, lowest order first:\n    const resolvedFeatureMapArray = Array.from(args.resolvedFeatureMap.entries()).sort(\n      (a, b) => a[1].order - b[1].order,\n    )\n\n    componentMap.set(\n      `features`,\n      resolvedFeatureMapArray\n        .map(([featureKey, resolvedFeature]) => {\n          const ClientComponent = resolvedFeature.ClientComponent\n          const clientComponentProps = resolvedFeature.clientFeatureProps\n\n          /**\n           * Handle Feature Component Maps\n           */\n          if (\n            'generateComponentMap' in resolvedFeature &&\n            typeof resolvedFeature.generateComponentMap === 'function'\n          ) {\n            const components = resolvedFeature.generateComponentMap({\n              config,\n              i18n,\n              props: resolvedFeature.serverFeatureProps,\n              schemaPath,\n            })\n\n            for (const componentKey in components) {\n              const Component = components[componentKey]\n\n              if (Component) {\n                componentMap.set(\n                  `feature.${featureKey}.components.${componentKey}`,\n                  <WithServerSideProps\n                    Component={Component}\n                    componentKey={componentKey}\n                    featureKey={resolvedFeature.key}\n                    key={`${resolvedFeature.key}-${componentKey}`}\n                  />,\n                )\n              }\n            }\n          }\n\n          /**\n           * Handle Feature Schema Maps (rendered fields)\n           */\n          if (\n            'generateSchemaMap' in resolvedFeature &&\n            typeof resolvedFeature.generateSchemaMap === 'function'\n          ) {\n            const schemas = resolvedFeature.generateSchemaMap({\n              config,\n              i18n,\n              props: resolvedFeature.serverFeatureProps,\n              schemaMap: new Map(),\n              schemaPath,\n            })\n\n            for (const schemaKey in schemas) {\n              const fields = schemas[schemaKey]\n\n              const sanitizedFields = sanitizeFields({\n                config,\n                fields: cloneDeep(fields),\n                requireFieldLevelRichTextEditor: true,\n                validRelationships,\n              })\n\n              const mappedFields = mapFields({\n                WithServerSideProps,\n                config,\n                disableAddingID: true,\n                fieldSchema: sanitizedFields,\n                i18n,\n                parentPath: `${schemaPath}.feature.${featureKey}.fields.${schemaKey}`,\n                readOnly: false,\n              })\n\n              componentMap.set(`feature.${featureKey}.fields.${schemaKey}`, mappedFields)\n            }\n          }\n\n          if (!ClientComponent) {\n            return null\n          }\n\n          return {\n            ClientComponent:\n              clientComponentProps && typeof clientComponentProps === 'object' ? (\n                <ClientComponent\n                  {...clientComponentProps}\n                  featureKey={resolvedFeature.key}\n                  key={resolvedFeature.key}\n                  order={resolvedFeature.order}\n                />\n              ) : (\n                <ClientComponent\n                  featureKey={resolvedFeature.key}\n                  key={resolvedFeature.key}\n                  order={resolvedFeature.order}\n                />\n              ),\n            key: resolvedFeature.key,\n            order: resolvedFeature.order,\n          } as GeneratedFeatureProviderComponent\n        })\n        .filter((feature) => feature !== null),\n    )\n\n    return componentMap\n  }\n"],"names":["mapFields","sanitizeFields","React","cloneDeep","getGenerateComponentMap","args","WithServerSideProps","config","i18n","schemaPath","validRelationships","collections","map","c","slug","componentMap","Map","resolvedFeatureMapArray","Array","from","resolvedFeatureMap","entries","sort","a","b","order","set","featureKey","resolvedFeature","ClientComponent","clientComponentProps","clientFeatureProps","generateComponentMap","components","props","serverFeatureProps","componentKey","Component","key","generateSchemaMap","schemas","schemaMap","schemaKey","fields","sanitizedFields","requireFieldLevelRichTextEditor","mappedFields","disableAddingID","fieldSchema","parentPath","readOnly","filter","feature"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}
+{"version":3,"sources":["../src/generateComponentMap.tsx"],"sourcesContent":["import type { RichTextAdapter } from 'payload/types'\n\nimport { mapFields } from '@payloadcms/ui/utilities/buildComponentMap'\nimport { sanitizeFields } from 'payload/config'\nimport React from 'react'\n\nimport type { ResolvedServerFeatureMap } from './field/features/types.js'\nimport type { GeneratedFeatureProviderComponent } from './types.js'\n\nimport { cloneDeep } from './field/lexical/utils/cloneDeep.js'\n\nexport const getGenerateComponentMap =\n  (args: {\n    resolvedFeatureMap: ResolvedServerFeatureMap\n  }): RichTextAdapter['generateComponentMap'] =>\n  ({ WithServerSideProps, config, i18n, schemaPath }) => {\n    const validRelationships = config.collections.map((c) => c.slug) || []\n\n    const componentMap = new Map()\n\n    // turn args.resolvedFeatureMap into an array of [key, value] pairs, ordered by value.order, lowest order first:\n    const resolvedFeatureMapArray = Array.from(args.resolvedFeatureMap.entries()).sort(\n      (a, b) => a[1].order - b[1].order,\n    )\n\n    componentMap.set(\n      `features`,\n      resolvedFeatureMapArray\n        .map(([featureKey, resolvedFeature]) => {\n          const ClientComponent = resolvedFeature.ClientComponent\n          const clientComponentProps = resolvedFeature.clientFeatureProps\n\n          /**\n           * Handle Feature Component Maps\n           */\n          if (\n            'generateComponentMap' in resolvedFeature &&\n            typeof resolvedFeature.generateComponentMap === 'function'\n          ) {\n            const components = resolvedFeature.generateComponentMap({\n              config,\n              i18n,\n              props: resolvedFeature.serverFeatureProps,\n              schemaPath,\n            })\n\n            for (const componentKey in components) {\n              const Component = components[componentKey]\n\n              if (Component) {\n                componentMap.set(\n                  `feature.${featureKey}.components.${componentKey}`,\n                  <WithServerSideProps\n                    Component={Component}\n                    componentKey={componentKey}\n                    featureKey={resolvedFeature.key}\n                    key={`${resolvedFeature.key}-${componentKey}`}\n                  />,\n                )\n              }\n            }\n          }\n\n          /**\n           * Handle Feature Schema Maps (rendered fields)\n           */\n          if (\n            'generateSchemaMap' in resolvedFeature &&\n            typeof resolvedFeature.generateSchemaMap === 'function'\n          ) {\n            const schemas = resolvedFeature.generateSchemaMap({\n              config,\n              i18n,\n              props: resolvedFeature.serverFeatureProps,\n              schemaMap: new Map(),\n              schemaPath,\n            })\n\n            if (schemas) {\n              for (const [schemaKey, fields] of schemas.entries()) {\n                const sanitizedFields = sanitizeFields({\n                  config,\n                  fields: cloneDeep(fields),\n                  requireFieldLevelRichTextEditor: true,\n                  validRelationships,\n                })\n\n                const mappedFields = mapFields({\n                  WithServerSideProps,\n                  config,\n                  disableAddingID: true,\n                  fieldSchema: sanitizedFields,\n                  i18n,\n                  parentPath: `${schemaPath}.feature.${featureKey}.fields.${schemaKey}`,\n                  readOnly: false,\n                })\n\n                componentMap.set(`feature.${featureKey}.fields.${schemaKey}`, mappedFields)\n              }\n            }\n          }\n\n          if (!ClientComponent) {\n            return null\n          }\n\n          return {\n            ClientComponent:\n              clientComponentProps && typeof clientComponentProps === 'object' ? (\n                <ClientComponent\n                  {...clientComponentProps}\n                  featureKey={resolvedFeature.key}\n                  key={resolvedFeature.key}\n                  order={resolvedFeature.order}\n                />\n              ) : (\n                <ClientComponent\n                  featureKey={resolvedFeature.key}\n                  key={resolvedFeature.key}\n                  order={resolvedFeature.order}\n                />\n              ),\n            key: resolvedFeature.key,\n            order: resolvedFeature.order,\n          } as GeneratedFeatureProviderComponent\n        })\n        .filter((feature) => feature !== null),\n    )\n\n    return componentMap\n  }\n"],"names":["mapFields","sanitizeFields","React","cloneDeep","getGenerateComponentMap","args","WithServerSideProps","config","i18n","schemaPath","validRelationships","collections","map","c","slug","componentMap","Map","resolvedFeatureMapArray","Array","from","resolvedFeatureMap","entries","sort","a","b","order","set","featureKey","resolvedFeature","ClientComponent","clientComponentProps","clientFeatureProps","generateComponentMap","components","props","serverFeatureProps","componentKey","Component","key","generateSchemaMap","schemas","schemaMap","schemaKey","fields","sanitizedFields","requireFieldLevelRichTextEditor","mappedFields","disableAddingID","fieldSchema","parentPath","readOnly","filter","feature"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAEA,SAASA,SAAS,QAAQ,6CAA4C;AACtE,SAASC,cAAc,QAAQ,iBAAgB;AAC/C,OAAOC,WAAW,QAAO;AAKzB,SAASC,SAAS,QAAQ,qCAAoC;AAE9D,OAAO,MAAMC,0BACX,CAACC,OAGD,CAAC,EAAEC,mBAAmB,EAAEC,MAAM,EAAEC,IAAI,EAAEC,UAAU,EAAE;QAChD,MAAMC,qBAAqBH,OAAOI,WAAW,CAACC,GAAG,CAAC,CAACC,IAAMA,EAAEC,IAAI,KAAK,EAAE;QAEtE,MAAMC,eAAe,IAAIC;QAEzB,gHAAgH;QAChH,MAAMC,0BAA0BC,MAAMC,IAAI,CAACd,KAAKe,kBAAkB,CAACC,OAAO,IAAIC,IAAI,CAChF,CAACC,GAAGC,IAAMD,CAAC,CAAC,EAAE,CAACE,KAAK,GAAGD,CAAC,CAAC,EAAE,CAACC,KAAK;QAGnCV,aAAaW,GAAG,CACd,CAAC,QAAQ,CAAC,EACVT,wBACGL,GAAG,CAAC,CAAC,CAACe,YAAYC,gBAAgB;YACjC,MAAMC,kBAAkBD,gBAAgBC,eAAe;YACvD,MAAMC,uBAAuBF,gBAAgBG,kBAAkB;YAE/D;;WAEC,GACD,IACE,0BAA0BH,mBAC1B,OAAOA,gBAAgBI,oBAAoB,KAAK,YAChD;gBACA,MAAMC,aAAaL,gBAAgBI,oBAAoB,CAAC;oBACtDzB;oBACAC;oBACA0B,OAAON,gBAAgBO,kBAAkB;oBACzC1B;gBACF;gBAEA,IAAK,MAAM2B,gBAAgBH,WAAY;oBACrC,MAAMI,YAAYJ,UAAU,CAACG,aAAa;oBAE1C,IAAIC,WAAW;wBACbtB,aAAaW,GAAG,CACd,CAAC,QAAQ,EAAEC,WAAW,YAAY,EAAES,aAAa,CAAC,gBAClD,oBAAC9B;4BACC+B,WAAWA;4BACXD,cAAcA;4BACdT,YAAYC,gBAAgBU,GAAG;4BAC/BA,KAAK,CAAC,EAAEV,gBAAgBU,GAAG,CAAC,CAAC,EAAEF,aAAa,CAAC;;oBAGnD;gBACF;YACF;YAEA;;WAEC,GACD,IACE,uBAAuBR,mBACvB,OAAOA,gBAAgBW,iBAAiB,KAAK,YAC7C;gBACA,MAAMC,UAAUZ,gBAAgBW,iBAAiB,CAAC;oBAChDhC;oBACAC;oBACA0B,OAAON,gBAAgBO,kBAAkB;oBACzCM,WAAW,IAAIzB;oBACfP;gBACF;gBAEA,IAAI+B,SAAS;oBACX,KAAK,MAAM,CAACE,WAAWC,OAAO,IAAIH,QAAQnB,OAAO,GAAI;wBACnD,MAAMuB,kBAAkB3C,eAAe;4BACrCM;4BACAoC,QAAQxC,UAAUwC;4BAClBE,iCAAiC;4BACjCnC;wBACF;wBAEA,MAAMoC,eAAe9C,UAAU;4BAC7BM;4BACAC;4BACAwC,iBAAiB;4BACjBC,aAAaJ;4BACbpC;4BACAyC,YAAY,CAAC,EAAExC,WAAW,SAAS,EAAEkB,WAAW,QAAQ,EAAEe,UAAU,CAAC;4BACrEQ,UAAU;wBACZ;wBAEAnC,aAAaW,GAAG,CAAC,CAAC,QAAQ,EAAEC,WAAW,QAAQ,EAAEe,UAAU,CAAC,EAAEI;oBAChE;gBACF;YACF;YAEA,IAAI,CAACjB,iBAAiB;gBACpB,OAAO;YACT;YAEA,OAAO;gBACLA,iBACEC,wBAAwB,OAAOA,yBAAyB,yBACtD,oBAACD;oBACE,GAAGC,oBAAoB;oBACxBH,YAAYC,gBAAgBU,GAAG;oBAC/BA,KAAKV,gBAAgBU,GAAG;oBACxBb,OAAOG,gBAAgBH,KAAK;mCAG9B,oBAACI;oBACCF,YAAYC,gBAAgBU,GAAG;oBAC/BA,KAAKV,gBAAgBU,GAAG;oBACxBb,OAAOG,gBAAgBH,KAAK;;gBAGlCa,KAAKV,gBAAgBU,GAAG;gBACxBb,OAAOG,gBAAgBH,KAAK;YAC9B;QACF,GACC0B,MAAM,CAAC,CAACC,UAAYA,YAAY;QAGrC,OAAOrC;IACT,EAAC"}

package/dist/generateSchemaMap.js

@@ -13,15 +13,16 @@ export const getGenerateSchemaMap = (args)=>({ config, i18n, schemaMap, schemaPa
                 schemaMap,
                 schemaPath
             });
-            for(const schemaKey in schemas){
-                const fields = schemas[schemaKey];
-                const sanitizedFields = sanitizeFields({
-                    config,
-                    fields: cloneDeep(fields),
-                    requireFieldLevelRichTextEditor: true,
-                    validRelationships
-                });
-                schemaMap.set(`${schemaPath}.feature.${featureKey}.${schemaKey}`, sanitizedFields);
+            if (schemas) {
+                for (const [schemaKey, fields] of schemas.entries()){
+                    const sanitizedFields = sanitizeFields({
+                        config,
+                        fields: cloneDeep(fields),
+                        requireFieldLevelRichTextEditor: true,
+                        validRelationships
+                    });
+                    schemaMap.set(`${schemaPath}.feature.${featureKey}.${schemaKey}`, sanitizedFields);
+                }
             }
         }
         return schemaMap;

package/dist/generateSchemaMap.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/generateSchemaMap.ts"],"sourcesContent":["import type { RichTextAdapter } from 'payload/types'\n\nimport { sanitizeFields } from 'payload/config'\n\nimport type { ResolvedServerFeatureMap } from './field/features/types.js'\n\nimport { cloneDeep } from './field/lexical/utils/cloneDeep.js'\n\nexport const getGenerateSchemaMap =\n  (args: { resolvedFeatureMap: ResolvedServerFeatureMap }): RichTextAdapter['generateSchemaMap'] =>\n  ({ config, i18n, schemaMap, schemaPath }) => {\n    const validRelationships = config.collections.map((c) => c.slug) || []\n\n    for (const [featureKey, resolvedFeature] of args.resolvedFeatureMap.entries()) {\n      if (\n        !('generateSchemaMap' in resolvedFeature) ||\n        typeof resolvedFeature.generateSchemaMap !== 'function'\n      ) {\n        continue\n      }\n      const schemas = resolvedFeature.generateSchemaMap({\n        config,\n        i18n,\n        props: resolvedFeature.serverFeatureProps,\n        schemaMap,\n        schemaPath,\n      })\n\n      for (const schemaKey in schemas) {\n        const fields = schemas[schemaKey]\n\n        const sanitizedFields = sanitizeFields({\n          config,\n          fields: cloneDeep(fields),\n          requireFieldLevelRichTextEditor: true,\n          validRelationships,\n        })\n\n        schemaMap.set(`${schemaPath}.feature.${featureKey}.${schemaKey}`, sanitizedFields)\n      }\n    }\n\n    return schemaMap\n  }\n"],"names":["sanitizeFields","cloneDeep","getGenerateSchemaMap","args","config","i18n","schemaMap","schemaPath","validRelationships","collections","map","c","slug","featureKey","resolvedFeature","resolvedFeatureMap","entries","generateSchemaMap","schemas","props","serverFeatureProps","schemaKey","fields","sanitizedFields","requireFieldLevelRichTextEditor","set"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAEA,SAASA,cAAc,QAAQ,iBAAgB;AAI/C,SAASC,SAAS,QAAQ,qCAAoC;AAE9D,OAAO,MAAMC,uBACX,CAACC,OACD,CAAC,EAAEC,MAAM,EAAEC,IAAI,EAAEC,SAAS,EAAEC,UAAU,EAAE;QACtC,MAAMC,qBAAqBJ,OAAOK,WAAW,CAACC,GAAG,CAAC,CAACC,IAAMA,EAAEC,IAAI,KAAK,EAAE;QAEtE,KAAK,MAAM,CAACC,YAAYC,gBAAgB,IAAIX,KAAKY,kBAAkB,CAACC,OAAO,GAAI;YAC7E,IACE,CAAE,CAAA,uBAAuBF,eAAc,KACvC,OAAOA,gBAAgBG,iBAAiB,KAAK,YAC7C;gBACA;YACF;YACA,MAAMC,UAAUJ,gBAAgBG,iBAAiB,CAAC;gBAChDb;gBACAC;gBACAc,OAAOL,gBAAgBM,kBAAkB;gBACzCd;gBACAC;YACF;YAEA,IAAK,MAAMc,aAAaH,QAAS;gBAC/B,MAAMI,SAASJ,OAAO,CAACG,UAAU;gBAEjC,MAAME,kBAAkBvB,eAAe;oBACrCI;oBACAkB,QAAQrB,UAAUqB;oBAClBE,iCAAiC;oBACjChB;gBACF;gBAEAF,UAAUmB,GAAG,CAAC,CAAC,EAAElB,WAAW,SAAS,EAAEM,WAAW,CAAC,EAAEQ,UAAU,CAAC,EAAEE;YACpE;QACF;QAEA,OAAOjB;IACT,EAAC"}
+{"version":3,"sources":["../src/generateSchemaMap.ts"],"sourcesContent":["import type { RichTextAdapter } from 'payload/types'\n\nimport { sanitizeFields } from 'payload/config'\n\nimport type { ResolvedServerFeatureMap } from './field/features/types.js'\n\nimport { cloneDeep } from './field/lexical/utils/cloneDeep.js'\n\nexport const getGenerateSchemaMap =\n  (args: { resolvedFeatureMap: ResolvedServerFeatureMap }): RichTextAdapter['generateSchemaMap'] =>\n  ({ config, i18n, schemaMap, schemaPath }) => {\n    const validRelationships = config.collections.map((c) => c.slug) || []\n\n    for (const [featureKey, resolvedFeature] of args.resolvedFeatureMap.entries()) {\n      if (\n        !('generateSchemaMap' in resolvedFeature) ||\n        typeof resolvedFeature.generateSchemaMap !== 'function'\n      ) {\n        continue\n      }\n      const schemas = resolvedFeature.generateSchemaMap({\n        config,\n        i18n,\n        props: resolvedFeature.serverFeatureProps,\n        schemaMap,\n        schemaPath,\n      })\n\n      if (schemas) {\n        for (const [schemaKey, fields] of schemas.entries()) {\n          const sanitizedFields = sanitizeFields({\n            config,\n            fields: cloneDeep(fields),\n            requireFieldLevelRichTextEditor: true,\n            validRelationships,\n          })\n\n          schemaMap.set(`${schemaPath}.feature.${featureKey}.${schemaKey}`, sanitizedFields)\n        }\n      }\n    }\n\n    return schemaMap\n  }\n"],"names":["sanitizeFields","cloneDeep","getGenerateSchemaMap","args","config","i18n","schemaMap","schemaPath","validRelationships","collections","map","c","slug","featureKey","resolvedFeature","resolvedFeatureMap","entries","generateSchemaMap","schemas","props","serverFeatureProps","schemaKey","fields","sanitizedFields","requireFieldLevelRichTextEditor","set"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAEA,SAASA,cAAc,QAAQ,iBAAgB;AAI/C,SAASC,SAAS,QAAQ,qCAAoC;AAE9D,OAAO,MAAMC,uBACX,CAACC,OACD,CAAC,EAAEC,MAAM,EAAEC,IAAI,EAAEC,SAAS,EAAEC,UAAU,EAAE;QACtC,MAAMC,qBAAqBJ,OAAOK,WAAW,CAACC,GAAG,CAAC,CAACC,IAAMA,EAAEC,IAAI,KAAK,EAAE;QAEtE,KAAK,MAAM,CAACC,YAAYC,gBAAgB,IAAIX,KAAKY,kBAAkB,CAACC,OAAO,GAAI;YAC7E,IACE,CAAE,CAAA,uBAAuBF,eAAc,KACvC,OAAOA,gBAAgBG,iBAAiB,KAAK,YAC7C;gBACA;YACF;YACA,MAAMC,UAAUJ,gBAAgBG,iBAAiB,CAAC;gBAChDb;gBACAC;gBACAc,OAAOL,gBAAgBM,kBAAkB;gBACzCd;gBACAC;YACF;YAEA,IAAIW,SAAS;gBACX,KAAK,MAAM,CAACG,WAAWC,OAAO,IAAIJ,QAAQF,OAAO,GAAI;oBACnD,MAAMO,kBAAkBvB,eAAe;wBACrCI;wBACAkB,QAAQrB,UAAUqB;wBAClBE,iCAAiC;wBACjChB;oBACF;oBAEAF,UAAUmB,GAAG,CAAC,CAAC,EAAElB,WAAW,SAAS,EAAEM,WAAW,CAAC,EAAEQ,UAAU,CAAC,EAAEE;gBACpE;YACF;QACF;QAEA,OAAOjB;IACT,EAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@payloadcms/richtext-lexical",
-  "version": "3.0.0-beta.10",
+  "version": "3.0.0-beta.12",
   "description": "The officially supported Lexical richtext adapter for Payload",
   "repository": {
     "type": "git",
@@ -40,17 +40,17 @@
     "@types/node": "20.12.5",
     "@types/react": "18.2.74",
     "@types/react-dom": "18.2.24",
+    "payload": "3.0.0-beta.12",
+    "@payloadcms/ui": "3.0.0-beta.12",
     "@payloadcms/eslint-config": "1.1.1",
-    "@payloadcms/next": "3.0.0-beta.10",
-    "@payloadcms/translations": "3.0.0-beta.10",
-    "@payloadcms/ui": "3.0.0-beta.10",
-    "payload": "3.0.0-beta.10"
+    "@payloadcms/translations": "3.0.0-beta.12",
+    "@payloadcms/next": "3.0.0-beta.12"
   },
   "peerDependencies": {
-    "@payloadcms/next": "3.0.0-beta.10",
-    "@payloadcms/translations": "3.0.0-beta.10",
-    "payload": "3.0.0-beta.10",
-    "@payloadcms/ui": "3.0.0-beta.10"
+    "@payloadcms/translations": "3.0.0-beta.12",
+    "@payloadcms/ui": "3.0.0-beta.12",
+    "@payloadcms/next": "3.0.0-beta.12",
+    "payload": "3.0.0-beta.12"
   },
   "exports": {
     ".": {

package/src/index.ts

@@ -1,423 +0,0 @@
-import type { JSONSchema4 } from 'json-schema'
-import type { EditorConfig as LexicalEditorConfig } from 'lexical/LexicalEditor.js'
-
-import { withMergedProps } from '@payloadcms/ui/elements/withMergedProps'
-import { withNullableJSONSchemaType } from 'payload/utilities'
-
-import type { FeatureProviderServer, ResolvedServerFeatureMap } from './field/features/types.js'
-import type { SanitizedServerEditorConfig } from './field/lexical/config/types.js'
-import type { AdapterProps, LexicalEditorProps, LexicalRichTextAdapter } from './types.js'
-
-import { RichTextCell } from './cell/index.js'
-import { RichTextField } from './field/index.js'
-import {
-  defaultEditorConfig,
-  defaultEditorFeatures,
-  defaultSanitizedServerEditorConfig,
-} from './field/lexical/config/server/default.js'
-import { loadFeatures } from './field/lexical/config/server/loader.js'
-import { sanitizeServerFeatures } from './field/lexical/config/server/sanitize.js'
-import { cloneDeep } from './field/lexical/utils/cloneDeep.js'
-import { getGenerateComponentMap } from './generateComponentMap.js'
-import { getGenerateSchemaMap } from './generateSchemaMap.js'
-import { richTextRelationshipPromise } from './populate/richTextRelationshipPromise.js'
-import { richTextValidateHOC } from './validate/index.js'
-
-export function lexicalEditor(props?: LexicalEditorProps): LexicalRichTextAdapter {
-  let resolvedFeatureMap: ResolvedServerFeatureMap = null
-
-  let finalSanitizedEditorConfig: SanitizedServerEditorConfig // For server only
-  if (!props || (!props.features && !props.lexical)) {
-    finalSanitizedEditorConfig = cloneDeep(defaultSanitizedServerEditorConfig)
-    resolvedFeatureMap = finalSanitizedEditorConfig.resolvedFeatureMap
-  } else {
-    let features: FeatureProviderServer<unknown, unknown>[] =
-      props.features && typeof props.features === 'function'
-        ? props.features({ defaultFeatures: cloneDeep(defaultEditorFeatures) })
-        : (props.features as FeatureProviderServer<unknown, unknown>[])
-    if (!features) {
-      features = cloneDeep(defaultEditorFeatures)
-    }
-
-    const lexical: LexicalEditorConfig = props.lexical
-
-    resolvedFeatureMap = loadFeatures({
-      unSanitizedEditorConfig: {
-        features,
-        lexical: lexical ? lexical : defaultEditorConfig.lexical,
-      },
-    })
-
-    finalSanitizedEditorConfig = {
-      features: sanitizeServerFeatures(resolvedFeatureMap),
-      lexical: lexical ? lexical : defaultEditorConfig.lexical,
-      resolvedFeatureMap,
-    }
-  }
-
-  return {
-    CellComponent: withMergedProps({
-      Component: RichTextCell,
-      toMergeIntoProps: { lexicalEditorConfig: finalSanitizedEditorConfig.lexical },
-    }),
-    FieldComponent: withMergedProps({
-      Component: RichTextField,
-      toMergeIntoProps: { lexicalEditorConfig: finalSanitizedEditorConfig.lexical },
-    }),
-    afterReadPromise: ({ field, incomingEditorState, siblingDoc }) => {
-      return new Promise<void>((resolve, reject) => {
-        const promises: Promise<void>[] = []
-
-        if (finalSanitizedEditorConfig?.features?.hooks?.afterReadPromises?.length) {
-          for (const afterReadPromise of finalSanitizedEditorConfig.features.hooks
-            .afterReadPromises) {
-            const promise = afterReadPromise({
-              field,
-              incomingEditorState,
-              siblingDoc,
-            })
-            if (promise) {
-              promises.push(promise)
-            }
-          }
-        }
-
-        Promise.all(promises)
-          .then(() => resolve())
-          .catch((error) => reject(error))
-      })
-    },
-    editorConfig: finalSanitizedEditorConfig,
-    generateComponentMap: getGenerateComponentMap({
-      resolvedFeatureMap,
-    }),
-    generateSchemaMap: getGenerateSchemaMap({
-      resolvedFeatureMap,
-    }),
-    outputSchema: ({
-      collectionIDFieldTypes,
-      config,
-      field,
-      interfaceNameDefinitions,
-      isRequired,
-    }) => {
-      let outputSchema: JSONSchema4 = {
-        // This schema matches the SerializedEditorState type so far, that it's possible to cast SerializedEditorState to this schema without any errors.
-        // In the future, we should
-        // 1) allow recursive children
-        // 2) Pass in all the different types for every node added to the editorconfig. This can be done with refs in the schema.
-        type: withNullableJSONSchemaType('object', isRequired),
-        properties: {
-          root: {
-            type: 'object',
-            additionalProperties: false,
-            properties: {
-              type: {
-                type: 'string',
-              },
-              children: {
-                type: 'array',
-                items: {
-                  type: 'object',
-                  additionalProperties: true,
-                  properties: {
-                    type: {
-                      type: 'string',
-                    },
-                    version: {
-                      type: 'integer',
-                    },
-                  },
-                  required: ['type', 'version'],
-                },
-              },
-              direction: {
-                oneOf: [
-                  {
-                    enum: ['ltr', 'rtl'],
-                  },
-                  {
-                    type: 'null',
-                  },
-                ],
-              },
-              format: {
-                type: 'string',
-                enum: ['left', 'start', 'center', 'right', 'end', 'justify', ''], // ElementFormatType, since the root node is an element
-              },
-              indent: {
-                type: 'integer',
-              },
-              version: {
-                type: 'integer',
-              },
-            },
-            required: ['children', 'direction', 'format', 'indent', 'type', 'version'],
-          },
-        },
-        required: ['root'],
-      }
-      for (const modifyOutputSchema of finalSanitizedEditorConfig.features.generatedTypes
-        .modifyOutputSchemas) {
-        outputSchema = modifyOutputSchema({
-          collectionIDFieldTypes,
-          config,
-          currentSchema: outputSchema,
-          field,
-          interfaceNameDefinitions,
-          isRequired,
-        })
-      }
-
-      return outputSchema
-    },
-    populationPromise({
-      context,
-      currentDepth,
-      depth,
-      field,
-      findMany,
-      flattenLocales,
-      overrideAccess,
-      populationPromises,
-      req,
-      showHiddenFields,
-      siblingDoc,
-    }) {
-      // check if there are any features with nodes which have populationPromises for this field
-      if (finalSanitizedEditorConfig?.features?.populationPromises?.size) {
-        return richTextRelationshipPromise({
-          context,
-          currentDepth,
-          depth,
-          editorPopulationPromises: finalSanitizedEditorConfig.features.populationPromises,
-          field,
-          findMany,
-          flattenLocales,
-          overrideAccess,
-          populationPromises,
-          req,
-          showHiddenFields,
-          siblingDoc,
-        })
-      }
-
-      return null
-    },
-    validate: richTextValidateHOC({
-      editorConfig: finalSanitizedEditorConfig,
-    }),
-  }
-}
-
-export { AlignFeature } from './field/features/align/feature.server.js'
-export { BlockQuoteFeature } from './field/features/blockquote/feature.server.js'
-export {
-  BlocksFeature,
-  type BlocksFeatureProps,
-  type LexicalBlock,
-} from './field/features/blocks/feature.server.js'
-export {
-  $createBlockNode,
-  $isBlockNode,
-  type BlockFields,
-  BlockNode,
-  type SerializedBlockNode,
-} from './field/features/blocks/nodes/BlocksNode.js'
-
-export { TextDropdownSectionWithEntries } from './field/features/common/floatingSelectToolbarTextDropdownSection/index.js'
-export { LinebreakHTMLConverter } from './field/features/converters/html/converter/converters/linebreak.js'
-export { ParagraphHTMLConverter } from './field/features/converters/html/converter/converters/paragraph.js'
-
-export { TextHTMLConverter } from './field/features/converters/html/converter/converters/text.js'
-export { defaultHTMLConverters } from './field/features/converters/html/converter/defaultConverters.js'
-export {
-  convertLexicalNodesToHTML,
-  convertLexicalToHTML,
-} from './field/features/converters/html/converter/index.js'
-export type { HTMLConverter } from './field/features/converters/html/converter/types.js'
-export {
-  HTMLConverterFeature,
-  type HTMLConverterFeatureProps,
-} from './field/features/converters/html/feature.server.js'
-export {
-  consolidateHTMLConverters,
-  lexicalHTML,
-} from './field/features/converters/html/field/index.js'
-export { createClientComponent } from './field/features/createClientComponent.js'
-export { TestRecorderFeature } from './field/features/debug/testrecorder/feature.server.js'
-export { TreeViewFeature } from './field/features/debug/treeview/feature.server.js'
-export { BoldFeature } from './field/features/format/bold/feature.server.js'
-export { SectionWithEntries as FormatSectionWithEntries } from './field/features/format/common/floatingSelectToolbarSection.js'
-export { InlineCodeFeature } from './field/features/format/inlinecode/feature.server.js'
-export { ItalicFeature } from './field/features/format/italic/feature.server.js'
-export { StrikethroughFeature } from './field/features/format/strikethrough/feature.server.js'
-export { SubscriptFeature } from './field/features/format/subscript/feature.server.js'
-export { SuperscriptFeature } from './field/features/format/superscript/feature.server.js'
-export { UnderlineFeature } from './field/features/format/underline/feature.server.js'
-
-export { HeadingFeature } from './field/features/heading/feature.server.js'
-export { IndentFeature } from './field/features/indent/feature.server.js'
-
-export { LinkFeature, type LinkFeatureServerProps } from './field/features/link/feature.server.js'
-export {
-  $createAutoLinkNode,
-  $isAutoLinkNode,
-  AutoLinkNode,
-} from './field/features/link/nodes/AutoLinkNode.js'
-export {
-  $createLinkNode,
-  $isLinkNode,
-  LinkNode,
-  TOGGLE_LINK_COMMAND,
-} from './field/features/link/nodes/LinkNode.js'
-export type {
-  LinkFields,
-  SerializedAutoLinkNode,
-  SerializedLinkNode,
-} from './field/features/link/nodes/types.js'
-export { CheckListFeature } from './field/features/lists/checklist/feature.server.js'
-export { OrderedListFeature } from './field/features/lists/orderedlist/feature.server.js'
-export { UnorderedListFeature } from './field/features/lists/unorderedlist/feature.server.js'
-export { LexicalPluginToLexicalFeature } from './field/features/migrations/lexicalPluginToLexical/feature.server.js'
-export { SlateBlockquoteConverter } from './field/features/migrations/slateToLexical/converter/converters/blockquote/index.js'
-export { SlateHeadingConverter } from './field/features/migrations/slateToLexical/converter/converters/heading/index.js'
-export { SlateIndentConverter } from './field/features/migrations/slateToLexical/converter/converters/indent/index.js'
-export { SlateLinkConverter } from './field/features/migrations/slateToLexical/converter/converters/link/index.js'
-export { SlateListItemConverter } from './field/features/migrations/slateToLexical/converter/converters/listItem/index.js'
-export { SlateOrderedListConverter } from './field/features/migrations/slateToLexical/converter/converters/orderedList/index.js'
-export { SlateRelationshipConverter } from './field/features/migrations/slateToLexical/converter/converters/relationship/index.js'
-export { SlateUnknownConverter } from './field/features/migrations/slateToLexical/converter/converters/unknown/index.js'
-export { SlateUnorderedListConverter } from './field/features/migrations/slateToLexical/converter/converters/unorderedList/index.js'
-
-export { SlateUploadConverter } from './field/features/migrations/slateToLexical/converter/converters/upload/index.js'
-export { defaultSlateConverters } from './field/features/migrations/slateToLexical/converter/defaultConverters.js'
-export {
-  convertSlateNodesToLexical,
-  convertSlateToLexical,
-} from './field/features/migrations/slateToLexical/converter/index.js'
-
-export type {
-  SlateNode,
-  SlateNodeConverter,
-} from './field/features/migrations/slateToLexical/converter/types.js'
-export { SlateToLexicalFeature } from './field/features/migrations/slateToLexical/feature.server.js'
-export { ParagraphFeature } from './field/features/paragraph/feature.server.js'
-export { RelationshipFeature } from './field/features/relationship/feature.server.js'
-export {
-  $createRelationshipNode,
-  $isRelationshipNode,
-  type RelationshipData,
-  RelationshipNode,
-  type SerializedRelationshipNode,
-} from './field/features/relationship/nodes/RelationshipNode.js'
-export type {
-  ClientFeature,
-  ClientFeatureProviderMap,
-  FeatureProviderClient,
-  FeatureProviderProviderClient,
-  FeatureProviderProviderServer,
-  FeatureProviderServer,
-  NodeValidation,
-  PopulationPromise,
-  ResolvedClientFeature,
-  ResolvedClientFeatureMap,
-  ResolvedServerFeature,
-  ResolvedServerFeatureMap,
-  SanitizedClientFeatures,
-  SanitizedPlugin,
-  SanitizedServerFeatures,
-  ServerFeature,
-  ServerFeatureProviderMap,
-} from './field/features/types.js'
-export { UploadFeature } from './field/features/upload/feature.server.js'
-
-export type { UploadFeatureProps } from './field/features/upload/feature.server.js'
-
-export type { RawUploadPayload } from './field/features/upload/nodes/UploadNode.js'
-
-export {
-  $createUploadNode,
-  $isUploadNode,
-  type SerializedUploadNode,
-  type UploadData,
-  UploadNode,
-} from './field/features/upload/nodes/UploadNode.js'
-export {
-  EditorConfigProvider,
-  useEditorConfigContext,
-} from './field/lexical/config/client/EditorConfigProvider.js'
-export {
-  sanitizeClientEditorConfig,
-  sanitizeClientFeatures,
-} from './field/lexical/config/client/sanitize.js'
-export {
-  defaultEditorConfig,
-  defaultEditorFeatures,
-  defaultEditorLexicalConfig,
-  defaultSanitizedServerEditorConfig,
-} from './field/lexical/config/server/default.js'
-export {
-  loadFeatures,
-  sortFeaturesForOptimalLoading,
-} from './field/lexical/config/server/loader.js'
-export {
-  sanitizeServerEditorConfig,
-  sanitizeServerFeatures,
-} from './field/lexical/config/server/sanitize.js'
-
-export type {
-  ClientEditorConfig,
-  SanitizedClientEditorConfig,
-  SanitizedServerEditorConfig,
-  ServerEditorConfig,
-} from './field/lexical/config/types.js'
-export { getEnabledNodes } from './field/lexical/nodes/index.js'
-
-export {
-  type FloatingToolbarSection,
-  type FloatingToolbarSectionEntry,
-} from './field/lexical/plugins/FloatingSelectToolbar/types.js'
-export { ENABLE_SLASH_MENU_COMMAND } from './field/lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/index.js'
-export type { AdapterProps }
-
-export {
-  SlashMenuGroup,
-  SlashMenuOption,
-} from './field/lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/types.js'
-export { CAN_USE_DOM } from './field/lexical/utils/canUseDOM.js'
-export { cloneDeep } from './field/lexical/utils/cloneDeep.js'
-export { getDOMRangeRect } from './field/lexical/utils/getDOMRangeRect.js'
-export { getSelectedNode } from './field/lexical/utils/getSelectedNode.js'
-export { isHTMLElement } from './field/lexical/utils/guard.js'
-export { invariant } from './field/lexical/utils/invariant.js'
-export { joinClasses } from './field/lexical/utils/joinClasses.js'
-export { createBlockNode } from './field/lexical/utils/markdown/createBlockNode.js'
-export {
-  DETAIL_TYPE_TO_DETAIL,
-  DOUBLE_LINE_BREAK,
-  ELEMENT_FORMAT_TO_TYPE,
-  ELEMENT_TYPE_TO_FORMAT,
-  IS_ALL_FORMATTING,
-  LTR_REGEX,
-  NON_BREAKING_SPACE,
-  NodeFormat,
-  RTL_REGEX,
-  TEXT_MODE_TO_TYPE,
-  TEXT_TYPE_TO_FORMAT,
-  TEXT_TYPE_TO_MODE,
-} from './field/lexical/utils/nodeFormat.js'
-export { Point, isPoint } from './field/lexical/utils/point.js'
-export { Rect } from './field/lexical/utils/rect.js'
-export { setFloatingElemPosition } from './field/lexical/utils/setFloatingElemPosition.js'
-export { setFloatingElemPositionForLinkEditor } from './field/lexical/utils/setFloatingElemPositionForLinkEditor.js'
-export {
-  addSwipeDownListener,
-  addSwipeLeftListener,
-  addSwipeRightListener,
-  addSwipeUpListener,
-} from './field/lexical/utils/swipe.js'
-export { sanitizeUrl, validateUrl } from './field/lexical/utils/url.js'
-export { defaultRichTextValue } from './populate/defaultValue.js'
-
-export type { LexicalEditorProps, LexicalRichTextAdapter } from './types.js'