@payloadcms/richtext-slate 1.0.0-beta.0

package/dist/field/elements/unwrapList.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "unwrapList", {
+    enumerable: true,
+    get: function() {
+        return unwrapList;
+    }
+});
+const _slate = require("slate");
+const _areAllChildrenElements = require("./areAllChildrenElements");
+const _listTypes = /*#__PURE__*/ _interop_require_default(require("./listTypes"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const unwrapList = (editor, atPath)=>{
+    // Remove type for any nodes that have text children -
+    // this means that the node should remain
+    _slate.Transforms.setNodes(editor, {
+        type: undefined
+    }, {
+        at: atPath,
+        match: (node, path)=>{
+            const childrenAreAllElements = (0, _areAllChildrenElements.areAllChildrenElements)(node);
+            const matches = !_slate.Editor.isEditor(node) && _slate.Element.isElement(node) && !childrenAreAllElements && node.type === 'li' && path.length === atPath.length + 1;
+            return matches;
+        }
+    });
+    // For nodes have all element children, unwrap it instead
+    // because the li is a duplicative wrapper
+    _slate.Transforms.unwrapNodes(editor, {
+        at: atPath,
+        match: (node, path)=>{
+            const childrenAreAllElements = (0, _areAllChildrenElements.areAllChildrenElements)(node);
+            const matches = !_slate.Editor.isEditor(node) && _slate.Element.isElement(node) && childrenAreAllElements && node.type === 'li' && path.length === atPath.length + 1;
+            return matches;
+        }
+    });
+    // Finally, unwrap the UL itself
+    _slate.Transforms.unwrapNodes(editor, {
+        match: (n)=>_slate.Element.isElement(n) && _listTypes.default.includes(n.type),
+        mode: 'lowest'
+    });
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/field/elements/upload/Button/index.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import './index.scss';
+type ButtonProps = {
+    enabledCollectionSlugs: string[];
+    path: string;
+};
+declare const _default: (props: ButtonProps) => React.ReactNode;
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/field/elements/upload/Button/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/elements/upload/Button/index.tsx"],"names":[],"mappings":"AACA,OAAO,KAAgC,MAAM,OAAO,CAAA;AAQpD,OAAO,cAAc,CAAA;AAmBrB,KAAK,WAAW,GAAG;IACjB,sBAAsB,EAAE,MAAM,EAAE,CAAA;IAChC,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;gCA4CsB,WAAW,KAAG,MAAM,SAAS;AAApD,wBAMC"}

package/dist/field/elements/upload/Button/index.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _elements = require("payload/components/elements");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _reacti18next = require("react-i18next");
+const _slatereact = require("slate-react");
+const _Upload = /*#__PURE__*/ _interop_require_default(require("../../../icons/Upload"));
+const _Button = /*#__PURE__*/ _interop_require_default(require("../../Button"));
+const _EnabledRelationshipsCondition = require("../../EnabledRelationshipsCondition");
+const _injectVoid = require("../../injectVoid");
+require("./index.scss");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+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 = 'upload-rich-text-button';
+const insertUpload = (editor, { relationTo, value })=>{
+    const text = {
+        text: ' '
+    };
+    const upload = {
+        children: [
+            text
+        ],
+        relationTo,
+        type: 'upload',
+        value
+    };
+    (0, _injectVoid.injectVoidElement)(editor, upload);
+    _slatereact.ReactEditor.focus(editor);
+};
+const UploadButton = ({ enabledCollectionSlugs })=>{
+    const { t } = (0, _reacti18next.useTranslation)([
+        'upload',
+        'general'
+    ]);
+    const editor = (0, _slatereact.useSlate)();
+    const [ListDrawer, ListDrawerToggler, { closeDrawer }] = (0, _elements.useListDrawer)({
+        collectionSlugs: enabledCollectionSlugs,
+        uploads: true
+    });
+    const onSelect = (0, _react.useCallback)(({ collectionConfig, docID })=>{
+        insertUpload(editor, {
+            relationTo: collectionConfig.slug,
+            value: {
+                id: docID
+            }
+        });
+        closeDrawer();
+    }, [
+        editor,
+        closeDrawer
+    ]);
+    return /*#__PURE__*/ _react.default.createElement(_react.Fragment, null, /*#__PURE__*/ _react.default.createElement(ListDrawerToggler, null, /*#__PURE__*/ _react.default.createElement(_Button.default, {
+        className: baseClass,
+        el: "div",
+        format: "upload",
+        onClick: ()=>{
+        // do nothing
+        },
+        tooltip: t('fields:addUpload')
+    }, /*#__PURE__*/ _react.default.createElement(_Upload.default, null))), /*#__PURE__*/ _react.default.createElement(ListDrawer, {
+        onSelect: onSelect
+    }));
+};
+const _default = (props)=>{
+    return /*#__PURE__*/ _react.default.createElement(_EnabledRelationshipsCondition.EnabledRelationshipsCondition, {
+        ...props,
+        uploads: true
+    }, /*#__PURE__*/ _react.default.createElement(UploadButton, props));
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/field/elements/upload/Element/UploadDrawer/index.d.ts

@@ -0,0 +1,8 @@
+import type { SanitizedCollectionConfig } from 'payload/types';
+import React from 'react';
+import type { ElementProps } from '..';
+export declare const UploadDrawer: React.FC<ElementProps & {
+    drawerSlug: string;
+    relatedCollection: SanitizedCollectionConfig;
+}>;
+//# sourceMappingURL=index.d.ts.map

package/dist/field/elements/upload/Element/UploadDrawer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/field/elements/upload/Element/UploadDrawer/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,eAAe,CAAA;AAa9D,OAAO,KAA2C,MAAM,OAAO,CAAA;AAK/D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,IAAI,CAAA;AAEtC,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CACjC,YAAY,GAAG;IACb,UAAU,EAAE,MAAM,CAAA;IAClB,iBAAiB,EAAE,yBAAyB,CAAA;CAC7C,CA2DF,CAAA"}

package/dist/field/elements/upload/Element/UploadDrawer/index.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "UploadDrawer", {
+    enumerable: true,
+    get: function() {
+        return UploadDrawer;
+    }
+});
+const _modal = require("@faceless-ui/modal");
+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 _slate = require("slate");
+const _slatereact = require("slate-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 UploadDrawer = (props)=>{
+    const editor = (0, _slatereact.useSlateStatic)();
+    const { drawerSlug, element, fieldProps, relatedCollection } = props;
+    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 = fieldProps?.admin?.upload?.collections?.[relatedCollection.slug]?.fields;
+    const handleUpdateEditData = (0, _react.useCallback)((_, data)=>{
+        const newNode = {
+            fields: data
+        };
+        const elementPath = _slatereact.ReactEditor.findPath(editor, element);
+        _slate.Transforms.setNodes(editor, newNode, {
+            at: elementPath
+        });
+        closeModal(drawerSlug);
+    }, [
+        closeModal,
+        editor,
+        element,
+        drawerSlug
+    ]);
+    (0, _react.useEffect)(()=>{
+        const awaitInitialState = async ()=>{
+            const preferences = await getDocPreferences();
+            const state = await (0, _utilities.buildStateFromSchema)({
+                data: (0, _utilities1.deepCopyObject)(element?.fields || {}),
+                fieldSchema,
+                locale,
+                operation: 'update',
+                preferences,
+                t,
+                user
+            });
+            setInitialState(state);
+        };
+        awaitInitialState();
+    }, [
+        fieldSchema,
+        element.fields,
+        user,
+        locale,
+        t,
+        getDocPreferences
+    ]);
+    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/elements/upload/Element/index.d.ts

@@ -0,0 +1,14 @@
+import type { HTMLAttributes } from 'react';
+import React from 'react';
+import type { FieldProps } from '../../../../types';
+import './index.scss';
+export type ElementProps = {
+    attributes: HTMLAttributes<HTMLDivElement>;
+    children: React.ReactNode;
+    element: any;
+    enabledCollectionSlugs: string[];
+    fieldProps: FieldProps;
+};
+declare const _default: (props: ElementProps) => React.ReactNode;
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/field/elements/upload/Element/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/elements/upload/Element/index.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAA;AAa3C,OAAO,KAA4C,MAAM,OAAO,CAAA;AAKhE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAInD,OAAO,cAAc,CAAA;AAQrB,MAAM,MAAM,YAAY,GAAG;IACzB,UAAU,EAAE,cAAc,CAAC,cAAc,CAAC,CAAA;IAC1C,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;IACzB,OAAO,EAAE,GAAG,CAAA;IACZ,sBAAsB,EAAE,MAAM,EAAE,CAAA;IAChC,UAAU,EAAE,UAAU,CAAA;CACvB,CAAA;gCAsLsB,YAAY,KAAG,MAAM,SAAS;AAArD,wBAMC"}

package/dist/field/elements/upload/Element/index.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+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 _slate = require("slate");
+const _slatereact = require("slate-react");
+const _EnabledRelationshipsCondition = require("../../EnabledRelationshipsCondition");
+const _UploadDrawer = require("./UploadDrawer");
+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 = 'rich-text-upload';
+const initialParams = {
+    depth: 0
+};
+const Element = (props)=>{
+    const { attributes, children, element: { relationTo, value }, element, enabledCollectionSlugs, fieldProps } = props;
+    const { collections, routes: { api }, serverURL } = (0, _utilities.useConfig)();
+    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 [ListDrawer, ListDrawerToggler, { closeDrawer: closeListDrawer }] = (0, _elements.useListDrawer)({
+        collectionSlugs: enabledCollectionSlugs,
+        selectedCollection: relatedCollection.slug
+    });
+    const [DocumentDrawer, DocumentDrawerToggler, { closeDrawer }] = (0, _elements.useDocumentDrawer)({
+        id: value?.id,
+        collectionSlug: relatedCollection.slug
+    });
+    const editor = (0, _slatereact.useSlateStatic)();
+    const selected = (0, _slatereact.useSelected)();
+    const focused = (0, _slatereact.useFocused)();
+    // 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)(()=>{
+        const elementPath = _slatereact.ReactEditor.findPath(editor, element);
+        _slate.Transforms.removeNodes(editor, {
+            at: elementPath
+        });
+    }, [
+        editor,
+        element
+    ]);
+    const updateUpload = (0, _react.useCallback)((json)=>{
+        const { doc } = json;
+        const newNode = {
+            fields: doc
+        };
+        const elementPath = _slatereact.ReactEditor.findPath(editor, element);
+        _slate.Transforms.setNodes(editor, newNode, {
+            at: elementPath
+        });
+        // setRelatedCollection(collections.find((coll) => coll.slug === collectionConfig.slug));
+        setParams({
+            ...initialParams,
+            cacheBust
+        });
+        dispatchCacheBust();
+        closeDrawer();
+    }, [
+        editor,
+        element,
+        setParams,
+        cacheBust,
+        closeDrawer
+    ]);
+    const swapUpload = _react.default.useCallback(({ collectionConfig, docID })=>{
+        const newNode = {
+            children: [
+                {
+                    text: ' '
+                }
+            ],
+            relationTo: collectionConfig.slug,
+            type: 'upload',
+            value: {
+                id: docID
+            }
+        };
+        const elementPath = _slatereact.ReactEditor.findPath(editor, element);
+        setRelatedCollection(collections.find((coll)=>coll.slug === collectionConfig.slug));
+        _slate.Transforms.setNodes(editor, newNode, {
+            at: elementPath
+        });
+        dispatchCacheBust();
+        closeListDrawer();
+    }, [
+        closeListDrawer,
+        editor,
+        element,
+        collections
+    ]);
+    const customFields = fieldProps?.admin?.upload?.collections?.[relatedCollection.slug]?.fields;
+    return /*#__PURE__*/ _react.default.createElement("div", {
+        className: [
+            baseClass,
+            selected && focused && `${baseClass}--selected`
+        ].filter(Boolean).join(' '),
+        contentEditable: false,
+        ...attributes
+    }, /*#__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: fieldProps?.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(ListDrawerToggler, {
+        className: `${baseClass}__list-drawer-toggler`,
+        disabled: fieldProps?.admin?.readOnly
+    }, /*#__PURE__*/ _react.default.createElement(_components.Button, {
+        buttonStyle: "icon-label",
+        disabled: fieldProps?.admin?.readOnly,
+        el: "div",
+        icon: "swap",
+        onClick: ()=>{
+        // do nothing
+        },
+        round: true,
+        tooltip: t('swapUpload')
+    })), /*#__PURE__*/ _react.default.createElement(_components.Button, {
+        buttonStyle: "icon-label",
+        className: `${baseClass}__removeButton`,
+        disabled: fieldProps?.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)))), children, value?.id && /*#__PURE__*/ _react.default.createElement(DocumentDrawer, {
+        onSave: updateUpload
+    }), /*#__PURE__*/ _react.default.createElement(ListDrawer, {
+        onSelect: swapUpload
+    }), /*#__PURE__*/ _react.default.createElement(_UploadDrawer.UploadDrawer, {
+        drawerSlug: drawerSlug,
+        relatedCollection: relatedCollection,
+        ...props
+    }));
+};
+const _default = (props)=>{
+    return /*#__PURE__*/ _react.default.createElement(_EnabledRelationshipsCondition.EnabledRelationshipsCondition, {
+        ...props,
+        uploads: true
+    }, /*#__PURE__*/ _react.default.createElement(Element, props));
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../src/field/elements/upload/Element/index.tsx"],"sourcesContent":["import type { SanitizedCollectionConfig } from 'payload/types'\nimport type { HTMLAttributes } from 'react'\n\nimport { Button } from 'payload/components'\nimport {\n  DrawerToggler,\n  useDocumentDrawer,\n  useDrawerSlug,\n  useListDrawer,\n} 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'\nimport { Transforms } from 'slate'\nimport { ReactEditor, useFocused, useSelected, useSlateStatic } from 'slate-react'\n\nimport type { FieldProps } from '../../../../types'\n\nimport { EnabledRelationshipsCondition } from '../../EnabledRelationshipsCondition'\nimport { UploadDrawer } from './UploadDrawer'\nimport './index.scss'\n\nconst baseClass = 'rich-text-upload'\n\nconst initialParams = {\n  depth: 0,\n}\n\nexport type ElementProps = {\n  attributes: HTMLAttributes<HTMLDivElement>\n  children: React.ReactNode\n  element: any\n  enabledCollectionSlugs: string[]\n  fieldProps: FieldProps\n}\n\nconst Element: React.FC<ElementProps> = (props) => {\n  const {\n    attributes,\n    children,\n    element: { relationTo, value },\n    element,\n    enabledCollectionSlugs,\n    fieldProps,\n  } = props\n\n  const {\n    collections,\n    routes: { api },\n    serverURL,\n  } = useConfig()\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 [ListDrawer, ListDrawerToggler, { closeDrawer: closeListDrawer }] = useListDrawer({\n    collectionSlugs: enabledCollectionSlugs,\n    selectedCollection: relatedCollection.slug,\n  })\n\n  const [DocumentDrawer, DocumentDrawerToggler, { closeDrawer }] = useDocumentDrawer({\n    id: value?.id,\n    collectionSlug: relatedCollection.slug,\n  })\n\n  const editor = useSlateStatic()\n  const selected = useSelected()\n  const focused = useFocused()\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    const elementPath = ReactEditor.findPath(editor, element)\n\n    Transforms.removeNodes(editor, { at: elementPath })\n  }, [editor, element])\n\n  const updateUpload = useCallback(\n    (json) => {\n      const { doc } = json\n\n      const newNode = {\n        fields: doc,\n      }\n\n      const elementPath = ReactEditor.findPath(editor, element)\n\n      Transforms.setNodes(editor, newNode, { at: elementPath })\n\n      // setRelatedCollection(collections.find((coll) => coll.slug === collectionConfig.slug));\n\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    [editor, element, setParams, cacheBust, closeDrawer],\n  )\n\n  const swapUpload = React.useCallback(\n    ({ collectionConfig, docID }) => {\n      const newNode = {\n        children: [{ text: ' ' }],\n        relationTo: collectionConfig.slug,\n        type: 'upload',\n        value: { id: docID },\n      }\n\n      const elementPath = ReactEditor.findPath(editor, element)\n\n      setRelatedCollection(collections.find((coll) => coll.slug === collectionConfig.slug))\n\n      Transforms.setNodes(editor, newNode, { at: elementPath })\n\n      dispatchCacheBust()\n      closeListDrawer()\n    },\n    [closeListDrawer, editor, element, collections],\n  )\n\n  const customFields = fieldProps?.admin?.upload?.collections?.[relatedCollection.slug]?.fields\n\n  return (\n    <div\n      className={[baseClass, selected && focused && `${baseClass}--selected`]\n        .filter(Boolean)\n        .join(' ')}\n      contentEditable={false}\n      {...attributes}\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={fieldProps?.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              <ListDrawerToggler\n                className={`${baseClass}__list-drawer-toggler`}\n                disabled={fieldProps?.admin?.readOnly}\n              >\n                <Button\n                  buttonStyle=\"icon-label\"\n                  disabled={fieldProps?.admin?.readOnly}\n                  el=\"div\"\n                  icon=\"swap\"\n                  onClick={() => {\n                    // do nothing\n                  }}\n                  round\n                  tooltip={t('swapUpload')}\n                />\n              </ListDrawerToggler>\n              <Button\n                buttonStyle=\"icon-label\"\n                className={`${baseClass}__removeButton`}\n                disabled={fieldProps?.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      {children}\n      {value?.id && <DocumentDrawer onSave={updateUpload} />}\n      <ListDrawer onSelect={swapUpload} />\n      <UploadDrawer drawerSlug={drawerSlug} relatedCollection={relatedCollection} {...props} />\n    </div>\n  )\n}\n\nexport default (props: ElementProps): React.ReactNode => {\n  return (\n    <EnabledRelationshipsCondition {...props} uploads>\n      <Element {...props} />\n    </EnabledRelationshipsCondition>\n  )\n}\n"],"names":["baseClass","initialParams","depth","Element","props","attributes","children","element","relationTo","value","enabledCollectionSlugs","fieldProps","collections","routes","api","serverURL","useConfig","i18n","t","useTranslation","cacheBust","dispatchCacheBust","useReducer","state","relatedCollection","setRelatedCollection","useState","find","coll","slug","drawerSlug","useDrawerSlug","ListDrawer","ListDrawerToggler","closeDrawer","closeListDrawer","useListDrawer","collectionSlugs","selectedCollection","DocumentDrawer","DocumentDrawerToggler","useDocumentDrawer","id","collectionSlug","editor","useSlateStatic","selected","useSelected","focused","useFocused","data","setParams","usePayloadAPI","thumbnailSRC","useThumbnail","removeUpload","useCallback","elementPath","ReactEditor","findPath","Transforms","removeNodes","at","updateUpload","json","doc","newNode","fields","setNodes","swapUpload","React","collectionConfig","docID","text","type","customFields","admin","upload","div","className","filter","Boolean","join","contentEditable","img","alt","filename","src","FileGraphic","getTranslation","labels","singular","length","DrawerToggler","disabled","readOnly","Button","buttonStyle","el","icon","onClick","e","preventDefault","round","tooltip","strong","onSave","onSelect","UploadDrawer","EnabledRelationshipsCondition","uploads"],"mappings":"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"}

package/dist/field/elements/upload/index.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+declare const _default: {
+    Button: (props: {
+        enabledCollectionSlugs: string[];
+        path: string;
+    }) => import("react").ReactNode;
+    Element: (props: import("./Element").ElementProps) => import("react").ReactNode;
+    plugins: ((incomingEditor: any) => any)[];
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/field/elements/upload/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/field/elements/upload/index.tsx"],"names":[],"mappings":";;;;;;;;;AAIA,wBAIC"}