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

package/dist/field/features/upload/component/ExtraFieldsDrawer/index.js

@@ -0,0 +1,110 @@
+'use client';
+import { useModal } from '@faceless-ui/modal';
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { getTranslation } from '@payloadcms/translations';
+import { Drawer, FieldPathProvider, Form, FormSubmit, RenderFields, getFormState, useConfig, useDocumentInfo, useFieldPath, useTranslation } from '@payloadcms/ui';
+import { $getNodeByKey } from 'lexical';
+import { deepCopyObject } from 'payload/utilities';
+import React, { useCallback, useEffect, useState } from 'react';
+import { v4 as uuid } from 'uuid';
+import { useEditorConfigContext } from '../../../../lexical/config/client/EditorConfigProvider';
+/**
+ * This handles the extra fields, e.g. captions or alt text, which are
+ * potentially added to the upload feature.
+ */ export const ExtraFieldsUploadDrawer = (props)=>{
+    const { data: { fields, relationTo, value }, drawerSlug, nodeKey, relatedCollection } = props;
+    const [editor] = useLexicalComposerContext();
+    const { closeModal } = useModal();
+    const { i18n, t } = useTranslation();
+    const { id } = useDocumentInfo();
+    const { schemaPath } = useFieldPath();
+    const config = useConfig();
+    const [initialState, setInitialState] = useState(false);
+    const { field: { richTextComponentMap } } = useEditorConfigContext();
+    const componentMapRenderedFieldsPath = `feature.upload.fields.${relatedCollection.slug}`;
+    const schemaFieldsPath = `${schemaPath}.feature.upload.${relatedCollection.slug}`;
+    const fieldMap = richTextComponentMap.get(componentMapRenderedFieldsPath) // Field Schema
+    ;
+    useEffect(()=>{
+        const awaitInitialState = async ()=>{
+            const state = await getFormState({
+                apiRoute: config.routes.api,
+                body: {
+                    id,
+                    data: deepCopyObject(fields || {}),
+                    operation: 'update',
+                    schemaPath: schemaFieldsPath
+                },
+                serverURL: config.serverURL
+            }) // Form State
+            ;
+            setInitialState(state);
+        };
+        void awaitInitialState();
+    }, [
+        config.routes.api,
+        config.serverURL,
+        schemaFieldsPath,
+        id,
+        fields
+    ]);
+    const onChange = useCallback(async ({ formState: prevFormState })=>{
+        return await getFormState({
+            apiRoute: config.routes.api,
+            body: {
+                id,
+                formState: prevFormState,
+                operation: 'update',
+                schemaPath: schemaFieldsPath
+            },
+            serverURL: config.serverURL
+        });
+    }, [
+        config.routes.api,
+        config.serverURL,
+        schemaFieldsPath,
+        id
+    ]);
+    const handleUpdateEditData = useCallback((_, data)=>{
+        // Update lexical node (with key nodeKey) with new data
+        editor.update(()=>{
+            const uploadNode = $getNodeByKey(nodeKey);
+            if (uploadNode) {
+                const newData = {
+                    ...uploadNode.getData(),
+                    fields: data
+                };
+                uploadNode.setData(newData);
+            }
+        });
+        closeModal(drawerSlug);
+    }, [
+        closeModal,
+        editor,
+        drawerSlug,
+        nodeKey
+    ]);
+    return /*#__PURE__*/ React.createElement(Drawer, {
+        slug: drawerSlug,
+        title: t('general:editLabel', {
+            label: getTranslation(relatedCollection.labels.singular, i18n)
+        })
+    }, initialState !== false && /*#__PURE__*/ React.createElement(FieldPathProvider, {
+        path: "",
+        schemaPath: ""
+    }, /*#__PURE__*/ React.createElement(Form, {
+        // @ts-expect-error // TODO: Fix this type. Is this correct?
+        fields: fieldMap,
+        initialState: initialState,
+        onChange: [
+            onChange
+        ],
+        onSubmit: handleUpdateEditData,
+        uuid: uuid()
+    }, /*#__PURE__*/ React.createElement(RenderFields, {
+        fieldMap: Array.isArray(fieldMap) ? fieldMap : [],
+        forceRender: true
+    }), /*#__PURE__*/ React.createElement(FormSubmit, null, t('fields:saveChanges')))));
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../../src/field/features/upload/component/ExtraFieldsDrawer/index.tsx"],"sourcesContent":["'use client'\nimport type { FormState, SanitizedCollectionConfig } from 'payload/types'\n\nimport { useModal } from '@faceless-ui/modal'\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext'\nimport { getTranslation } from '@payloadcms/translations'\nimport {\n  Drawer,\n  FieldPathProvider,\n  Form,\n  type FormProps,\n  FormSubmit,\n  RenderFields,\n  getFormState,\n  useConfig,\n  useDocumentInfo,\n  useFieldPath,\n  useTranslation,\n} from '@payloadcms/ui'\nimport { $getNodeByKey } from 'lexical'\nimport { deepCopyObject } from 'payload/utilities'\nimport React, { useCallback, useEffect, useState } from 'react'\nimport { v4 as uuid } from 'uuid'\n\nimport type { ElementProps } from '..'\nimport type { UploadData, UploadNode } from '../../nodes/UploadNode'\n\nimport { useEditorConfigContext } from '../../../../lexical/config/client/EditorConfigProvider'\n\n/**\n * This handles the extra fields, e.g. captions or alt text, which are\n * potentially added to the upload feature.\n */\nexport const ExtraFieldsUploadDrawer: React.FC<\n  ElementProps & {\n    drawerSlug: string\n    relatedCollection: SanitizedCollectionConfig\n  }\n> = (props) => {\n  const {\n    data: { fields, relationTo, value },\n    drawerSlug,\n    nodeKey,\n    relatedCollection,\n  } = props\n\n  const [editor] = useLexicalComposerContext()\n\n  const { closeModal } = useModal()\n\n  const { i18n, t } = useTranslation()\n  const { id } = useDocumentInfo()\n  const { schemaPath } = useFieldPath()\n  const config = useConfig()\n  const [initialState, setInitialState] = useState<FormState | false>(false)\n  const {\n    field: { richTextComponentMap },\n  } = useEditorConfigContext()\n\n  const componentMapRenderedFieldsPath = `feature.upload.fields.${relatedCollection.slug}`\n  const schemaFieldsPath = `${schemaPath}.feature.upload.${relatedCollection.slug}`\n\n  const fieldMap = richTextComponentMap.get(componentMapRenderedFieldsPath) // Field Schema\n\n  useEffect(() => {\n    const awaitInitialState = async () => {\n      const state = await getFormState({\n        apiRoute: config.routes.api,\n        body: {\n          id,\n          data: deepCopyObject(fields || {}),\n          operation: 'update',\n          schemaPath: schemaFieldsPath,\n        },\n        serverURL: config.serverURL,\n      }) // Form State\n\n      setInitialState(state)\n    }\n\n    void awaitInitialState()\n  }, [config.routes.api, config.serverURL, schemaFieldsPath, id, fields])\n\n  const onChange: FormProps['onChange'][0] = useCallback(\n    async ({ formState: prevFormState }) => {\n      return await getFormState({\n        apiRoute: config.routes.api,\n        body: {\n          id,\n          formState: prevFormState,\n          operation: 'update',\n          schemaPath: schemaFieldsPath,\n        },\n        serverURL: config.serverURL,\n      })\n    },\n\n    [config.routes.api, config.serverURL, schemaFieldsPath, id],\n  )\n\n  const handleUpdateEditData = useCallback(\n    (_, data) => {\n      // Update lexical node (with key nodeKey) with new data\n      editor.update(() => {\n        const uploadNode: UploadNode | null = $getNodeByKey(nodeKey)\n        if (uploadNode) {\n          const newData: UploadData = {\n            ...uploadNode.getData(),\n            fields: data,\n          }\n          uploadNode.setData(newData)\n        }\n      })\n\n      closeModal(drawerSlug)\n    },\n    [closeModal, editor, drawerSlug, nodeKey],\n  )\n\n  return (\n    <Drawer\n      slug={drawerSlug}\n      title={t('general:editLabel', {\n        label: getTranslation(relatedCollection.labels.singular, i18n),\n      })}\n    >\n      {initialState !== false && (\n        <FieldPathProvider path=\"\" schemaPath=\"\">\n          <Form\n            // @ts-expect-error // TODO: Fix this type. Is this correct?\n            fields={fieldMap}\n            initialState={initialState}\n            onChange={[onChange]}\n            onSubmit={handleUpdateEditData}\n            uuid={uuid()}\n          >\n            <RenderFields fieldMap={Array.isArray(fieldMap) ? fieldMap : []} forceRender />\n            <FormSubmit>{t('fields:saveChanges')}</FormSubmit>\n          </Form>\n        </FieldPathProvider>\n      )}\n    </Drawer>\n  )\n}\n"],"names":["useModal","useLexicalComposerContext","getTranslation","Drawer","FieldPathProvider","Form","FormSubmit","RenderFields","getFormState","useConfig","useDocumentInfo","useFieldPath","useTranslation","$getNodeByKey","deepCopyObject","React","useCallback","useEffect","useState","v4","uuid","useEditorConfigContext","ExtraFieldsUploadDrawer","props","data","fields","relationTo","value","drawerSlug","nodeKey","relatedCollection","editor","closeModal","i18n","t","id","schemaPath","config","initialState","setInitialState","field","richTextComponentMap","componentMapRenderedFieldsPath","slug","schemaFieldsPath","fieldMap","get","awaitInitialState","state","apiRoute","routes","api","body","operation","serverURL","onChange","formState","prevFormState","handleUpdateEditData","_","update","uploadNode","newData","getData","setData","title","label","labels","singular","path","onSubmit","Array","isArray","forceRender"],"mappings":"AAAA;AAGA,SAASA,QAAQ,QAAQ,qBAAoB;AAC7C,SAASC,yBAAyB,QAAQ,wCAAuC;AACjF,SAASC,cAAc,QAAQ,2BAA0B;AACzD,SACEC,MAAM,EACNC,iBAAiB,EACjBC,IAAI,EAEJC,UAAU,EACVC,YAAY,EACZC,YAAY,EACZC,SAAS,EACTC,eAAe,EACfC,YAAY,EACZC,cAAc,QACT,iBAAgB;AACvB,SAASC,aAAa,QAAQ,UAAS;AACvC,SAASC,cAAc,QAAQ,oBAAmB;AAClD,OAAOC,SAASC,WAAW,EAAEC,SAAS,EAAEC,QAAQ,QAAQ,QAAO;AAC/D,SAASC,MAAMC,IAAI,QAAQ,OAAM;AAKjC,SAASC,sBAAsB,QAAQ,yDAAwD;AAE/F;;;CAGC,GACD,OAAO,MAAMC,0BAKT,CAACC;IACH,MAAM,EACJC,MAAM,EAAEC,MAAM,EAAEC,UAAU,EAAEC,KAAK,EAAE,EACnCC,UAAU,EACVC,OAAO,EACPC,iBAAiB,EAClB,GAAGP;IAEJ,MAAM,CAACQ,OAAO,GAAG9B;IAEjB,MAAM,EAAE+B,UAAU,EAAE,GAAGhC;IAEvB,MAAM,EAAEiC,IAAI,EAAEC,CAAC,EAAE,GAAGtB;IACpB,MAAM,EAAEuB,EAAE,EAAE,GAAGzB;IACf,MAAM,EAAE0B,UAAU,EAAE,GAAGzB;IACvB,MAAM0B,SAAS5B;IACf,MAAM,CAAC6B,cAAcC,gBAAgB,GAAGrB,SAA4B;IACpE,MAAM,EACJsB,OAAO,EAAEC,oBAAoB,EAAE,EAChC,GAAGpB;IAEJ,MAAMqB,iCAAiC,CAAC,sBAAsB,EAAEZ,kBAAkBa,IAAI,CAAC,CAAC;IACxF,MAAMC,mBAAmB,CAAC,EAAER,WAAW,gBAAgB,EAAEN,kBAAkBa,IAAI,CAAC,CAAC;IAEjF,MAAME,WAAWJ,qBAAqBK,GAAG,CAACJ,gCAAgC,eAAe;;IAEzFzB,UAAU;QACR,MAAM8B,oBAAoB;YACxB,MAAMC,QAAQ,MAAMxC,aAAa;gBAC/ByC,UAAUZ,OAAOa,MAAM,CAACC,GAAG;gBAC3BC,MAAM;oBACJjB;oBACAX,MAAMV,eAAeW,UAAU,CAAC;oBAChC4B,WAAW;oBACXjB,YAAYQ;gBACd;gBACAU,WAAWjB,OAAOiB,SAAS;YAC7B,GAAG,aAAa;;YAEhBf,gBAAgBS;QAClB;QAEA,KAAKD;IACP,GAAG;QAACV,OAAOa,MAAM,CAACC,GAAG;QAAEd,OAAOiB,SAAS;QAAEV;QAAkBT;QAAIV;KAAO;IAEtE,MAAM8B,WAAqCvC,YACzC,OAAO,EAAEwC,WAAWC,aAAa,EAAE;QACjC,OAAO,MAAMjD,aAAa;YACxByC,UAAUZ,OAAOa,MAAM,CAACC,GAAG;YAC3BC,MAAM;gBACJjB;gBACAqB,WAAWC;gBACXJ,WAAW;gBACXjB,YAAYQ;YACd;YACAU,WAAWjB,OAAOiB,SAAS;QAC7B;IACF,GAEA;QAACjB,OAAOa,MAAM,CAACC,GAAG;QAAEd,OAAOiB,SAAS;QAAEV;QAAkBT;KAAG;IAG7D,MAAMuB,uBAAuB1C,YAC3B,CAAC2C,GAAGnC;QACF,uDAAuD;QACvDO,OAAO6B,MAAM,CAAC;YACZ,MAAMC,aAAgChD,cAAcgB;YACpD,IAAIgC,YAAY;gBACd,MAAMC,UAAsB;oBAC1B,GAAGD,WAAWE,OAAO,EAAE;oBACvBtC,QAAQD;gBACV;gBACAqC,WAAWG,OAAO,CAACF;YACrB;QACF;QAEA9B,WAAWJ;IACb,GACA;QAACI;QAAYD;QAAQH;QAAYC;KAAQ;IAG3C,qBACE,oBAAC1B;QACCwC,MAAMf;QACNqC,OAAO/B,EAAE,qBAAqB;YAC5BgC,OAAOhE,eAAe4B,kBAAkBqC,MAAM,CAACC,QAAQ,EAAEnC;QAC3D;OAECK,iBAAiB,uBAChB,oBAAClC;QAAkBiE,MAAK;QAAGjC,YAAW;qBACpC,oBAAC/B;QACC,4DAA4D;QAC5DoB,QAAQoB;QACRP,cAAcA;QACdiB,UAAU;YAACA;SAAS;QACpBe,UAAUZ;QACVtC,MAAMA;qBAEN,oBAACb;QAAasC,UAAU0B,MAAMC,OAAO,CAAC3B,YAAYA,WAAW,EAAE;QAAE4B,aAAAA;sBACjE,oBAACnE,kBAAY4B,EAAE;AAM3B,EAAC"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/upload/component/index.tsx"],"names":[],"mappings":"AAkBA,OAAO,KAA4C,MAAM,OAAO,CAAA;AAIhE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAMrD,OAAO,cAAc,CAAA;AAQrB,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,UAAU,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;CAEhB,CAAA;gCA+IsB,YAAY,KAAG,MAAM,SAAS;AAArD,wBAMC"}

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

@@ -0,0 +1,135 @@
+'use client';
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { useLexicalNodeSelection } from '@lexical/react/useLexicalNodeSelection';
+import { getTranslation } from '@payloadcms/translations';
+import { Button, DrawerToggler, FileGraphic, useConfig, useDocumentDrawer, useDrawerSlug, usePayloadAPI, useThumbnail, useTranslation } from '@payloadcms/ui';
+import { $getNodeByKey } from 'lexical';
+import React, { useCallback, useReducer, useState } from 'react';
+import { useEditorConfigContext } from '../../../lexical/config/client/EditorConfigProvider';
+import { EnabledRelationshipsCondition } from '../../relationship/utils/EnabledRelationshipsCondition';
+import { INSERT_UPLOAD_WITH_DRAWER_COMMAND } from '../drawer/commands';
+import { ExtraFieldsUploadDrawer } from './ExtraFieldsDrawer';
+import './index.scss';
+const baseClass = 'lexical-upload';
+const initialParams = {
+    depth: 0
+};
+const Component = (props)=>{
+    const { data: { fields, relationTo, value }, nodeKey } = props;
+    const { collections, routes: { api }, serverURL } = useConfig();
+    const [editor] = useLexicalComposerContext();
+    const [isSelected, setSelected, clearSelection] = useLexicalNodeSelection(nodeKey);
+    const { editorConfig, field } = useEditorConfigContext();
+    const { i18n, t } = useTranslation();
+    const [cacheBust, dispatchCacheBust] = useReducer((state)=>state + 1, 0);
+    const [relatedCollection, setRelatedCollection] = useState(()=>collections.find((coll)=>coll.slug === relationTo));
+    const drawerSlug = useDrawerSlug('upload-drawer');
+    const [DocumentDrawer, DocumentDrawerToggler, { closeDrawer }] = useDocumentDrawer({
+        id: value?.id,
+        collectionSlug: relatedCollection.slug
+    });
+    // Get the referenced document
+    const [{ data }, { setParams }] = usePayloadAPI(`${serverURL}${api}/${relatedCollection.slug}/${value?.id}`, {
+        initialParams
+    });
+    const thumbnailSRC = useThumbnail(relatedCollection.slug, relatedCollection.upload, data);
+    const removeUpload = useCallback(()=>{
+        editor.update(()=>{
+            $getNodeByKey(nodeKey).remove();
+        });
+    }, [
+        editor,
+        nodeKey
+    ]);
+    const updateUpload = useCallback((json)=>{
+        setParams({
+            ...initialParams,
+            cacheBust
+        });
+        dispatchCacheBust();
+        closeDrawer();
+    }, [
+        setParams,
+        cacheBust,
+        closeDrawer
+    ]);
+    const hasExtraFields = editorConfig?.resolvedFeatureMap?.get('upload')?.clientFeatureProps.collections?.[relatedCollection.slug]?.hasExtraFields;
+    return /*#__PURE__*/ React.createElement("div", {
+        className: [
+            baseClass,
+            isSelected && `${baseClass}--selected`
+        ].filter(Boolean).join(' '),
+        contentEditable: false
+    }, /*#__PURE__*/ React.createElement("div", {
+        className: `${baseClass}__card`
+    }, /*#__PURE__*/ React.createElement("div", {
+        className: `${baseClass}__topRow`
+    }, /*#__PURE__*/ React.createElement("div", {
+        className: `${baseClass}__thumbnail`
+    }, thumbnailSRC ? /*#__PURE__*/ React.createElement("img", {
+        alt: data?.filename,
+        src: thumbnailSRC
+    }) : /*#__PURE__*/ React.createElement(FileGraphic, null)), /*#__PURE__*/ React.createElement("div", {
+        className: `${baseClass}__topRowRightPanel`
+    }, /*#__PURE__*/ React.createElement("div", {
+        className: `${baseClass}__collectionLabel`
+    }, getTranslation(relatedCollection.labels.singular, i18n)), editor.isEditable() && /*#__PURE__*/ React.createElement("div", {
+        className: `${baseClass}__actions`
+    }, hasExtraFields ? /*#__PURE__*/ React.createElement(DrawerToggler, {
+        className: `${baseClass}__upload-drawer-toggler`,
+        disabled: field?.readOnly,
+        slug: drawerSlug
+    }, /*#__PURE__*/ React.createElement(Button, {
+        buttonStyle: "icon-label",
+        el: "div",
+        icon: "edit",
+        onClick: (e)=>{
+            e.preventDefault();
+        },
+        round: true,
+        tooltip: t('fields:editRelationship')
+    })) : null, /*#__PURE__*/ React.createElement(Button, {
+        buttonStyle: "icon-label",
+        disabled: field?.readOnly,
+        el: "div",
+        icon: "swap",
+        onClick: ()=>{
+            editor.dispatchCommand(INSERT_UPLOAD_WITH_DRAWER_COMMAND, {
+                replace: {
+                    nodeKey
+                }
+            });
+        },
+        round: true,
+        tooltip: t('fields:swapUpload')
+    }), /*#__PURE__*/ React.createElement(Button, {
+        buttonStyle: "icon-label",
+        className: `${baseClass}__removeButton`,
+        disabled: field?.readOnly,
+        icon: "x",
+        onClick: (e)=>{
+            e.preventDefault();
+            removeUpload();
+        },
+        round: true,
+        tooltip: t('fields:removeUpload')
+    })))), /*#__PURE__*/ React.createElement("div", {
+        className: `${baseClass}__bottomRow`
+    }, /*#__PURE__*/ React.createElement(DocumentDrawerToggler, {
+        className: `${baseClass}__doc-drawer-toggler`
+    }, /*#__PURE__*/ React.createElement("strong", null, data?.filename)))), value?.id && /*#__PURE__*/ React.createElement(DocumentDrawer, {
+        onSave: updateUpload
+    }), /*#__PURE__*/ React.createElement(ExtraFieldsUploadDrawer, {
+        drawerSlug: drawerSlug,
+        relatedCollection: relatedCollection,
+        ...props
+    }));
+};
+export default ((props)=>{
+    return /*#__PURE__*/ React.createElement(EnabledRelationshipsCondition, {
+        ...props,
+        uploads: true
+    }, /*#__PURE__*/ React.createElement(Component, props));
+});
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../src/field/features/upload/component/index.tsx"],"sourcesContent":["'use client'\nimport type { SanitizedCollectionConfig } from 'payload/types'\n\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext'\nimport { useLexicalNodeSelection } from '@lexical/react/useLexicalNodeSelection'\nimport { getTranslation } from '@payloadcms/translations'\nimport {\n  Button,\n  DrawerToggler,\n  FileGraphic,\n  useConfig,\n  useDocumentDrawer,\n  useDrawerSlug,\n  usePayloadAPI,\n  useThumbnail,\n  useTranslation,\n} from '@payloadcms/ui'\nimport { $getNodeByKey } from 'lexical'\nimport React, { useCallback, useReducer, useState } from 'react'\n\nimport type { ClientComponentProps } from '../../types'\nimport type { UploadFeaturePropsClient } from '../feature.client'\nimport type { UploadData } from '../nodes/UploadNode'\n\nimport { useEditorConfigContext } from '../../../lexical/config/client/EditorConfigProvider'\nimport { EnabledRelationshipsCondition } from '../../relationship/utils/EnabledRelationshipsCondition'\nimport { INSERT_UPLOAD_WITH_DRAWER_COMMAND } from '../drawer/commands'\nimport { ExtraFieldsUploadDrawer } from './ExtraFieldsDrawer'\nimport './index.scss'\n\nconst baseClass = 'lexical-upload'\n\nconst initialParams = {\n  depth: 0,\n}\n\nexport type ElementProps = {\n  data: UploadData\n  nodeKey: string\n  //uploadProps: UploadFeatureProps\n}\n\nconst Component: React.FC<ElementProps> = (props) => {\n  const {\n    data: { fields, relationTo, value },\n    nodeKey,\n  } = props\n\n  const {\n    collections,\n    routes: { api },\n    serverURL,\n  } = useConfig()\n\n  const [editor] = useLexicalComposerContext()\n  const [isSelected, setSelected, clearSelection] = useLexicalNodeSelection(nodeKey)\n  const { editorConfig, field } = useEditorConfigContext()\n\n  const { i18n, t } = useTranslation()\n  const [cacheBust, dispatchCacheBust] = useReducer((state) => state + 1, 0)\n  const [relatedCollection, setRelatedCollection] = useState<SanitizedCollectionConfig>(() =>\n    collections.find((coll) => coll.slug === relationTo),\n  )\n\n  const drawerSlug = useDrawerSlug('upload-drawer')\n\n  const [DocumentDrawer, DocumentDrawerToggler, { closeDrawer }] = useDocumentDrawer({\n    id: value?.id,\n    collectionSlug: relatedCollection.slug,\n  })\n\n  // Get the referenced document\n  const [{ data }, { setParams }] = usePayloadAPI(\n    `${serverURL}${api}/${relatedCollection.slug}/${value?.id}`,\n    { initialParams },\n  )\n\n  const thumbnailSRC = useThumbnail(relatedCollection.slug, relatedCollection.upload, data)\n\n  const removeUpload = useCallback(() => {\n    editor.update(() => {\n      $getNodeByKey(nodeKey).remove()\n    })\n  }, [editor, nodeKey])\n\n  const updateUpload = useCallback(\n    (json) => {\n      setParams({\n        ...initialParams,\n        cacheBust, // do this to get the usePayloadAPI to re-fetch the data even though the URL string hasn't changed\n      })\n\n      dispatchCacheBust()\n      closeDrawer()\n    },\n    [setParams, cacheBust, closeDrawer],\n  )\n\n  const hasExtraFields = (\n    editorConfig?.resolvedFeatureMap?.get('upload')\n      ?.clientFeatureProps as ClientComponentProps<UploadFeaturePropsClient>\n  ).collections?.[relatedCollection.slug]?.hasExtraFields\n\n  return (\n    <div\n      className={[baseClass, isSelected && `${baseClass}--selected`].filter(Boolean).join(' ')}\n      contentEditable={false}\n    >\n      <div className={`${baseClass}__card`}>\n        <div className={`${baseClass}__topRow`}>\n          <div className={`${baseClass}__thumbnail`}>\n            {thumbnailSRC ? <img alt={data?.filename} src={thumbnailSRC} /> : <FileGraphic />}\n          </div>\n          <div className={`${baseClass}__topRowRightPanel`}>\n            <div className={`${baseClass}__collectionLabel`}>\n              {getTranslation(relatedCollection.labels.singular, i18n)}\n            </div>\n            {editor.isEditable() && (\n              <div className={`${baseClass}__actions`}>\n                {hasExtraFields ? (\n                  <DrawerToggler\n                    className={`${baseClass}__upload-drawer-toggler`}\n                    disabled={field?.readOnly}\n                    slug={drawerSlug}\n                  >\n                    <Button\n                      buttonStyle=\"icon-label\"\n                      el=\"div\"\n                      icon=\"edit\"\n                      onClick={(e) => {\n                        e.preventDefault()\n                      }}\n                      round\n                      tooltip={t('fields:editRelationship')}\n                    />\n                  </DrawerToggler>\n                ) : null}\n\n                <Button\n                  buttonStyle=\"icon-label\"\n                  disabled={field?.readOnly}\n                  el=\"div\"\n                  icon=\"swap\"\n                  onClick={() => {\n                    editor.dispatchCommand(INSERT_UPLOAD_WITH_DRAWER_COMMAND, {\n                      replace: { nodeKey },\n                    })\n                  }}\n                  round\n                  tooltip={t('fields:swapUpload')}\n                />\n                <Button\n                  buttonStyle=\"icon-label\"\n                  className={`${baseClass}__removeButton`}\n                  disabled={field?.readOnly}\n                  icon=\"x\"\n                  onClick={(e) => {\n                    e.preventDefault()\n                    removeUpload()\n                  }}\n                  round\n                  tooltip={t('fields:removeUpload')}\n                />\n              </div>\n            )}\n          </div>\n        </div>\n        <div className={`${baseClass}__bottomRow`}>\n          <DocumentDrawerToggler className={`${baseClass}__doc-drawer-toggler`}>\n            <strong>{data?.filename}</strong>\n          </DocumentDrawerToggler>\n        </div>\n      </div>\n      {value?.id && <DocumentDrawer onSave={updateUpload} />}\n      <ExtraFieldsUploadDrawer\n        drawerSlug={drawerSlug}\n        relatedCollection={relatedCollection}\n        {...props}\n      />\n    </div>\n  )\n}\n\nexport default (props: ElementProps): React.ReactNode => {\n  return (\n    <EnabledRelationshipsCondition {...props} uploads>\n      <Component {...props} />\n    </EnabledRelationshipsCondition>\n  )\n}\n"],"names":["useLexicalComposerContext","useLexicalNodeSelection","getTranslation","Button","DrawerToggler","FileGraphic","useConfig","useDocumentDrawer","useDrawerSlug","usePayloadAPI","useThumbnail","useTranslation","$getNodeByKey","React","useCallback","useReducer","useState","useEditorConfigContext","EnabledRelationshipsCondition","INSERT_UPLOAD_WITH_DRAWER_COMMAND","ExtraFieldsUploadDrawer","baseClass","initialParams","depth","Component","props","data","fields","relationTo","value","nodeKey","collections","routes","api","serverURL","editor","isSelected","setSelected","clearSelection","editorConfig","field","i18n","t","cacheBust","dispatchCacheBust","state","relatedCollection","setRelatedCollection","find","coll","slug","drawerSlug","DocumentDrawer","DocumentDrawerToggler","closeDrawer","id","collectionSlug","setParams","thumbnailSRC","upload","removeUpload","update","remove","updateUpload","json","hasExtraFields","resolvedFeatureMap","get","clientFeatureProps","div","className","filter","Boolean","join","contentEditable","img","alt","filename","src","labels","singular","isEditable","disabled","readOnly","buttonStyle","el","icon","onClick","e","preventDefault","round","tooltip","dispatchCommand","replace","strong","onSave","uploads"],"mappings":"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"}

package/dist/field/features/upload/component/index.scss

@@ -0,0 +1,152 @@
+@import '../../../../scss/styles.scss';
+
+.lexical-upload {
+  @extend %body;
+  @include shadow-sm;
+  max-width: calc(var(--base) * 15);
+  display: flex;
+  align-items: center;
+  background: var(--theme-input-bg);
+  border: 1px solid var(--theme-elevation-100);
+  position: relative;
+  font-family: var(--font-body);
+  margin: 0 0 1.5em;
+
+  .btn {
+    margin: 0;
+  }
+
+  &:hover {
+    border: 1px solid var(--theme-elevation-150);
+  }
+
+  &[data-slate-node='element'] {
+    margin: calc(var(--base) * 0.625) 0;
+  }
+
+  &__card {
+    @include soft-shadow-bottom;
+    display: flex;
+    flex-direction: column;
+    width: 100%;
+  }
+
+  &__topRow {
+    display: flex;
+  }
+
+  &__thumbnail {
+    width: calc(var(--base) * 3.25);
+    height: auto;
+    position: relative;
+    overflow: hidden;
+    flex-shrink: 0;
+
+    img,
+    svg {
+      position: absolute;
+      object-fit: cover;
+      width: 100%;
+      height: 100%;
+      background-color: var(--theme-elevation-800);
+    }
+  }
+
+  &__topRowRightPanel {
+    flex-grow: 1;
+    display: flex;
+    align-items: center;
+    padding: calc(var(--base) * 0.75);
+    justify-content: space-between;
+    max-width: calc(100% - #{calc(var(--base) * 3.25)});
+  }
+
+  &__actions {
+    display: flex;
+    align-items: center;
+    flex-shrink: 0;
+    margin-left: calc(var(--base) * 0.5);
+
+    .lexical-upload__doc-drawer-toggler {
+      pointer-events: all;
+    }
+
+    & > *:not(:last-child) {
+      margin-right: calc(var(--base) * 0.25);
+    }
+  }
+
+  &__removeButton {
+    margin: 0;
+
+    line {
+      stroke-width: $style-stroke-width-m;
+    }
+
+    &:disabled {
+      color: var(--theme-elevation-300);
+      pointer-events: none;
+    }
+  }
+
+  &__upload-drawer-toggler {
+    background-color: transparent;
+    border: none;
+    padding: 0;
+    margin: 0;
+    outline: none;
+    line-height: inherit;
+  }
+
+  &__doc-drawer-toggler {
+    text-decoration: underline;
+  }
+
+  &__doc-drawer-toggler,
+  &__list-drawer-toggler,
+  &__upload-drawer-toggler {
+    & > * {
+      margin: 0;
+    }
+
+    &:disabled {
+      color: var(--theme-elevation-300);
+      pointer-events: none;
+    }
+  }
+
+  &__collectionLabel {
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+
+  &__bottomRow {
+    padding: calc(var(--base) * 0.5);
+    border-top: 1px solid var(--theme-elevation-100);
+  }
+
+  h5 {
+    white-space: nowrap;
+    text-overflow: ellipsis;
+    overflow: hidden;
+  }
+
+  &__wrap {
+    padding: calc(var(--base) * 0.5) calc(var(--base) * 0.5) calc(var(--base) * 0.5) var(--base);
+    text-align: left;
+    overflow: hidden;
+    text-overflow: ellipsis;
+  }
+
+  &--selected {
+    box-shadow: $focus-box-shadow;
+    outline: none;
+  }
+
+  @include small-break {
+    &__topRowRightPanel {
+      padding: calc(var(--base) * 0.75) calc(var(--base) * 0.5);
+    }
+  }
+}

package/dist/field/features/upload/drawer/commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/upload/drawer/commands.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAI7C,eAAO,MAAM,iCAAiC,EAAE,cAAc,CAAC;IAC7D,OAAO,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,GAAG,KAAK,CAAA;CACrC,CAAsD,CAAA"}

package/dist/field/features/upload/drawer/commands.js

@@ -0,0 +1,5 @@
+'use client';
+import { createCommand } from 'lexical';
+export const INSERT_UPLOAD_WITH_DRAWER_COMMAND = createCommand('INSERT_UPLOAD_WITH_DRAWER_COMMAND');
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy91cGxvYWQvZHJhd2VyL2NvbW1hbmRzLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIid1c2UgY2xpZW50J1xuaW1wb3J0IHR5cGUgeyBMZXhpY2FsQ29tbWFuZCB9IGZyb20gJ2xleGljYWwnXG5cbmltcG9ydCB7IGNyZWF0ZUNvbW1hbmQgfSBmcm9tICdsZXhpY2FsJ1xuXG5leHBvcnQgY29uc3QgSU5TRVJUX1VQTE9BRF9XSVRIX0RSQVdFUl9DT01NQU5EOiBMZXhpY2FsQ29tbWFuZDx7XG4gIHJlcGxhY2U6IHsgbm9kZUtleTogc3RyaW5nIH0gfCBmYWxzZVxufT4gPSBjcmVhdGVDb21tYW5kKCdJTlNFUlRfVVBMT0FEX1dJVEhfRFJBV0VSX0NPTU1BTkQnKVxuIl0sIm5hbWVzIjpbImNyZWF0ZUNvbW1hbmQiLCJJTlNFUlRfVVBMT0FEX1dJVEhfRFJBV0VSX0NPTU1BTkQiXSwibWFwcGluZ3MiOiJBQUFBO0FBR0EsU0FBU0EsYUFBYSxRQUFRLFVBQVM7QUFFdkMsT0FBTyxNQUFNQyxvQ0FFUkQsY0FBYyxxQ0FBb0MifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/upload/drawer/index.tsx"],"names":[],"mappings":"AAIA,OAAO,KAA2C,MAAM,OAAO,CAAA;AA8C/D,KAAK,KAAK,GAAG;IACX,sBAAsB,EAAE,MAAM,EAAE,CAAA;CACjC,CAAA;AA0CD,eAAO,MAAM,YAAY,UAAW,KAAK,KAAG,MAAM,SAMjD,CAAA"}

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

@@ -0,0 +1,76 @@
+'use client';
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { useListDrawer } from '@payloadcms/ui';
+import { $getNodeByKey, COMMAND_PRIORITY_EDITOR } from 'lexical';
+import React, { useCallback, useEffect, useState } from 'react';
+import { EnabledRelationshipsCondition } from '../../relationship/utils/EnabledRelationshipsCondition';
+import { $createUploadNode } from '../nodes/UploadNode';
+import { INSERT_UPLOAD_COMMAND } from '../plugin';
+import { INSERT_UPLOAD_WITH_DRAWER_COMMAND } from './commands';
+const baseClass = 'lexical-upload-drawer';
+const insertUpload = ({ id, editor, relationTo, replaceNodeKey })=>{
+    if (!replaceNodeKey) {
+        editor.dispatchCommand(INSERT_UPLOAD_COMMAND, {
+            id,
+            fields: null,
+            relationTo
+        });
+    } else {
+        editor.update(()=>{
+            const node = $getNodeByKey(replaceNodeKey);
+            if (node) {
+                node.replace($createUploadNode({
+                    data: {
+                        fields: null,
+                        relationTo,
+                        value: {
+                            id
+                        }
+                    }
+                }));
+            }
+        });
+    }
+};
+const UploadDrawerComponent = ({ enabledCollectionSlugs })=>{
+    const [editor] = useLexicalComposerContext();
+    const [replaceNodeKey, setReplaceNodeKey] = useState(null);
+    const [ListDrawer, ListDrawerToggler, { closeDrawer, openDrawer }] = useListDrawer({
+        collectionSlugs: enabledCollectionSlugs,
+        uploads: true
+    });
+    useEffect(()=>{
+        return editor.registerCommand(INSERT_UPLOAD_WITH_DRAWER_COMMAND, (payload)=>{
+            setReplaceNodeKey(payload?.replace ? payload?.replace.nodeKey : null);
+            openDrawer();
+            return true;
+        }, COMMAND_PRIORITY_EDITOR);
+    }, [
+        editor,
+        openDrawer
+    ]);
+    const onSelect = useCallback(({ collectionSlug, docID })=>{
+        insertUpload({
+            id: docID,
+            editor,
+            relationTo: collectionSlug,
+            replaceNodeKey
+        });
+        closeDrawer();
+    }, [
+        editor,
+        closeDrawer,
+        replaceNodeKey
+    ]);
+    return /*#__PURE__*/ React.createElement(ListDrawer, {
+        onSelect: onSelect
+    });
+};
+export const UploadDrawer = (props)=>{
+    return /*#__PURE__*/ React.createElement(EnabledRelationshipsCondition, {
+        ...props,
+        uploads: true
+    }, /*#__PURE__*/ React.createElement(UploadDrawerComponent, props));
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy91cGxvYWQvZHJhd2VyL2luZGV4LnRzeCJdLCJzb3VyY2VzQ29udGVudCI6WyIndXNlIGNsaWVudCdcbmltcG9ydCB7IHVzZUxleGljYWxDb21wb3NlckNvbnRleHQgfSBmcm9tICdAbGV4aWNhbC9yZWFjdC9MZXhpY2FsQ29tcG9zZXJDb250ZXh0J1xuaW1wb3J0IHsgdXNlTGlzdERyYXdlciB9IGZyb20gJ0BwYXlsb2FkY21zL3VpJ1xuaW1wb3J0IHsgJGdldE5vZGVCeUtleSwgQ09NTUFORF9QUklPUklUWV9FRElUT1IsIHR5cGUgTGV4aWNhbEVkaXRvciB9IGZyb20gJ2xleGljYWwnXG5pbXBvcnQgUmVhY3QsIHsgdXNlQ2FsbGJhY2ssIHVzZUVmZmVjdCwgdXNlU3RhdGUgfSBmcm9tICdyZWFjdCdcblxuaW1wb3J0IHsgRW5hYmxlZFJlbGF0aW9uc2hpcHNDb25kaXRpb24gfSBmcm9tICcuLi8uLi9yZWxhdGlvbnNoaXAvdXRpbHMvRW5hYmxlZFJlbGF0aW9uc2hpcHNDb25kaXRpb24nXG5pbXBvcnQgeyAkY3JlYXRlVXBsb2FkTm9kZSB9IGZyb20gJy4uL25vZGVzL1VwbG9hZE5vZGUnXG5pbXBvcnQgeyBJTlNFUlRfVVBMT0FEX0NPTU1BTkQgfSBmcm9tICcuLi9wbHVnaW4nXG5pbXBvcnQgeyBJTlNFUlRfVVBMT0FEX1dJVEhfRFJBV0VSX0NPTU1BTkQgfSBmcm9tICcuL2NvbW1hbmRzJ1xuXG5jb25zdCBiYXNlQ2xhc3MgPSAnbGV4aWNhbC11cGxvYWQtZHJhd2VyJ1xuXG5jb25zdCBpbnNlcnRVcGxvYWQgPSAoe1xuICBpZCxcbiAgZWRpdG9yLFxuICByZWxhdGlvblRvLFxuICByZXBsYWNlTm9kZUtleSxcbn06IHtcbiAgZWRpdG9yOiBMZXhpY2FsRWRpdG9yXG4gIGlkOiBzdHJpbmdcbiAgcmVsYXRpb25Ubzogc3RyaW5nXG4gIHJlcGxhY2VOb2RlS2V5OiBudWxsIHwgc3RyaW5nXG59KSA9PiB7XG4gIGlmICghcmVwbGFjZU5vZGVLZXkpIHtcbiAgICBlZGl0b3IuZGlzcGF0Y2hDb21tYW5kKElOU0VSVF9VUExPQURfQ09NTUFORCwge1xuICAgICAgaWQsXG4gICAgICBmaWVsZHM6IG51bGwsXG4gICAgICByZWxhdGlvblRvLFxuICAgIH0pXG4gIH0gZWxzZSB7XG4gICAgZWRpdG9yLnVwZGF0ZSgoKSA9PiB7XG4gICAgICBjb25zdCBub2RlID0gJGdldE5vZGVCeUtleShyZXBsYWNlTm9kZUtleSlcbiAgICAgIGlmIChub2RlKSB7XG4gICAgICAgIG5vZGUucmVwbGFjZShcbiAgICAgICAgICAkY3JlYXRlVXBsb2FkTm9kZSh7XG4gICAgICAgICAgICBkYXRhOiB7XG4gICAgICAgICAgICAgIGZpZWxkczogbnVsbCxcbiAgICAgICAgICAgICAgcmVsYXRpb25UbyxcbiAgICAgICAgICAgICAgdmFsdWU6IHtcbiAgICAgICAgICAgICAgICBpZCxcbiAgICAgICAgICAgICAgfSxcbiAgICAgICAgICAgIH0sXG4gICAgICAgICAgfSksXG4gICAgICAgIClcbiAgICAgIH1cbiAgICB9KVxuICB9XG59XG5cbnR5cGUgUHJvcHMgPSB7XG4gIGVuYWJsZWRDb2xsZWN0aW9uU2x1Z3M6IHN0cmluZ1tdXG59XG5cbmNvbnN0IFVwbG9hZERyYXdlckNvbXBvbmVudDogUmVhY3QuRkM8UHJvcHM+ID0gKHsgZW5hYmxlZENvbGxlY3Rpb25TbHVncyB9KSA9PiB7XG4gIGNvbnN0IFtlZGl0b3JdID0gdXNlTGV4aWNhbENvbXBvc2VyQ29udGV4dCgpXG5cbiAgY29uc3QgW3JlcGxhY2VOb2RlS2V5LCBzZXRSZXBsYWNlTm9kZUtleV0gPSB1c2VTdGF0ZTxudWxsIHwgc3RyaW5nPihudWxsKVxuXG4gIGNvbnN0IFtMaXN0RHJhd2VyLCBMaXN0RHJhd2VyVG9nZ2xlciwgeyBjbG9zZURyYXdlciwgb3BlbkRyYXdlciB9XSA9IHVzZUxpc3REcmF3ZXIoe1xuICAgIGNvbGxlY3Rpb25TbHVnczogZW5hYmxlZENvbGxlY3Rpb25TbHVncyxcbiAgICB1cGxvYWRzOiB0cnVlLFxuICB9KVxuXG4gIHVzZUVmZmVjdCgoKSA9PiB7XG4gICAgcmV0dXJuIGVkaXRvci5yZWdpc3RlckNvbW1hbmQ8e1xuICAgICAgcmVwbGFjZTogeyBub2RlS2V5OiBzdHJpbmcgfSB8IGZhbHNlXG4gICAgfT4oXG4gICAgICBJTlNFUlRfVVBMT0FEX1dJVEhfRFJBV0VSX0NPTU1BTkQsXG4gICAgICAocGF5bG9hZCkgPT4ge1xuICAgICAgICBzZXRSZXBsYWNlTm9kZUtleShwYXlsb2FkPy5yZXBsYWNlID8gcGF5bG9hZD8ucmVwbGFjZS5ub2RlS2V5IDogbnVsbClcbiAgICAgICAgb3BlbkRyYXdlcigpXG4gICAgICAgIHJldHVybiB0cnVlXG4gICAgICB9LFxuICAgICAgQ09NTUFORF9QUklPUklUWV9FRElUT1IsXG4gICAgKVxuICB9LCBbZWRpdG9yLCBvcGVuRHJhd2VyXSlcblxuICBjb25zdCBvblNlbGVjdCA9IHVzZUNhbGxiYWNrKFxuICAgICh7IGNvbGxlY3Rpb25TbHVnLCBkb2NJRCB9KSA9PiB7XG4gICAgICBpbnNlcnRVcGxvYWQoe1xuICAgICAgICBpZDogZG9jSUQsXG4gICAgICAgIGVkaXRvcixcbiAgICAgICAgcmVsYXRpb25UbzogY29sbGVjdGlvblNsdWcsXG4gICAgICAgIHJlcGxhY2VOb2RlS2V5LFxuICAgICAgfSlcbiAgICAgIGNsb3NlRHJhd2VyKClcbiAgICB9LFxuICAgIFtlZGl0b3IsIGNsb3NlRHJhd2VyLCByZXBsYWNlTm9kZUtleV0sXG4gIClcblxuICByZXR1cm4gPExpc3REcmF3ZXIgb25TZWxlY3Q9e29uU2VsZWN0fSAvPlxufVxuXG5leHBvcnQgY29uc3QgVXBsb2FkRHJhd2VyID0gKHByb3BzOiBQcm9wcyk6IFJlYWN0LlJlYWN0Tm9kZSA9PiB7XG4gIHJldHVybiAoXG4gICAgPEVuYWJsZWRSZWxhdGlvbnNoaXBzQ29uZGl0aW9uIHsuLi5wcm9wc30gdXBsb2Fkcz5cbiAgICAgIDxVcGxvYWREcmF3ZXJDb21wb25lbnQgey4uLnByb3BzfSAvPlxuICAgIDwvRW5hYmxlZFJlbGF0aW9uc2hpcHNDb25kaXRpb24+XG4gIClcbn1cbiJdLCJuYW1lcyI6WyJ1c2VMZXhpY2FsQ29tcG9zZXJDb250ZXh0IiwidXNlTGlzdERyYXdlciIsIiRnZXROb2RlQnlLZXkiLCJDT01NQU5EX1BSSU9SSVRZX0VESVRPUiIsIlJlYWN0IiwidXNlQ2FsbGJhY2siLCJ1c2VFZmZlY3QiLCJ1c2VTdGF0ZSIsIkVuYWJsZWRSZWxhdGlvbnNoaXBzQ29uZGl0aW9uIiwiJGNyZWF0ZVVwbG9hZE5vZGUiLCJJTlNFUlRfVVBMT0FEX0NPTU1BTkQiLCJJTlNFUlRfVVBMT0FEX1dJVEhfRFJBV0VSX0NPTU1BTkQiLCJiYXNlQ2xhc3MiLCJpbnNlcnRVcGxvYWQiLCJpZCIsImVkaXRvciIsInJlbGF0aW9uVG8iLCJyZXBsYWNlTm9kZUtleSIsImRpc3BhdGNoQ29tbWFuZCIsImZpZWxkcyIsInVwZGF0ZSIsIm5vZGUiLCJyZXBsYWNlIiwiZGF0YSIsInZhbHVlIiwiVXBsb2FkRHJhd2VyQ29tcG9uZW50IiwiZW5hYmxlZENvbGxlY3Rpb25TbHVncyIsInNldFJlcGxhY2VOb2RlS2V5IiwiTGlzdERyYXdlciIsIkxpc3REcmF3ZXJUb2dnbGVyIiwiY2xvc2VEcmF3ZXIiLCJvcGVuRHJhd2VyIiwiY29sbGVjdGlvblNsdWdzIiwidXBsb2FkcyIsInJlZ2lzdGVyQ29tbWFuZCIsInBheWxvYWQiLCJub2RlS2V5Iiwib25TZWxlY3QiLCJjb2xsZWN0aW9uU2x1ZyIsImRvY0lEIiwiVXBsb2FkRHJhd2VyIiwicHJvcHMiXSwibWFwcGluZ3MiOiJBQUFBO0FBQ0EsU0FBU0EseUJBQXlCLFFBQVEsd0NBQXVDO0FBQ2pGLFNBQVNDLGFBQWEsUUFBUSxpQkFBZ0I7QUFDOUMsU0FBU0MsYUFBYSxFQUFFQyx1QkFBdUIsUUFBNEIsVUFBUztBQUNwRixPQUFPQyxTQUFTQyxXQUFXLEVBQUVDLFNBQVMsRUFBRUMsUUFBUSxRQUFRLFFBQU87QUFFL0QsU0FBU0MsNkJBQTZCLFFBQVEseURBQXdEO0FBQ3RHLFNBQVNDLGlCQUFpQixRQUFRLHNCQUFxQjtBQUN2RCxTQUFTQyxxQkFBcUIsUUFBUSxZQUFXO0FBQ2pELFNBQVNDLGlDQUFpQyxRQUFRLGFBQVk7QUFFOUQsTUFBTUMsWUFBWTtBQUVsQixNQUFNQyxlQUFlLENBQUMsRUFDcEJDLEVBQUUsRUFDRkMsTUFBTSxFQUNOQyxVQUFVLEVBQ1ZDLGNBQWMsRUFNZjtJQUNDLElBQUksQ0FBQ0EsZ0JBQWdCO1FBQ25CRixPQUFPRyxlQUFlLENBQUNSLHVCQUF1QjtZQUM1Q0k7WUFDQUssUUFBUTtZQUNSSDtRQUNGO0lBQ0YsT0FBTztRQUNMRCxPQUFPSyxNQUFNLENBQUM7WUFDWixNQUFNQyxPQUFPbkIsY0FBY2U7WUFDM0IsSUFBSUksTUFBTTtnQkFDUkEsS0FBS0MsT0FBTyxDQUNWYixrQkFBa0I7b0JBQ2hCYyxNQUFNO3dCQUNKSixRQUFRO3dCQUNSSDt3QkFDQVEsT0FBTzs0QkFDTFY7d0JBQ0Y7b0JBQ0Y7Z0JBQ0Y7WUFFSjtRQUNGO0lBQ0Y7QUFDRjtBQU1BLE1BQU1XLHdCQUF5QyxDQUFDLEVBQUVDLHNCQUFzQixFQUFFO0lBQ3hFLE1BQU0sQ0FBQ1gsT0FBTyxHQUFHZjtJQUVqQixNQUFNLENBQUNpQixnQkFBZ0JVLGtCQUFrQixHQUFHcEIsU0FBd0I7SUFFcEUsTUFBTSxDQUFDcUIsWUFBWUMsbUJBQW1CLEVBQUVDLFdBQVcsRUFBRUMsVUFBVSxFQUFFLENBQUMsR0FBRzlCLGNBQWM7UUFDakYrQixpQkFBaUJOO1FBQ2pCTyxTQUFTO0lBQ1g7SUFFQTNCLFVBQVU7UUFDUixPQUFPUyxPQUFPbUIsZUFBZSxDQUczQnZCLG1DQUNBLENBQUN3QjtZQUNDUixrQkFBa0JRLFNBQVNiLFVBQVVhLFNBQVNiLFFBQVFjLFVBQVU7WUFDaEVMO1lBQ0EsT0FBTztRQUNULEdBQ0E1QjtJQUVKLEdBQUc7UUFBQ1k7UUFBUWdCO0tBQVc7SUFFdkIsTUFBTU0sV0FBV2hDLFlBQ2YsQ0FBQyxFQUFFaUMsY0FBYyxFQUFFQyxLQUFLLEVBQUU7UUFDeEIxQixhQUFhO1lBQ1hDLElBQUl5QjtZQUNKeEI7WUFDQUMsWUFBWXNCO1lBQ1pyQjtRQUNGO1FBQ0FhO0lBQ0YsR0FDQTtRQUFDZjtRQUFRZTtRQUFhYjtLQUFlO0lBR3ZDLHFCQUFPLG9CQUFDVztRQUFXUyxVQUFVQTs7QUFDL0I7QUFFQSxPQUFPLE1BQU1HLGVBQWUsQ0FBQ0M7SUFDM0IscUJBQ0Usb0JBQUNqQztRQUErQixHQUFHaUMsS0FBSztRQUFFUixTQUFBQTtxQkFDeEMsb0JBQUNSLHVCQUEwQmdCO0FBR2pDLEVBQUMifQ==

package/dist/field/features/upload/feature.client.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+export type UploadFeaturePropsClient = {
+    collections: {
+        [collection: string]: {
+            hasExtraFields: boolean;
+        };
+    };
+};
+export declare const UploadFeatureClientComponent: import("react").FC<import("../types").ClientComponentProps<UploadFeaturePropsClient>>;
+//# sourceMappingURL=feature.client.d.ts.map

package/dist/field/features/upload/feature.client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature.client.d.ts","sourceRoot":"","sources":["../../../../src/field/features/upload/feature.client.tsx"],"names":[],"mappings":";AAWA,MAAM,MAAM,wBAAwB,GAAG;IACrC,WAAW,EAAE;QACX,CAAC,UAAU,EAAE,MAAM,GAAG;YACpB,cAAc,EAAE,OAAO,CAAA;SACxB,CAAA;KACF,CAAA;CACF,CAAA;AAsCD,eAAO,MAAM,4BAA4B,uFAA6C,CAAA"}

package/dist/field/features/upload/feature.client.js

@@ -0,0 +1,55 @@
+'use client';
+import { SlashMenuOption } from '../../lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/types';
+import { UploadIcon } from '../../lexical/ui/icons/Upload';
+import { createClientComponent } from '../createClientComponent';
+import { INSERT_UPLOAD_WITH_DRAWER_COMMAND } from './drawer/commands';
+import { UploadNode } from './nodes/UploadNode';
+import { UploadPlugin } from './plugin';
+const UploadFeatureClient = (props)=>{
+    return {
+        clientFeatureProps: props,
+        feature: ()=>({
+                clientFeatureProps: props,
+                nodes: [
+                    UploadNode
+                ],
+                plugins: [
+                    {
+                        Component: UploadPlugin,
+                        position: 'normal'
+                    }
+                ],
+                slashMenu: {
+                    options: [
+                        {
+                            displayName: 'Basic',
+                            key: 'basic',
+                            options: [
+                                new SlashMenuOption('upload', {
+                                    Icon: UploadIcon,
+                                    displayName: 'Upload',
+                                    keywords: [
+                                        'upload',
+                                        'image',
+                                        'file',
+                                        'img',
+                                        'picture',
+                                        'photo',
+                                        'media'
+                                    ],
+                                    onSelect: ({ editor })=>{
+                                        editor.dispatchCommand(INSERT_UPLOAD_WITH_DRAWER_COMMAND, {
+                                            replace: false
+                                        });
+                                    }
+                                })
+                            ]
+                        }
+                    ]
+                }
+            })
+    };
+};
+export const UploadFeatureClientComponent = createClientComponent(UploadFeatureClient);
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,12 @@
+import type { Field } from 'payload/types';
+import type { FeatureProviderProviderServer } from '../types';
+import type { UploadFeaturePropsClient } from './feature.client';
+export type UploadFeatureProps = {
+    collections: {
+        [collection: string]: {
+            fields: Field[];
+        };
+    };
+};
+export declare const UploadFeature: FeatureProviderProviderServer<UploadFeatureProps, UploadFeaturePropsClient>;
+//# sourceMappingURL=feature.server.d.ts.map

package/dist/field/features/upload/feature.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature.server.d.ts","sourceRoot":"","sources":["../../../../src/field/features/upload/feature.server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAW,MAAM,eAAe,CAAA;AAGnD,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,UAAU,CAAA;AAC7D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,kBAAkB,CAAA;AAOhE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,WAAW,EAAE;QACX,CAAC,UAAU,EAAE,MAAM,GAAG;YACpB,MAAM,EAAE,KAAK,EAAE,CAAA;SAChB,CAAA;KACF,CAAA;CACF,CAAA;AASD,eAAO,MAAM,aAAa,EAAE,6BAA6B,CACvD,kBAAkB,EAClB,wBAAwB,CA2GzB,CAAA"}