@payloadcms/richtext-lexical 3.0.0-beta.7 → 3.0.0-beta.71

package/dist/field/features/upload/nodes/UploadNode.js

@@ -1,102 +0,0 @@
-import lexicalDecoratorBlockNodeImport from '@lexical/react/LexicalDecoratorBlockNode.js';
-const { DecoratorBlockNode } = lexicalDecoratorBlockNodeImport;
-import lexicalImport from 'lexical';
-const { $applyNodeReplacement } = lexicalImport;
-import * as React from 'react';
-const RawUploadComponent = /*#__PURE__*/ React.lazy(()=>import('../component/index.js').then((module)=>({
-            default: module.UploadComponent
-        })));
-function convertUploadElement(domNode) {
-    //if (domNode instanceof HTMLImageElement) {
-    // const { alt: altText, src } = domNode;
-    // const node = $createImageNode({ altText, src });
-    // return { node };
-    // TODO: Auto-upload functionality here!
-    //}
-    return null;
-}
-export class UploadNode extends DecoratorBlockNode {
-    __data;
-    constructor({ data, format, key }){
-        super(format, key);
-        this.__data = data;
-    }
-    static clone(node) {
-        return new UploadNode({
-            data: node.__data,
-            format: node.__format,
-            key: node.__key
-        });
-    }
-    static getType() {
-        return 'upload';
-    }
-    static importDOM() {
-        return {
-            img: (node)=>({
-                    conversion: convertUploadElement,
-                    priority: 0
-                })
-        };
-    }
-    static importJSON(serializedNode) {
-        const importedData = {
-            fields: serializedNode.fields,
-            relationTo: serializedNode.relationTo,
-            value: serializedNode.value
-        };
-        const node = $createUploadNode({
-            data: importedData
-        });
-        node.setFormat(serializedNode.format);
-        return node;
-    }
-    static isInline() {
-        return false;
-    }
-    decorate() {
-        // @ts-expect-error
-        return /*#__PURE__*/ React.createElement(RawUploadComponent, {
-            data: this.__data,
-            format: this.__format,
-            nodeKey: this.getKey()
-        });
-    }
-    exportDOM() {
-        const element = document.createElement('img');
-        // element.setAttribute('src', this.__src);
-        // element.setAttribute('alt', this.__altText); //TODO
-        return {
-            element
-        };
-    }
-    exportJSON() {
-        return {
-            ...super.exportJSON(),
-            ...this.getData(),
-            type: this.getType(),
-            version: 1
-        };
-    }
-    getData() {
-        return this.getLatest().__data;
-    }
-    setData(data) {
-        const writable = this.getWritable();
-        writable.__data = data;
-    }
-    // eslint-disable-next-line class-methods-use-this
-    updateDOM() {
-        return false;
-    }
-}
-export function $createUploadNode({ data }) {
-    return $applyNodeReplacement(new UploadNode({
-        data
-    }));
-}
-export function $isUploadNode(node) {
-    return node instanceof UploadNode;
-}
-
-//# sourceMappingURL=UploadNode.js.map

