@payloadcms/richtext-lexical 0.1.0-beta.0

package/dist/field/features/Relationship/utils/EnabledRelationshipsCondition.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "EnabledRelationshipsCondition", {
+    enumerable: true,
+    get: function() {
+        return EnabledRelationshipsCondition;
+    }
+});
+const _utilities = require("payload/components/utilities");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const filterRichTextCollections = (collections, options)=>{
+    return collections.filter(({ admin: { enableRichTextRelationship }, upload })=>{
+        if (options?.uploads) {
+            return enableRichTextRelationship && Boolean(upload) === true;
+        }
+        return upload ? false : enableRichTextRelationship;
+    });
+};
+const EnabledRelationshipsCondition = (props)=>{
+    const { children, uploads = false, ...rest } = props;
+    const { collections } = (0, _utilities.useConfig)();
+    const [enabledCollectionSlugs] = _react.useState(()=>filterRichTextCollections(collections, {
+            uploads
+        }).map(({ slug })=>slug));
+    if (!enabledCollectionSlugs.length) {
+        return null;
+    }
+    return /*#__PURE__*/ _react.cloneElement(children, {
+        ...rest,
+        enabledCollectionSlugs
+    });
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/field/features/Upload/afterReadPromise.d.ts

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

package/dist/field/features/Upload/afterReadPromise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"afterReadPromise.d.ts","sourceRoot":"","sources":["../../../../src/field/features/Upload/afterReadPromise.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,GAAG,CAAA;AAC3C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAChD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAA;AAK9D,eAAO,MAAM,yBAAyB,WAC5B,kBAAkB,KACzB,iBAAiB,oBAAoB,CAmDvC,CAAA"}

package/dist/field/features/Upload/afterReadPromise.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "uploadAfterReadPromiseHOC", {
+    enumerable: true,
+    get: function() {
+        return uploadAfterReadPromiseHOC;
+    }
+});
+const _populate = require("../../../populate/populate");
+const _recurseNestedFields = require("../../../populate/recurseNestedFields");
+const uploadAfterReadPromiseHOC = (props)=>{
+    const uploadAfterReadPromise = ({ afterReadPromises, currentDepth, depth, field, node, overrideAccess, req, showHiddenFields })=>{
+        const promises = [];
+        if (node?.fields?.value?.id) {
+            const collection = req.payload.collections[node?.fields?.relationTo];
+            if (collection) {
+                promises.push((0, _populate.populate)({
+                    id: node?.fields?.value?.id,
+                    collection,
+                    currentDepth,
+                    data: node.fields,
+                    depth,
+                    field,
+                    key: 'value',
+                    overrideAccess,
+                    req,
+                    showHiddenFields
+                }));
+            }
+            if (Array.isArray(props?.collections?.[node?.fields?.relationTo]?.fields)) {
+                (0, _recurseNestedFields.recurseNestedFields)({
+                    afterReadPromises,
+                    currentDepth,
+                    data: node.fields || {},
+                    depth,
+                    fields: props?.collections?.[node?.fields?.relationTo]?.fields,
+                    overrideAccess,
+                    promises,
+                    req,
+                    showHiddenFields
+                });
+            }
+        }
+        return promises;
+    };
+    return uploadAfterReadPromise;
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/field/features/Upload/component/ExtraFieldsDrawer/index.d.ts

@@ -0,0 +1,12 @@
+import type { SanitizedCollectionConfig } from 'payload/types';
+import React from 'react';
+import type { ElementProps } from '..';
+/**
+ * This handles the extra fields, e.g. captions or alt text, which are
+ * potentially added to the upload feature.
+ */
+export declare const ExtraFieldsUploadDrawer: React.FC<ElementProps & {
+    drawerSlug: string;
+    relatedCollection: SanitizedCollectionConfig;
+}>;
+//# sourceMappingURL=index.d.ts.map

package/dist/field/features/Upload/component/ExtraFieldsDrawer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/field/features/Upload/component/ExtraFieldsDrawer/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,eAAe,CAAA;AAe9D,OAAO,KAA2C,MAAM,OAAO,CAAA;AAG/D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,IAAI,CAAA;AAMtC;;;GAGG;AACH,eAAO,MAAM,uBAAuB,EAAE,KAAK,CAAC,EAAE,CAC5C,YAAY,GAAG;IACb,UAAU,EAAE,MAAM,CAAA;IAClB,iBAAiB,EAAE,yBAAyB,CAAA;CAC7C,CAwEF,CAAA"}

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

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ExtraFieldsUploadDrawer", {
+    enumerable: true,
+    get: function() {
+        return ExtraFieldsUploadDrawer;
+    }
+});
+const _modal = require("@faceless-ui/modal");
+const _LexicalComposerContext = require("@lexical/react/LexicalComposerContext");
+const _lexical = require("lexical");
+const _elements = require("payload/components/elements");
+const _forms = require("payload/components/forms");
+const _utilities = require("payload/components/utilities");
+const _config = require("payload/config");
+const _utilities1 = require("payload/utilities");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _reacti18next = require("react-i18next");
+const _EditorConfigProvider = require("../../../../lexical/config/EditorConfigProvider");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const ExtraFieldsUploadDrawer = (props)=>{
+    const { drawerSlug, fields: { relationTo, value }, fields, nodeKey, relatedCollection } = props;
+    const [editor] = (0, _LexicalComposerContext.useLexicalComposerContext)();
+    const { editorConfig, field } = (0, _EditorConfigProvider.useEditorConfigContext)();
+    const { i18n, t } = (0, _reacti18next.useTranslation)();
+    const { code: locale } = (0, _utilities.useLocale)();
+    const { user } = (0, _utilities.useAuth)();
+    const { closeModal } = (0, _modal.useModal)();
+    const { getDocPreferences } = (0, _utilities.useDocumentInfo)();
+    const [initialState, setInitialState] = (0, _react.useState)({});
+    const fieldSchema = (editorConfig?.resolvedFeatureMap.get('upload')?.props)?.collections?.[relatedCollection.slug]?.fields;
+    const handleUpdateEditData = (0, _react.useCallback)((_, data)=>{
+        // Update lexical node (with key nodeKey) with new data
+        editor.update(()=>{
+            const uploadNode = (0, _lexical.$getNodeByKey)(nodeKey);
+            if (uploadNode) {
+                const newFields = {
+                    ...uploadNode.getFields(),
+                    ...data
+                };
+                uploadNode.setFields(newFields);
+            }
+        });
+        closeModal(drawerSlug);
+    }, [
+        closeModal,
+        editor,
+        drawerSlug,
+        nodeKey
+    ]);
+    (0, _react.useEffect)(()=>{
+        const awaitInitialState = async ()=>{
+            const preferences = await getDocPreferences();
+            const state = await (0, _utilities.buildStateFromSchema)({
+                data: (0, _utilities1.deepCopyObject)(fields || {}),
+                fieldSchema,
+                locale,
+                operation: 'update',
+                preferences,
+                t,
+                user
+            });
+            setInitialState(state);
+        };
+        void awaitInitialState();
+    }, [
+        user,
+        locale,
+        t,
+        getDocPreferences,
+        fields,
+        fieldSchema
+    ]);
+    return /*#__PURE__*/ _react.default.createElement(_elements.Drawer, {
+        slug: drawerSlug,
+        title: t('general:editLabel', {
+            label: (0, _utilities1.getTranslation)(relatedCollection.labels.singular, i18n)
+        })
+    }, /*#__PURE__*/ _react.default.createElement(_forms.Form, {
+        initialState: initialState,
+        onSubmit: handleUpdateEditData
+    }, /*#__PURE__*/ _react.default.createElement(_forms.RenderFields, {
+        fieldSchema: fieldSchema,
+        fieldTypes: _config.fieldTypes,
+        readOnly: false
+    }), /*#__PURE__*/ _react.default.createElement(_forms.FormSubmit, null, t('fields:saveChanges'))));
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/field/features/Upload/component/index.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { UploadFields } from '../nodes/UploadNode';
+import './index.scss';
+export type ElementProps = {
+    fields: UploadFields;
+    nodeKey: string;
+};
+declare const _default: (props: ElementProps) => React.ReactNode;
+export default _default;
+//# sourceMappingURL=index.d.ts.map

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":"AAWA,OAAO,KAA4C,MAAM,OAAO,CAAA;AAIhE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAMvD,OAAO,cAAc,CAAA;AAQrB,MAAM,MAAM,YAAY,GAAG;IACzB,MAAM,EAAE,YAAY,CAAA;IACpB,OAAO,EAAE,MAAM,CAAA;CAEhB,CAAA;gCA4IsB,YAAY,KAAG,MAAM,SAAS;AAArD,wBAMC"}

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

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _LexicalComposerContext = require("@lexical/react/LexicalComposerContext");
+const _useLexicalNodeSelection = require("@lexical/react/useLexicalNodeSelection");
+const _lexical = require("lexical");
+const _components = require("payload/components");
+const _elements = require("payload/components/elements");
+const _graphics = require("payload/components/graphics");
+const _hooks = require("payload/components/hooks");
+const _utilities = require("payload/components/utilities");
+const _utilities1 = require("payload/utilities");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _reacti18next = require("react-i18next");
+const _EditorConfigProvider = require("../../../lexical/config/EditorConfigProvider");
+const _EnabledRelationshipsCondition = require("../../Relationship/utils/EnabledRelationshipsCondition");
+const _drawer = require("../drawer");
+const _ExtraFieldsDrawer = require("./ExtraFieldsDrawer");
+require("./index.scss");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const baseClass = 'lexical-upload';
+const initialParams = {
+    depth: 0
+};
+const Component = (props)=>{
+    const { fields: { relationTo, value }, nodeKey } = props;
+    const { collections, routes: { api }, serverURL } = (0, _utilities.useConfig)();
+    const [editor] = (0, _LexicalComposerContext.useLexicalComposerContext)();
+    const [isSelected, setSelected, clearSelection] = (0, _useLexicalNodeSelection.useLexicalNodeSelection)(nodeKey);
+    const { editorConfig, field } = (0, _EditorConfigProvider.useEditorConfigContext)();
+    const { i18n, t } = (0, _reacti18next.useTranslation)('fields');
+    const [cacheBust, dispatchCacheBust] = (0, _react.useReducer)((state)=>state + 1, 0);
+    const [relatedCollection, setRelatedCollection] = (0, _react.useState)(()=>collections.find((coll)=>coll.slug === relationTo));
+    const drawerSlug = (0, _elements.useDrawerSlug)('upload-drawer');
+    const [DocumentDrawer, DocumentDrawerToggler, { closeDrawer }] = (0, _elements.useDocumentDrawer)({
+        id: value?.id,
+        collectionSlug: relatedCollection.slug
+    });
+    // Get the referenced document
+    const [{ data }, { setParams }] = (0, _hooks.usePayloadAPI)(`${serverURL}${api}/${relatedCollection.slug}/${value?.id}`, {
+        initialParams
+    });
+    const thumbnailSRC = (0, _hooks.useThumbnail)(relatedCollection, data);
+    const removeUpload = (0, _react.useCallback)(()=>{
+        editor.update(()=>{
+            (0, _lexical.$getNodeByKey)(nodeKey).remove();
+        });
+    }, [
+        editor,
+        nodeKey
+    ]);
+    const updateUpload = (0, _react.useCallback)((json)=>{
+        setParams({
+            ...initialParams,
+            cacheBust
+        });
+        dispatchCacheBust();
+        closeDrawer();
+    }, [
+        setParams,
+        cacheBust,
+        closeDrawer
+    ]);
+    const customFields = (editorConfig?.resolvedFeatureMap?.get('upload')?.props)?.collections?.[relatedCollection.slug]?.fields;
+    return /*#__PURE__*/ _react.default.createElement("div", {
+        className: [
+            baseClass,
+            isSelected && `${baseClass}--selected`
+        ].filter(Boolean).join(' '),
+        contentEditable: false
+    }, /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__card`
+    }, /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__topRow`
+    }, /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__thumbnail`
+    }, thumbnailSRC ? /*#__PURE__*/ _react.default.createElement("img", {
+        alt: data?.filename,
+        src: thumbnailSRC
+    }) : /*#__PURE__*/ _react.default.createElement(_graphics.FileGraphic, null)), /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__topRowRightPanel`
+    }, /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__collectionLabel`
+    }, (0, _utilities1.getTranslation)(relatedCollection.labels.singular, i18n)), /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__actions`
+    }, customFields?.length > 0 && /*#__PURE__*/ _react.default.createElement(_elements.DrawerToggler, {
+        className: `${baseClass}__upload-drawer-toggler`,
+        disabled: field?.admin?.readOnly,
+        slug: drawerSlug
+    }, /*#__PURE__*/ _react.default.createElement(_components.Button, {
+        buttonStyle: "icon-label",
+        el: "div",
+        icon: "edit",
+        onClick: (e)=>{
+            e.preventDefault();
+        },
+        round: true,
+        tooltip: t('fields:editRelationship')
+    })), /*#__PURE__*/ _react.default.createElement(_components.Button, {
+        buttonStyle: "icon-label",
+        disabled: field?.admin?.readOnly,
+        el: "div",
+        icon: "swap",
+        onClick: ()=>{
+            editor.dispatchCommand(_drawer.INSERT_UPLOAD_WITH_DRAWER_COMMAND, {
+                replace: {
+                    nodeKey
+                }
+            });
+        },
+        round: true,
+        tooltip: t('swapUpload')
+    }), /*#__PURE__*/ _react.default.createElement(_components.Button, {
+        buttonStyle: "icon-label",
+        className: `${baseClass}__removeButton`,
+        disabled: field?.admin?.readOnly,
+        icon: "x",
+        onClick: (e)=>{
+            e.preventDefault();
+            removeUpload();
+        },
+        round: true,
+        tooltip: t('removeUpload')
+    })))), /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__bottomRow`
+    }, /*#__PURE__*/ _react.default.createElement(DocumentDrawerToggler, {
+        className: `${baseClass}__doc-drawer-toggler`
+    }, /*#__PURE__*/ _react.default.createElement("strong", null, data?.filename)))), value?.id && /*#__PURE__*/ _react.default.createElement(DocumentDrawer, {
+        onSave: updateUpload
+    }), /*#__PURE__*/ _react.default.createElement(_ExtraFieldsDrawer.ExtraFieldsUploadDrawer, {
+        drawerSlug: drawerSlug,
+        relatedCollection: relatedCollection,
+        ...props
+    }));
+};
+const _default = (props)=>{
+    return /*#__PURE__*/ _react.default.createElement(_EnabledRelationshipsCondition.EnabledRelationshipsCondition, {
+        ...props,
+        uploads: true
+    }, /*#__PURE__*/ _react.default.createElement(Component, props));
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../src/field/features/Upload/component/index.tsx"],"sourcesContent":["import type { SanitizedCollectionConfig } from 'payload/types'\n\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext'\nimport { useLexicalNodeSelection } from '@lexical/react/useLexicalNodeSelection'\nimport { $getNodeByKey } from 'lexical'\nimport { Button } from 'payload/components'\nimport { DrawerToggler, useDocumentDrawer, useDrawerSlug } from 'payload/components/elements'\nimport { FileGraphic } from 'payload/components/graphics'\nimport { usePayloadAPI, useThumbnail } from 'payload/components/hooks'\nimport { useConfig } from 'payload/components/utilities'\nimport { getTranslation } from 'payload/utilities'\nimport React, { useCallback, useReducer, useState } from 'react'\nimport { useTranslation } from 'react-i18next'\n\nimport type { UploadFeatureProps } from '..'\nimport type { UploadFields } from '../nodes/UploadNode'\n\nimport { useEditorConfigContext } from '../../../lexical/config/EditorConfigProvider'\nimport { EnabledRelationshipsCondition } from '../../Relationship/utils/EnabledRelationshipsCondition'\nimport { INSERT_UPLOAD_WITH_DRAWER_COMMAND } from '../drawer'\nimport { ExtraFieldsUploadDrawer } from './ExtraFieldsDrawer'\nimport './index.scss'\n\nconst baseClass = 'lexical-upload'\n\nconst initialParams = {\n  depth: 0,\n}\n\nexport type ElementProps = {\n  fields: UploadFields\n  nodeKey: string\n  //uploadProps: UploadFeatureProps\n}\n\nconst Component: React.FC<ElementProps> = (props) => {\n  const {\n    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('fields')\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, 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 customFields = (\n    editorConfig?.resolvedFeatureMap?.get('upload')?.props as UploadFeatureProps\n  )?.collections?.[relatedCollection.slug]?.fields\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            <div className={`${baseClass}__actions`}>\n              {customFields?.length > 0 && (\n                <DrawerToggler\n                  className={`${baseClass}__upload-drawer-toggler`}\n                  disabled={field?.admin?.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              )}\n\n              <Button\n                buttonStyle=\"icon-label\"\n                disabled={field?.admin?.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('swapUpload')}\n              />\n              <Button\n                buttonStyle=\"icon-label\"\n                className={`${baseClass}__removeButton`}\n                disabled={field?.admin?.readOnly}\n                icon=\"x\"\n                onClick={(e) => {\n                  e.preventDefault()\n                  removeUpload()\n                }}\n                round\n                tooltip={t('removeUpload')}\n              />\n            </div>\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":["baseClass","initialParams","depth","Component","props","fields","relationTo","value","nodeKey","collections","routes","api","serverURL","useConfig","editor","useLexicalComposerContext","isSelected","setSelected","clearSelection","useLexicalNodeSelection","editorConfig","field","useEditorConfigContext","i18n","t","useTranslation","cacheBust","dispatchCacheBust","useReducer","state","relatedCollection","setRelatedCollection","useState","find","coll","slug","drawerSlug","useDrawerSlug","DocumentDrawer","DocumentDrawerToggler","closeDrawer","useDocumentDrawer","id","collectionSlug","data","setParams","usePayloadAPI","thumbnailSRC","useThumbnail","removeUpload","useCallback","update","$getNodeByKey","remove","updateUpload","json","customFields","resolvedFeatureMap","get","div","className","filter","Boolean","join","contentEditable","img","alt","filename","src","FileGraphic","getTranslation","labels","singular","length","DrawerToggler","disabled","admin","readOnly","Button","buttonStyle","el","icon","onClick","e","preventDefault","round","tooltip","dispatchCommand","INSERT_UPLOAD_WITH_DRAWER_COMMAND","replace","strong","onSave","ExtraFieldsUploadDrawer","EnabledRelationshipsCondition","uploads"],"mappings":"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"}

package/dist/field/features/Upload/drawer/index.d.ts

@@ -0,0 +1,14 @@
+import { type LexicalCommand } from 'lexical';
+import React from 'react';
+import './index.scss';
+export declare const INSERT_UPLOAD_WITH_DRAWER_COMMAND: LexicalCommand<{
+    replace: {
+        nodeKey: string;
+    } | false;
+}>;
+type Props = {
+    enabledCollectionSlugs: string[];
+};
+export declare const UploadDrawer: (props: Props) => React.ReactNode;
+export {};
+//# sourceMappingURL=index.d.ts.map

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":"AACA,OAAO,EAGL,KAAK,cAAc,EAGpB,MAAM,SAAS,CAAA;AAEhB,OAAO,KAA2C,MAAM,OAAO,CAAA;AAK/D,OAAO,cAAc,CAAA;AAIrB,eAAO,MAAM,iCAAiC,EAAE,cAAc,CAAC;IAC7D,OAAO,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,GAAG,KAAK,CAAA;CACrC,CAAsD,CAAA;AAqCvD,KAAK,KAAK,GAAG;IACX,sBAAsB,EAAE,MAAM,EAAE,CAAA;CACjC,CAAA;AA0CD,eAAO,MAAM,YAAY,UAAW,KAAK,KAAG,MAAM,SAMjD,CAAA"}