package/dist/field/features/upload/nodes/UploadNode.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../src/field/features/upload/nodes/UploadNode.tsx"],"sourcesContent":["import type { SerializedDecoratorBlockNode } from '@lexical/react/LexicalDecoratorBlockNode.js'\nimport type { ElementFormatType, NodeKey } from 'lexical'\n\nimport lexicalDecoratorBlockNodeImport from '@lexical/react/LexicalDecoratorBlockNode.js'\nconst { DecoratorBlockNode } = lexicalDecoratorBlockNodeImport\n\nimport lexicalImport from 'lexical'\nconst { $applyNodeReplacement } = lexicalImport\n\nimport type {\n  DOMConversionMap,\n  DOMConversionOutput,\n  DOMExportOutput,\n  LexicalNode,\n  Spread,\n} from 'lexical'\n\nimport * as React from 'react'\n\nconst RawUploadComponent = React.lazy(() =>\n  import('../component/index.js').then((module) => ({ default: module.UploadComponent })),\n)\n\nexport type RawUploadPayload = {\n  fields: {\n    // unknown, custom fields:\n    [key: string]: unknown\n  }\n  id: string\n  relationTo: string\n}\n\nexport type UploadData = {\n  fields: {\n    // unknown, custom fields:\n    [key: string]: unknown\n  }\n  relationTo: string\n  value: {\n    // Actual upload data, populated in afterRead hook\n    [key: string]: unknown\n    id: string\n  }\n}\n\nfunction convertUploadElement(domNode: Node): DOMConversionOutput | null {\n  //if (domNode instanceof HTMLImageElement) {\n  // const { alt: altText, src } = domNode;\n  // const node = $createImageNode({ altText, src });\n  // return { node };\n  // TODO: Auto-upload functionality here!\n  //}\n  return null\n}\n\nexport type SerializedUploadNode = Spread<UploadData, SerializedDecoratorBlockNode>\n\nexport class UploadNode extends DecoratorBlockNode {\n  __data: UploadData\n\n  constructor({\n    data,\n    format,\n    key,\n  }: {\n    data: UploadData\n    format?: ElementFormatType\n    key?: NodeKey\n  }) {\n    super(format, key)\n    this.__data = data\n  }\n\n  static clone(node: UploadNode): UploadNode {\n    return new UploadNode({\n      data: node.__data,\n      format: node.__format,\n      key: node.__key,\n    })\n  }\n\n  static getType(): string {\n    return 'upload'\n  }\n\n  static importDOM(): DOMConversionMap | null {\n    return {\n      img: (node: Node) => ({\n        conversion: convertUploadElement,\n        priority: 0,\n      }),\n    }\n  }\n\n  static importJSON(serializedNode: SerializedUploadNode): UploadNode {\n    const importedData: UploadData = {\n      fields: serializedNode.fields,\n      relationTo: serializedNode.relationTo,\n      value: serializedNode.value,\n    }\n\n    const node = $createUploadNode({ data: importedData })\n    node.setFormat(serializedNode.format)\n\n    return node\n  }\n\n  static isInline(): false {\n    return false\n  }\n\n  decorate(): JSX.Element {\n    // @ts-expect-error\n    return <RawUploadComponent data={this.__data} format={this.__format} nodeKey={this.getKey()} />\n  }\n\n  exportDOM(): DOMExportOutput {\n    const element = document.createElement('img')\n    // element.setAttribute('src', this.__src);\n    // element.setAttribute('alt', this.__altText); //TODO\n    return { element }\n  }\n\n  exportJSON(): SerializedUploadNode {\n    return {\n      ...super.exportJSON(),\n      ...this.getData(),\n      type: this.getType(),\n      version: 1,\n    }\n  }\n\n  getData(): UploadData {\n    return this.getLatest().__data\n  }\n\n  setData(data: UploadData): void {\n    const writable = this.getWritable()\n    writable.__data = data\n  }\n\n  // eslint-disable-next-line class-methods-use-this\n  updateDOM(): false {\n    return false\n  }\n}\n\nexport function $createUploadNode({ data }: { data: UploadData }): UploadNode {\n  return $applyNodeReplacement(new UploadNode({ data }))\n}\n\nexport function $isUploadNode(node: LexicalNode | null | undefined): node is UploadNode {\n  return node instanceof UploadNode\n}\n"],"names":["lexicalDecoratorBlockNodeImport","DecoratorBlockNode","lexicalImport","$applyNodeReplacement","React","RawUploadComponent","lazy","then","module","default","UploadComponent","convertUploadElement","domNode","UploadNode","__data","constructor","data","format","key","clone","node","__format","__key","getType","importDOM","img","conversion","priority","importJSON","serializedNode","importedData","fields","relationTo","value","$createUploadNode","setFormat","isInline","decorate","nodeKey","getKey","exportDOM","element","document","createElement","exportJSON","getData","type","version","getLatest","setData","writable","getWritable","updateDOM","$isUploadNode"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAGA,OAAOA,qCAAqC,8CAA6C;AACzF,MAAM,EAAEC,kBAAkB,EAAE,GAAGD;AAE/B,OAAOE,mBAAmB,UAAS;AACnC,MAAM,EAAEC,qBAAqB,EAAE,GAAGD;AAUlC,YAAYE,WAAW,QAAO;AAE9B,MAAMC,mCAAqBD,MAAME,IAAI,CAAC,IACpC,MAAM,CAAC,yBAAyBC,IAAI,CAAC,CAACC,SAAY,CAAA;YAAEC,SAASD,OAAOE,eAAe;QAAC,CAAA;AAyBtF,SAASC,qBAAqBC,OAAa;IACzC,4CAA4C;IAC5C,yCAAyC;IACzC,mDAAmD;IACnD,mBAAmB;IACnB,wCAAwC;IACxC,GAAG;IACH,OAAO;AACT;AAIA,OAAO,MAAMC,mBAAmBZ;IAC9Ba,OAAkB;IAElBC,YAAY,EACVC,IAAI,EACJC,MAAM,EACNC,GAAG,EAKJ,CAAE;QACD,KAAK,CAACD,QAAQC;QACd,IAAI,CAACJ,MAAM,GAAGE;IAChB;IAEA,OAAOG,MAAMC,IAAgB,EAAc;QACzC,OAAO,IAAIP,WAAW;YACpBG,MAAMI,KAAKN,MAAM;YACjBG,QAAQG,KAAKC,QAAQ;YACrBH,KAAKE,KAAKE,KAAK;QACjB;IACF;IAEA,OAAOC,UAAkB;QACvB,OAAO;IACT;IAEA,OAAOC,YAAqC;QAC1C,OAAO;YACLC,KAAK,CAACL,OAAgB,CAAA;oBACpBM,YAAYf;oBACZgB,UAAU;gBACZ,CAAA;QACF;IACF;IAEA,OAAOC,WAAWC,cAAoC,EAAc;QAClE,MAAMC,eAA2B;YAC/BC,QAAQF,eAAeE,MAAM;YAC7BC,YAAYH,eAAeG,UAAU;YACrCC,OAAOJ,eAAeI,KAAK;QAC7B;QAEA,MAAMb,OAAOc,kBAAkB;YAAElB,MAAMc;QAAa;QACpDV,KAAKe,SAAS,CAACN,eAAeZ,MAAM;QAEpC,OAAOG;IACT;IAEA,OAAOgB,WAAkB;QACvB,OAAO;IACT;IAEAC,WAAwB;QACtB,mBAAmB;QACnB,qBAAO,oBAAChC;YAAmBW,MAAM,IAAI,CAACF,MAAM;YAAEG,QAAQ,IAAI,CAACI,QAAQ;YAAEiB,SAAS,IAAI,CAACC,MAAM;;IAC3F;IAEAC,YAA6B;QAC3B,MAAMC,UAAUC,SAASC,aAAa,CAAC;QACvC,2CAA2C;QAC3C,sDAAsD;QACtD,OAAO;YAAEF;QAAQ;IACnB;IAEAG,aAAmC;QACjC,OAAO;YACL,GAAG,KAAK,CAACA,YAAY;YACrB,GAAG,IAAI,CAACC,OAAO,EAAE;YACjBC,MAAM,IAAI,CAACvB,OAAO;YAClBwB,SAAS;QACX;IACF;IAEAF,UAAsB;QACpB,OAAO,IAAI,CAACG,SAAS,GAAGlC,MAAM;IAChC;IAEAmC,QAAQjC,IAAgB,EAAQ;QAC9B,MAAMkC,WAAW,IAAI,CAACC,WAAW;QACjCD,SAASpC,MAAM,GAAGE;IACpB;IAEA,kDAAkD;IAClDoC,YAAmB;QACjB,OAAO;IACT;AACF;AAEA,OAAO,SAASlB,kBAAkB,EAAElB,IAAI,EAAwB;IAC9D,OAAOb,sBAAsB,IAAIU,WAAW;QAAEG;IAAK;AACrD;AAEA,OAAO,SAASqC,cAAcjC,IAAoC;IAChE,OAAOA,gBAAgBP;AACzB"}

package/dist/field/features/upload/plugin/index.d.ts

@@ -1,7 +0,0 @@
-/// <reference types="react" resolution-mode="require"/>
-import type { LexicalCommand } from 'lexical';
-import type { RawUploadPayload } from '../nodes/UploadNode.js';
-export type InsertUploadPayload = Readonly<RawUploadPayload>;
-export declare const INSERT_UPLOAD_COMMAND: LexicalCommand<InsertUploadPayload>;
-export declare function UploadPlugin(): JSX.Element | null;
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/upload/plugin/index.tsx"],"names":[],"mappings":";AAeA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAK7C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AAK9D,MAAM,MAAM,mBAAmB,GAAG,QAAQ,CAAC,gBAAgB,CAAC,CAAA;AAE5D,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,mBAAmB,CAC9B,CAAA;AAExC,wBAAgB,YAAY,IAAI,GAAG,CAAC,OAAO,GAAG,IAAI,CAuDjD"}

package/dist/field/features/upload/plugin/index.js

@@ -1,55 +0,0 @@
-'use client';
-import lexicalComposerContextImport from '@lexical/react/LexicalComposerContext.js';
-const { useLexicalComposerContext } = lexicalComposerContextImport;
-import lexicalUtilsImport from '@lexical/utils';
-const { $insertNodeToNearestRoot, mergeRegister } = lexicalUtilsImport;
-import lexicalImport from 'lexical';
-const { $getPreviousSelection, $getSelection, $isParagraphNode, $isRangeSelection, COMMAND_PRIORITY_EDITOR, createCommand } = lexicalImport;
-import { useConfig } from '@payloadcms/ui/providers/Config';
-import React, { useEffect } from 'react';
-import { UploadDrawer } from '../drawer/index.js';
-import { $createUploadNode, UploadNode } from '../nodes/UploadNode.js';
-export const INSERT_UPLOAD_COMMAND = createCommand('INSERT_UPLOAD_COMMAND');
-export function UploadPlugin() {
-    const [editor] = useLexicalComposerContext();
-    const { collections } = useConfig();
-    useEffect(()=>{
-        if (!editor.hasNodes([
-            UploadNode
-        ])) {
-            throw new Error('UploadPlugin: UploadNode not registered on editor');
-        }
-        return mergeRegister(editor.registerCommand(INSERT_UPLOAD_COMMAND, (payload)=>{
-            editor.update(()=>{
-                const uploadNode = $createUploadNode({
-                    data: {
-                        fields: payload.fields,
-                        relationTo: payload.relationTo,
-                        value: {
-                            id: payload.id
-                        }
-                    }
-                });
-                const selection = $getSelection() || $getPreviousSelection();
-                if ($isRangeSelection(selection)) {
-                    const { focus } = selection;
-                    const focusNode = focus.getNode();
-                    // First, delete currently selected node if it's an empty paragraph and if there are sufficient
-                    // paragraph nodes (more than 1) left in the parent node, so that we don't "trap" the user
-                    if ($isParagraphNode(focusNode) && focusNode.getTextContentSize() === 0 && focusNode.getParent().getChildren().filter((node)=>$isParagraphNode(node)).length > 1) {
-                        focusNode.remove();
-                    }
-                    $insertNodeToNearestRoot(uploadNode);
-                }
-            });
-            return true;
-        }, COMMAND_PRIORITY_EDITOR));
-    }, [
-        editor
-    ]);
-    return /*#__PURE__*/ React.createElement(UploadDrawer, {
-        enabledCollectionSlugs: collections.map(({ slug })=>slug)
-    });
-}
-
-//# sourceMappingURL=index.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../src/field/features/upload/plugin/index.tsx"],"sourcesContent":["'use client'\nimport lexicalComposerContextImport from '@lexical/react/LexicalComposerContext.js'\nconst { useLexicalComposerContext } = lexicalComposerContextImport\nimport lexicalUtilsImport from '@lexical/utils'\nconst { $insertNodeToNearestRoot, mergeRegister } = lexicalUtilsImport\nimport lexicalImport from 'lexical'\nconst {\n  $getPreviousSelection,\n  $getSelection,\n  $isParagraphNode,\n  $isRangeSelection,\n  COMMAND_PRIORITY_EDITOR,\n  createCommand,\n} = lexicalImport\n\nimport type { LexicalCommand } from 'lexical'\n\nimport { useConfig } from '@payloadcms/ui/providers/Config'\nimport React, { useEffect } from 'react'\n\nimport type { RawUploadPayload } from '../nodes/UploadNode.js'\n\nimport { UploadDrawer } from '../drawer/index.js'\nimport { $createUploadNode, UploadNode } from '../nodes/UploadNode.js'\n\nexport type InsertUploadPayload = Readonly<RawUploadPayload>\n\nexport const INSERT_UPLOAD_COMMAND: LexicalCommand<InsertUploadPayload> =\n  createCommand('INSERT_UPLOAD_COMMAND')\n\nexport function UploadPlugin(): JSX.Element | null {\n  const [editor] = useLexicalComposerContext()\n  const { collections } = useConfig()\n\n  useEffect(() => {\n    if (!editor.hasNodes([UploadNode])) {\n      throw new Error('UploadPlugin: UploadNode not registered on editor')\n    }\n\n    return mergeRegister(\n      editor.registerCommand<InsertUploadPayload>(\n        INSERT_UPLOAD_COMMAND,\n        (payload: InsertUploadPayload) => {\n          editor.update(() => {\n            const uploadNode = $createUploadNode({\n              data: {\n                fields: payload.fields,\n                relationTo: payload.relationTo,\n                value: {\n                  id: payload.id,\n                },\n              },\n            })\n\n            const selection = $getSelection() || $getPreviousSelection()\n\n            if ($isRangeSelection(selection)) {\n              const { focus } = selection\n              const focusNode = focus.getNode()\n\n              // First, delete currently selected node if it's an empty paragraph and if there are sufficient\n              // paragraph nodes (more than 1) left in the parent node, so that we don't \"trap\" the user\n              if (\n                $isParagraphNode(focusNode) &&\n                focusNode.getTextContentSize() === 0 &&\n                focusNode\n                  .getParent()\n                  .getChildren()\n                  .filter((node) => $isParagraphNode(node)).length > 1\n              ) {\n                focusNode.remove()\n              }\n\n              $insertNodeToNearestRoot(uploadNode)\n            }\n          })\n\n          return true\n        },\n        COMMAND_PRIORITY_EDITOR,\n      ),\n    )\n  }, [editor])\n\n  return <UploadDrawer enabledCollectionSlugs={collections.map(({ slug }) => slug)} />\n}\n"],"names":["lexicalComposerContextImport","useLexicalComposerContext","lexicalUtilsImport","$insertNodeToNearestRoot","mergeRegister","lexicalImport","$getPreviousSelection","$getSelection","$isParagraphNode","$isRangeSelection","COMMAND_PRIORITY_EDITOR","createCommand","useConfig","React","useEffect","UploadDrawer","$createUploadNode","UploadNode","INSERT_UPLOAD_COMMAND","UploadPlugin","editor","collections","hasNodes","Error","registerCommand","payload","update","uploadNode","data","fields","relationTo","value","id","selection","focus","focusNode","getNode","getTextContentSize","getParent","getChildren","filter","node","length","remove","enabledCollectionSlugs","map","slug"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;AACA,OAAOA,kCAAkC,2CAA0C;AACnF,MAAM,EAAEC,yBAAyB,EAAE,GAAGD;AACtC,OAAOE,wBAAwB,iBAAgB;AAC/C,MAAM,EAAEC,wBAAwB,EAAEC,aAAa,EAAE,GAAGF;AACpD,OAAOG,mBAAmB,UAAS;AACnC,MAAM,EACJC,qBAAqB,EACrBC,aAAa,EACbC,gBAAgB,EAChBC,iBAAiB,EACjBC,uBAAuB,EACvBC,aAAa,EACd,GAAGN;AAIJ,SAASO,SAAS,QAAQ,kCAAiC;AAC3D,OAAOC,SAASC,SAAS,QAAQ,QAAO;AAIxC,SAASC,YAAY,QAAQ,qBAAoB;AACjD,SAASC,iBAAiB,EAAEC,UAAU,QAAQ,yBAAwB;AAItE,OAAO,MAAMC,wBACXP,cAAc,yBAAwB;AAExC,OAAO,SAASQ;IACd,MAAM,CAACC,OAAO,GAAGnB;IACjB,MAAM,EAAEoB,WAAW,EAAE,GAAGT;IAExBE,UAAU;QACR,IAAI,CAACM,OAAOE,QAAQ,CAAC;YAACL;SAAW,GAAG;YAClC,MAAM,IAAIM,MAAM;QAClB;QAEA,OAAOnB,cACLgB,OAAOI,eAAe,CACpBN,uBACA,CAACO;YACCL,OAAOM,MAAM,CAAC;gBACZ,MAAMC,aAAaX,kBAAkB;oBACnCY,MAAM;wBACJC,QAAQJ,QAAQI,MAAM;wBACtBC,YAAYL,QAAQK,UAAU;wBAC9BC,OAAO;4BACLC,IAAIP,QAAQO,EAAE;wBAChB;oBACF;gBACF;gBAEA,MAAMC,YAAY1B,mBAAmBD;gBAErC,IAAIG,kBAAkBwB,YAAY;oBAChC,MAAM,EAAEC,KAAK,EAAE,GAAGD;oBAClB,MAAME,YAAYD,MAAME,OAAO;oBAE/B,+FAA+F;oBAC/F,0FAA0F;oBAC1F,IACE5B,iBAAiB2B,cACjBA,UAAUE,kBAAkB,OAAO,KACnCF,UACGG,SAAS,GACTC,WAAW,GACXC,MAAM,CAAC,CAACC,OAASjC,iBAAiBiC,OAAOC,MAAM,GAAG,GACrD;wBACAP,UAAUQ,MAAM;oBAClB;oBAEAxC,yBAAyBwB;gBAC3B;YACF;YAEA,OAAO;QACT,GACAjB;IAGN,GAAG;QAACU;KAAO;IAEX,qBAAO,oBAACL;QAAa6B,wBAAwBvB,YAAYwB,GAAG,CAAC,CAAC,EAAEC,IAAI,EAAE,GAAKA;;AAC7E"}

package/dist/field/features/upload/populationPromise.d.ts

@@ -1,5 +0,0 @@
-import type { PopulationPromise } from '../types.js';
-import type { UploadFeatureProps } from './feature.server.js';
-import type { SerializedUploadNode } from './nodes/UploadNode.js';
-export declare const uploadPopulationPromiseHOC: (props?: UploadFeatureProps) => PopulationPromise<SerializedUploadNode>;
-//# sourceMappingURL=populationPromise.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"populationPromise.d.ts","sourceRoot":"","sources":["../../../../src/field/features/upload/populationPromise.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AACpD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AAC7D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAA;AAKjE,eAAO,MAAM,0BAA0B,WAC7B,kBAAkB,KACzB,kBAAkB,oBAAoB,CA6DxC,CAAA"}

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

@@ -1,46 +0,0 @@
-import { populate } from '../../../populate/populate.js';
-import { recurseNestedFields } from '../../../populate/recurseNestedFields.js';
-export const uploadPopulationPromiseHOC = (props)=>{
-    const uploadPopulationPromise = ({ context, currentDepth, depth, editorPopulationPromises, field, findMany, flattenLocales, node, overrideAccess, populationPromises, req, showHiddenFields, siblingDoc })=>{
-        const promises = [];
-        if (node?.value?.id) {
-            const collection = req.payload.collections[node?.relationTo];
-            if (collection) {
-                promises.push(populate({
-                    id: node?.value?.id,
-                    collection,
-                    currentDepth,
-                    data: node,
-                    depth,
-                    field,
-                    key: 'value',
-                    overrideAccess,
-                    req,
-                    showHiddenFields
-                }));
-            }
-            if (Array.isArray(props?.collections?.[node?.relationTo]?.fields)) {
-                recurseNestedFields({
-                    context,
-                    currentDepth,
-                    data: node.fields || {},
-                    depth,
-                    editorPopulationPromises,
-                    fields: props?.collections?.[node?.relationTo]?.fields,
-                    findMany,
-                    flattenLocales,
-                    overrideAccess,
-                    populationPromises,
-                    promises,
-                    req,
-                    showHiddenFields,
-                    siblingDoc: node.fields || {}
-                });
-            }
-        }
-        return promises;
-    };
-    return uploadPopulationPromise;
-};
-
-//# sourceMappingURL=populationPromise.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/field/features/upload/populationPromise.ts"],"sourcesContent":["import type { PopulationPromise } from '../types.js'\nimport type { UploadFeatureProps } from './feature.server.js'\nimport type { SerializedUploadNode } from './nodes/UploadNode.js'\n\nimport { populate } from '../../../populate/populate.js'\nimport { recurseNestedFields } from '../../../populate/recurseNestedFields.js'\n\nexport const uploadPopulationPromiseHOC = (\n  props?: UploadFeatureProps,\n): PopulationPromise<SerializedUploadNode> => {\n  const uploadPopulationPromise: PopulationPromise<SerializedUploadNode> = ({\n    context,\n    currentDepth,\n    depth,\n    editorPopulationPromises,\n    field,\n    findMany,\n    flattenLocales,\n    node,\n    overrideAccess,\n    populationPromises,\n    req,\n    showHiddenFields,\n    siblingDoc,\n  }) => {\n    const promises: Promise<void>[] = []\n\n    if (node?.value?.id) {\n      const collection = req.payload.collections[node?.relationTo]\n\n      if (collection) {\n        promises.push(\n          populate({\n            id: node?.value?.id,\n            collection,\n            currentDepth,\n            data: node,\n            depth,\n            field,\n            key: 'value',\n            overrideAccess,\n            req,\n            showHiddenFields,\n          }),\n        )\n      }\n      if (Array.isArray(props?.collections?.[node?.relationTo]?.fields)) {\n        recurseNestedFields({\n          context,\n          currentDepth,\n          data: node.fields || {},\n          depth,\n          editorPopulationPromises,\n          fields: props?.collections?.[node?.relationTo]?.fields,\n          findMany,\n          flattenLocales,\n          overrideAccess,\n          populationPromises,\n          promises,\n          req,\n          showHiddenFields,\n          siblingDoc: node.fields || {},\n        })\n      }\n    }\n\n    return promises\n  }\n\n  return uploadPopulationPromise\n}\n"],"names":["populate","recurseNestedFields","uploadPopulationPromiseHOC","props","uploadPopulationPromise","context","currentDepth","depth","editorPopulationPromises","field","findMany","flattenLocales","node","overrideAccess","populationPromises","req","showHiddenFields","siblingDoc","promises","value","id","collection","payload","collections","relationTo","push","data","key","Array","isArray","fields"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAIA,SAASA,QAAQ,QAAQ,gCAA+B;AACxD,SAASC,mBAAmB,QAAQ,2CAA0C;AAE9E,OAAO,MAAMC,6BAA6B,CACxCC;IAEA,MAAMC,0BAAmE,CAAC,EACxEC,OAAO,EACPC,YAAY,EACZC,KAAK,EACLC,wBAAwB,EACxBC,KAAK,EACLC,QAAQ,EACRC,cAAc,EACdC,IAAI,EACJC,cAAc,EACdC,kBAAkB,EAClBC,GAAG,EACHC,gBAAgB,EAChBC,UAAU,EACX;QACC,MAAMC,WAA4B,EAAE;QAEpC,IAAIN,MAAMO,OAAOC,IAAI;YACnB,MAAMC,aAAaN,IAAIO,OAAO,CAACC,WAAW,CAACX,MAAMY,WAAW;YAE5D,IAAIH,YAAY;gBACdH,SAASO,IAAI,CACXzB,SAAS;oBACPoB,IAAIR,MAAMO,OAAOC;oBACjBC;oBACAf;oBACAoB,MAAMd;oBACNL;oBACAE;oBACAkB,KAAK;oBACLd;oBACAE;oBACAC;gBACF;YAEJ;YACA,IAAIY,MAAMC,OAAO,CAAC1B,OAAOoB,aAAa,CAACX,MAAMY,WAAW,EAAEM,SAAS;gBACjE7B,oBAAoB;oBAClBI;oBACAC;oBACAoB,MAAMd,KAAKkB,MAAM,IAAI,CAAC;oBACtBvB;oBACAC;oBACAsB,QAAQ3B,OAAOoB,aAAa,CAACX,MAAMY,WAAW,EAAEM;oBAChDpB;oBACAC;oBACAE;oBACAC;oBACAI;oBACAH;oBACAC;oBACAC,YAAYL,KAAKkB,MAAM,IAAI,CAAC;gBAC9B;YACF;QACF;QAEA,OAAOZ;IACT;IAEA,OAAOd;AACT,EAAC"}

package/dist/field/features/upload/validate.d.ts

@@ -1,4 +0,0 @@
-import type { NodeValidation } from '../types.js';
-import type { SerializedUploadNode } from './nodes/UploadNode.js';
-export declare const uploadValidation: () => NodeValidation<SerializedUploadNode>;
-//# sourceMappingURL=validate.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../../src/field/features/upload/validate.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AACjD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAA;AAIjE,eAAO,MAAM,gBAAgB,QAAO,eAAe,oBAAoB,CAuBtE,CAAA"}

package/dist/field/features/upload/validate.js

@@ -1,17 +0,0 @@
-import { isValidID } from 'payload/utilities';
-import { CAN_USE_DOM } from '../../lexical/utils/canUseDOM.js';
-export const uploadValidation = ()=>{
-    const uploadValidation = ({ node, validation: { options: { req: { payload, t } } } })=>{
-        if (!CAN_USE_DOM) {
-            const idType = payload.collections[node.relationTo].customIDType || payload.db.defaultIDType;
-            if (!isValidID(node.value?.id, idType)) {
-                return t('validation:validUploadID');
-            }
-        }
-        // TODO: validate upload collection fields
-        return true;
-    };
-    return uploadValidation;
-};
-
-//# sourceMappingURL=validate.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/field/features/upload/validate.ts"],"sourcesContent":["import { isValidID } from 'payload/utilities'\n\nimport type { NodeValidation } from '../types.js'\nimport type { SerializedUploadNode } from './nodes/UploadNode.js'\n\nimport { CAN_USE_DOM } from '../../lexical/utils/canUseDOM.js'\n\nexport const uploadValidation = (): NodeValidation<SerializedUploadNode> => {\n  const uploadValidation: NodeValidation<SerializedUploadNode> = ({\n    node,\n    validation: {\n      options: {\n        req: { payload, t },\n      },\n    },\n  }) => {\n    if (!CAN_USE_DOM) {\n      const idType = payload.collections[node.relationTo].customIDType || payload.db.defaultIDType\n\n      if (!isValidID(node.value?.id, idType)) {\n        return t('validation:validUploadID')\n      }\n    }\n\n    // TODO: validate upload collection fields\n\n    return true\n  }\n\n  return uploadValidation\n}\n"],"names":["isValidID","CAN_USE_DOM","uploadValidation","node","validation","options","req","payload","t","idType","collections","relationTo","customIDType","db","defaultIDType","value","id"],"rangeMappings":";;;;;;;;;;;;;;","mappings":"AAAA,SAASA,SAAS,QAAQ,oBAAmB;AAK7C,SAASC,WAAW,QAAQ,mCAAkC;AAE9D,OAAO,MAAMC,mBAAmB;IAC9B,MAAMA,mBAAyD,CAAC,EAC9DC,IAAI,EACJC,YAAY,EACVC,SAAS,EACPC,KAAK,EAAEC,OAAO,EAAEC,CAAC,EAAE,EACpB,EACF,EACF;QACC,IAAI,CAACP,aAAa;YAChB,MAAMQ,SAASF,QAAQG,WAAW,CAACP,KAAKQ,UAAU,CAAC,CAACC,YAAY,IAAIL,QAAQM,EAAE,CAACC,aAAa;YAE5F,IAAI,CAACd,UAAUG,KAAKY,KAAK,EAAEC,IAAIP,SAAS;gBACtC,OAAOD,EAAE;YACX;QACF;QAEA,0CAA0C;QAE1C,OAAO;IACT;IAEA,OAAON;AACT,EAAC"}

package/dist/field/index.scss

@@ -1,46 +0,0 @@
-@import '../scss/styles.scss';
-
-.rich-text-lexical {
-  display: flex;
-
-  .errorBoundary {
-    pre {
-      text-wrap: unset;
-    }
-  }
-
-  &__wrap {
-    width: 100%;
-    position: relative;
-  }
-
-  &--read-only {
-    .editor-shell {
-      .editor {
-        background: var(--theme-elevation-200);
-        color: var(--theme-elevation-450);
-        padding: calc(var(--base) * 0.5);
-      }
-    }
-  }
-}
-
-html[data-theme='light'] {
-  .rich-text-lexical {
-    &.error {
-      .editor-shell {
-        @include lightInputError;
-      }
-    }
-  }
-}
-
-html[data-theme='dark'] {
-  .rich-text-lexical {
-    &.error {
-      .editor-shell {
-        @include darkInputError;
-      }
-    }
-  }
-}

package/dist/field/lexical/EditorPlugin.d.ts

@@ -1,7 +0,0 @@
-import * as React from 'react';
-import type { SanitizedPlugin } from '../features/types.js';
-export declare const EditorPlugin: React.FC<{
-    anchorElem?: HTMLDivElement;
-    plugin: SanitizedPlugin;
-}>;
-//# sourceMappingURL=EditorPlugin.d.ts.map

package/dist/field/lexical/EditorPlugin.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"EditorPlugin.d.ts","sourceRoot":"","sources":["../../../src/field/lexical/EditorPlugin.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAE3D,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC;IAClC,UAAU,CAAC,EAAE,cAAc,CAAA;IAC3B,MAAM,EAAE,eAAe,CAAA;CACxB,CAMA,CAAA"}

package/dist/field/lexical/EditorPlugin.js

@@ -1,11 +0,0 @@
-import * as React from 'react';
-export const EditorPlugin = ({ anchorElem, plugin })=>{
-    if (plugin.position === 'floatingAnchorElem') {
-        return plugin.Component && /*#__PURE__*/ React.createElement(plugin.Component, {
-            anchorElem: anchorElem
-        });
-    }
-    return plugin.Component && /*#__PURE__*/ React.createElement(plugin.Component, null);
-};
-
-//# sourceMappingURL=EditorPlugin.js.map

package/dist/field/lexical/EditorPlugin.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/field/lexical/EditorPlugin.tsx"],"sourcesContent":["import * as React from 'react'\n\nimport type { SanitizedPlugin } from '../features/types.js'\n\nexport const EditorPlugin: React.FC<{\n  anchorElem?: HTMLDivElement\n  plugin: SanitizedPlugin\n}> = ({ anchorElem, plugin }) => {\n  if (plugin.position === 'floatingAnchorElem') {\n    return plugin.Component && <plugin.Component anchorElem={anchorElem} />\n  }\n\n  return plugin.Component && <plugin.Component />\n}\n"],"names":["React","EditorPlugin","anchorElem","plugin","position","Component"],"rangeMappings":";;;;;;;;","mappings":"AAAA,YAAYA,WAAW,QAAO;AAI9B,OAAO,MAAMC,eAGR,CAAC,EAAEC,UAAU,EAAEC,MAAM,EAAE;IAC1B,IAAIA,OAAOC,QAAQ,KAAK,sBAAsB;QAC5C,OAAOD,OAAOE,SAAS,kBAAI,oBAACF,OAAOE,SAAS;YAACH,YAAYA;;IAC3D;IAEA,OAAOC,OAAOE,SAAS,kBAAI,oBAACF,OAAOE,SAAS;AAC9C,EAAC"}

package/dist/field/lexical/LexicalEditor.d.ts

@@ -1,5 +0,0 @@
-import * as React from 'react';
-import type { LexicalProviderProps } from './LexicalProvider.js';
-import './LexicalEditor.scss';
-export declare const LexicalEditor: React.FC<Pick<LexicalProviderProps, 'editorConfig' | 'onChange'>>;
-//# sourceMappingURL=LexicalEditor.d.ts.map

package/dist/field/lexical/LexicalEditor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"LexicalEditor.d.ts","sourceRoot":"","sources":["../../../src/field/lexical/LexicalEditor.tsx"],"names":[],"mappings":"AAiBA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAG9B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAA;AAGhE,OAAO,sBAAsB,CAAA;AAQ7B,eAAO,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,oBAAoB,EAAE,cAAc,GAAG,UAAU,CAAC,CAgH3F,CAAA"}

package/dist/field/lexical/LexicalEditor.js

@@ -1,112 +0,0 @@
-'use client';
-import lexicalComposerContextImport from '@lexical/react/LexicalComposerContext.js';
-const { useLexicalComposerContext } = lexicalComposerContextImport;
-import LexicalErrorBoundary from '@lexical/react/LexicalErrorBoundary.js';
-import lexicalHistoryPluginImport from '@lexical/react/LexicalHistoryPlugin.js';
-const { HistoryPlugin } = lexicalHistoryPluginImport;
-import lexicalOnChangePluginImport from '@lexical/react/LexicalOnChangePlugin.js';
-const { OnChangePlugin } = lexicalOnChangePluginImport;
-import lexicalRichTextPluginImport from '@lexical/react/LexicalRichTextPlugin.js';
-const { RichTextPlugin } = lexicalRichTextPluginImport;
-import lexicalTabIndentationPluginImport from '@lexical/react/LexicalTabIndentationPlugin.js';
-const { TabIndentationPlugin } = lexicalTabIndentationPluginImport;
-import * as React from 'react';
-import { useEffect, useState } from 'react';
-import { EditorPlugin } from './EditorPlugin.js';
-import './LexicalEditor.scss';
-import { FloatingSelectToolbarPlugin } from './plugins/FloatingSelectToolbar/index.js';
-import { MarkdownShortcutPlugin } from './plugins/MarkdownShortcut/index.js';
-import { SlashMenuPlugin } from './plugins/SlashMenu/index.js';
-import { AddBlockHandlePlugin } from './plugins/handles/AddBlockHandlePlugin/index.js';
-import { DraggableBlockPlugin } from './plugins/handles/DraggableBlockPlugin/index.js';
-import { LexicalContentEditable } from './ui/ContentEditable.js';
-export const LexicalEditor = (props)=>{
-    const { editorConfig, onChange } = props;
-    const [editor] = useLexicalComposerContext();
-    const [floatingAnchorElem, setFloatingAnchorElem] = useState(null);
-    const onRef = (_floatingAnchorElem)=>{
-        if (_floatingAnchorElem !== null) {
-            setFloatingAnchorElem(_floatingAnchorElem);
-        }
-    };
-    const [isSmallWidthViewport, setIsSmallWidthViewport] = useState(false);
-    useEffect(()=>{
-        const updateViewPortWidth = ()=>{
-            const isNextSmallWidthViewport = window.matchMedia('(max-width: 1025px)').matches;
-            if (isNextSmallWidthViewport !== isSmallWidthViewport) {
-                setIsSmallWidthViewport(isNextSmallWidthViewport);
-            }
-        };
-        updateViewPortWidth();
-        window.addEventListener('resize', updateViewPortWidth);
-        return ()=>{
-            window.removeEventListener('resize', updateViewPortWidth);
-        };
-    }, [
-        isSmallWidthViewport
-    ]);
-    const ErrorBoundaryComponent = LexicalErrorBoundary.default || LexicalErrorBoundary;
-    return /*#__PURE__*/ React.createElement(React.Fragment, null, editorConfig.features.plugins.map((plugin)=>{
-        if (plugin.position === 'top') {
-            return /*#__PURE__*/ React.createElement(EditorPlugin, {
-                key: plugin.key,
-                plugin: plugin
-            });
-        }
-    }), /*#__PURE__*/ React.createElement(RichTextPlugin, {
-        //@ts-expect-error ts being dumb
-        ErrorBoundary: ErrorBoundaryComponent,
-        contentEditable: /*#__PURE__*/ React.createElement("div", {
-            className: "editor-scroller"
-        }, /*#__PURE__*/ React.createElement("div", {
-            className: "editor",
-            ref: onRef
-        }, /*#__PURE__*/ React.createElement(LexicalContentEditable, null))),
-        placeholder: /*#__PURE__*/ React.createElement("p", {
-            className: "editor-placeholder"
-        }, "Start typing, or press '/' for commands...")
-    }), /*#__PURE__*/ React.createElement(OnChangePlugin, {
-        // Selection changes can be ignored here, reducing the
-        // frequency that the FieldComponent and Payload receive updates.
-        // Selection changes are only needed if you are saving selection state
-        ignoreSelectionChange: true,
-        onChange: (editorState, editor, tags)=>{
-            // Ignore any onChange event triggered by focus only
-            if (!tags.has('focus') || tags.size > 1) {
-                if (onChange != null) onChange(editorState, editor, tags);
-            }
-        }
-    }), floatingAnchorElem && /*#__PURE__*/ React.createElement(React.Fragment, null, !isSmallWidthViewport && editor.isEditable() && /*#__PURE__*/ React.createElement(React.Fragment, null, /*#__PURE__*/ React.createElement(DraggableBlockPlugin, {
-        anchorElem: floatingAnchorElem
-    }), /*#__PURE__*/ React.createElement(AddBlockHandlePlugin, {
-        anchorElem: floatingAnchorElem
-    })), editorConfig.features.plugins.map((plugin)=>{
-        if (plugin.position === 'floatingAnchorElem' && !(plugin.desktopOnly === true && isSmallWidthViewport)) {
-            return /*#__PURE__*/ React.createElement(EditorPlugin, {
-                anchorElem: floatingAnchorElem,
-                key: plugin.key,
-                plugin: plugin
-            });
-        }
-    }), editor.isEditable() && /*#__PURE__*/ React.createElement(React.Fragment, null, /*#__PURE__*/ React.createElement(FloatingSelectToolbarPlugin, {
-        anchorElem: floatingAnchorElem
-    }), /*#__PURE__*/ React.createElement(SlashMenuPlugin, {
-        anchorElem: floatingAnchorElem
-    }))), editor.isEditable() && /*#__PURE__*/ React.createElement(React.Fragment, null, /*#__PURE__*/ React.createElement(HistoryPlugin, null), editorConfig?.features?.markdownTransformers?.length > 0 && /*#__PURE__*/ React.createElement(MarkdownShortcutPlugin, null)), /*#__PURE__*/ React.createElement(TabIndentationPlugin, null), editorConfig.features.plugins.map((plugin)=>{
-        if (plugin.position === 'normal') {
-            return /*#__PURE__*/ React.createElement(EditorPlugin, {
-                key: plugin.key,
-                plugin: plugin
-            });
-        }
-    }), editorConfig.features.plugins.map((plugin)=>{
-        if (plugin.position === 'bottom') {
-            return /*#__PURE__*/ React.createElement(EditorPlugin, {
-                key: plugin.key,
-                plugin: plugin
-            });
-        }
-    }));
-};
-
-//# sourceMappingURL=LexicalEditor.js.map

package/dist/field/lexical/LexicalEditor.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/field/lexical/LexicalEditor.tsx"],"sourcesContent":["'use client'\nimport lexicalComposerContextImport from '@lexical/react/LexicalComposerContext.js'\nconst { useLexicalComposerContext } = lexicalComposerContextImport\n\nimport LexicalErrorBoundary from '@lexical/react/LexicalErrorBoundary.js'\nimport lexicalHistoryPluginImport from '@lexical/react/LexicalHistoryPlugin.js'\nconst { HistoryPlugin } = lexicalHistoryPluginImport\n\nimport lexicalOnChangePluginImport from '@lexical/react/LexicalOnChangePlugin.js'\nconst { OnChangePlugin } = lexicalOnChangePluginImport\n\nimport lexicalRichTextPluginImport from '@lexical/react/LexicalRichTextPlugin.js'\nconst { RichTextPlugin } = lexicalRichTextPluginImport\n\nimport lexicalTabIndentationPluginImport from '@lexical/react/LexicalTabIndentationPlugin.js'\nconst { TabIndentationPlugin } = lexicalTabIndentationPluginImport\n\nimport * as React from 'react'\nimport { useEffect, useState } from 'react'\n\nimport type { LexicalProviderProps } from './LexicalProvider.js'\n\nimport { EditorPlugin } from './EditorPlugin.js'\nimport './LexicalEditor.scss'\nimport { FloatingSelectToolbarPlugin } from './plugins/FloatingSelectToolbar/index.js'\nimport { MarkdownShortcutPlugin } from './plugins/MarkdownShortcut/index.js'\nimport { SlashMenuPlugin } from './plugins/SlashMenu/index.js'\nimport { AddBlockHandlePlugin } from './plugins/handles/AddBlockHandlePlugin/index.js'\nimport { DraggableBlockPlugin } from './plugins/handles/DraggableBlockPlugin/index.js'\nimport { LexicalContentEditable } from './ui/ContentEditable.js'\n\nexport const LexicalEditor: React.FC<Pick<LexicalProviderProps, 'editorConfig' | 'onChange'>> = (\n  props,\n) => {\n  const { editorConfig, onChange } = props\n  const [editor] = useLexicalComposerContext()\n\n  const [floatingAnchorElem, setFloatingAnchorElem] = useState<HTMLDivElement | null>(null)\n  const onRef = (_floatingAnchorElem: HTMLDivElement) => {\n    if (_floatingAnchorElem !== null) {\n      setFloatingAnchorElem(_floatingAnchorElem)\n    }\n  }\n\n  const [isSmallWidthViewport, setIsSmallWidthViewport] = useState<boolean>(false)\n\n  useEffect(() => {\n    const updateViewPortWidth = () => {\n      const isNextSmallWidthViewport = window.matchMedia('(max-width: 1025px)').matches\n\n      if (isNextSmallWidthViewport !== isSmallWidthViewport) {\n        setIsSmallWidthViewport(isNextSmallWidthViewport)\n      }\n    }\n    updateViewPortWidth()\n    window.addEventListener('resize', updateViewPortWidth)\n\n    return () => {\n      window.removeEventListener('resize', updateViewPortWidth)\n    }\n  }, [isSmallWidthViewport])\n\n  const ErrorBoundaryComponent = LexicalErrorBoundary.default || LexicalErrorBoundary\n\n  return (\n    <React.Fragment>\n      {editorConfig.features.plugins.map((plugin) => {\n        if (plugin.position === 'top') {\n          return <EditorPlugin key={plugin.key} plugin={plugin} />\n        }\n      })}\n      <RichTextPlugin\n        //@ts-expect-error ts being dumb\n        ErrorBoundary={ErrorBoundaryComponent}\n        contentEditable={\n          <div className=\"editor-scroller\">\n            <div className=\"editor\" ref={onRef}>\n              <LexicalContentEditable />\n            </div>\n          </div>\n        }\n        placeholder={\n          <p className=\"editor-placeholder\">Start typing, or press '/' for commands...</p>\n        }\n      />\n      <OnChangePlugin\n        // Selection changes can be ignored here, reducing the\n        // frequency that the FieldComponent and Payload receive updates.\n        // Selection changes are only needed if you are saving selection state\n        ignoreSelectionChange\n        onChange={(editorState, editor, tags) => {\n          // Ignore any onChange event triggered by focus only\n          if (!tags.has('focus') || tags.size > 1) {\n            if (onChange != null) onChange(editorState, editor, tags)\n          }\n        }}\n      />\n      {floatingAnchorElem && (\n        <React.Fragment>\n          {!isSmallWidthViewport && editor.isEditable() && (\n            <React.Fragment>\n              <DraggableBlockPlugin anchorElem={floatingAnchorElem} />\n              <AddBlockHandlePlugin anchorElem={floatingAnchorElem} />\n            </React.Fragment>\n          )}\n          {editorConfig.features.plugins.map((plugin) => {\n            if (\n              plugin.position === 'floatingAnchorElem' &&\n              !(plugin.desktopOnly === true && isSmallWidthViewport)\n            ) {\n              return (\n                <EditorPlugin anchorElem={floatingAnchorElem} key={plugin.key} plugin={plugin} />\n              )\n            }\n          })}\n          {editor.isEditable() && (\n            <React.Fragment>\n              <FloatingSelectToolbarPlugin anchorElem={floatingAnchorElem} />\n              <SlashMenuPlugin anchorElem={floatingAnchorElem} />\n            </React.Fragment>\n          )}\n        </React.Fragment>\n      )}\n      {editor.isEditable() && (\n        <React.Fragment>\n          <HistoryPlugin />\n          {editorConfig?.features?.markdownTransformers?.length > 0 && <MarkdownShortcutPlugin />}\n        </React.Fragment>\n      )}\n\n      <TabIndentationPlugin />\n      {editorConfig.features.plugins.map((plugin) => {\n        if (plugin.position === 'normal') {\n          return <EditorPlugin key={plugin.key} plugin={plugin} />\n        }\n      })}\n      {editorConfig.features.plugins.map((plugin) => {\n        if (plugin.position === 'bottom') {\n          return <EditorPlugin key={plugin.key} plugin={plugin} />\n        }\n      })}\n    </React.Fragment>\n  )\n}\n"],"names":["lexicalComposerContextImport","useLexicalComposerContext","LexicalErrorBoundary","lexicalHistoryPluginImport","HistoryPlugin","lexicalOnChangePluginImport","OnChangePlugin","lexicalRichTextPluginImport","RichTextPlugin","lexicalTabIndentationPluginImport","TabIndentationPlugin","React","useEffect","useState","EditorPlugin","FloatingSelectToolbarPlugin","MarkdownShortcutPlugin","SlashMenuPlugin","AddBlockHandlePlugin","DraggableBlockPlugin","LexicalContentEditable","LexicalEditor","props","editorConfig","onChange","editor","floatingAnchorElem","setFloatingAnchorElem","onRef","_floatingAnchorElem","isSmallWidthViewport","setIsSmallWidthViewport","updateViewPortWidth","isNextSmallWidthViewport","window","matchMedia","matches","addEventListener","removeEventListener","ErrorBoundaryComponent","default","Fragment","features","plugins","map","plugin","position","key","ErrorBoundary","contentEditable","div","className","ref","placeholder","p","ignoreSelectionChange","editorState","tags","has","size","isEditable","anchorElem","desktopOnly","markdownTransformers","length"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/dist/field/lexical/LexicalEditor.scss

@@ -1,56 +0,0 @@
-.rich-text-lexical {
-  .editor {
-    position: relative;
-  }
-
-  .editor-shell {
-    position: relative;
-
-    font-family: var(--font-serif);
-    font-size: calc(var(--base) * 0.625);
-
-    h1,
-    h2,
-    h3,
-    h4,
-    h5,
-    h6 {
-      font-family: var(--font-body);
-      line-height: 1.125;
-    }
-  }
-
-  .editor-placeholder {
-    position: absolute;
-    top: 8px;
-    left: 0px;
-    font-size: 15px;
-    color: var(--theme-elevation-500);
-    /* Prevent text selection */
-    user-select: none;
-    -webkit-user-select: none;
-    -moz-user-select: none;
-    -ms-user-select: none;
-
-    /* Make it behave more like a background element (no interaction) */
-    pointer-events: none;
-  }
-}
-
-.floating-select-toolbar-popup__section-dropdown-align {
-  display: flex;
-  gap: 2px;
-}
-.floating-select-toolbar-popup__section-features {
-  display: flex;
-  gap: 2px;
-}
-.floating-select-toolbar-popup__section-dropdown-text {
-  display: flex;
-  gap: 2px;
-}
-
-.floating-select-toolbar-popup__section-format {
-  display: flex;
-  gap: 2px;
-}

package/dist/field/lexical/LexicalProvider.d.ts

@@ -1,19 +0,0 @@
-import type { EditorState, SerializedEditorState } from 'lexical';
-import type { LexicalEditor } from 'lexical';
-import type { FormFieldBase } from '@payloadcms/ui/fields/shared';
-import * as React from 'react';
-import type { SanitizedClientEditorConfig } from './config/types.js';
-export type LexicalProviderProps = {
-    editorConfig: SanitizedClientEditorConfig;
-    fieldProps: FormFieldBase & {
-        editorConfig: SanitizedClientEditorConfig;
-        name: string;
-        richTextComponentMap: Map<string, React.ReactNode>;
-    };
-    onChange: (editorState: EditorState, editor: LexicalEditor, tags: Set<string>) => void;
-    path: string;
-    readOnly: boolean;
-    value: SerializedEditorState;
-};
-export declare const LexicalProvider: React.FC<LexicalProviderProps>;
-//# sourceMappingURL=LexicalProvider.d.ts.map

package/dist/field/lexical/LexicalProvider.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"LexicalProvider.d.ts","sourceRoot":"","sources":["../../../src/field/lexical/LexicalProvider.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AACjE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAM5C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAA;AAEjE,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,mBAAmB,CAAA;AAMpE,MAAM,MAAM,oBAAoB,GAAG;IACjC,YAAY,EAAE,2BAA2B,CAAA;IACzC,UAAU,EAAE,aAAa,GAAG;QAC1B,YAAY,EAAE,2BAA2B,CAAA;QACzC,IAAI,EAAE,MAAM,CAAA;QACZ,oBAAoB,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,SAAS,CAAC,CAAA;KACnD,CAAA;IACD,QAAQ,EAAE,CAAC,WAAW,EAAE,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,KAAK,IAAI,CAAA;IACtF,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,OAAO,CAAA;IACjB,KAAK,EAAE,qBAAqB,CAAA;CAC7B,CAAA;AACD,eAAO,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC,oBAAoB,CA2D1D,CAAA"}