@payloadcms/ui 3.0.0-alpha.0 → 3.0.0-alpha.2

package/dist/elements/Popup/index.js

@@ -0,0 +1,193 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _windowinfo = require("@faceless-ui/window-info");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _useIntersect = require("../../hooks/useIntersect");
+const _PopupTrigger = require("./PopupTrigger");
+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 = {
+        __proto__: null
+    };
+    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 = 'popup';
+const Popup = (props)=>{
+    const { boundingRef, button, buttonClassName, buttonType = 'default', caret = true, children, className, forceOpen, horizontalAlign: horizontalAlignFromProps = 'left', initActive = false, onToggleOpen, render, showOnHover = false, showScrollbar = false, size = 'medium', verticalAlign: verticalAlignFromProps = 'top' } = props;
+    const { height: windowHeight, width: windowWidth } = (0, _windowinfo.useWindowInfo)();
+    const [intersectionRef, intersectionEntry] = (0, _useIntersect.useIntersect)({
+        root: boundingRef?.current || null,
+        rootMargin: '-100px 0px 0px 0px',
+        threshold: 1
+    });
+    const contentRef = (0, _react.useRef)(null);
+    const [active, setActive] = (0, _react.useState)(initActive);
+    const [verticalAlign, setVerticalAlign] = (0, _react.useState)(verticalAlignFromProps);
+    const [horizontalAlign, setHorizontalAlign] = (0, _react.useState)(horizontalAlignFromProps);
+    const setPosition = (0, _react.useCallback)(({ horizontal = false, vertical = false })=>{
+        if (contentRef.current) {
+            const bounds = contentRef.current.getBoundingClientRect();
+            const { bottom: contentBottomPos, left: contentLeftPos, right: contentRightPos, top: contentTopPos } = bounds;
+            let boundingTopPos = 100;
+            let boundingRightPos = document.documentElement.clientWidth;
+            let boundingBottomPos = document.documentElement.clientHeight;
+            let boundingLeftPos = 0;
+            if (boundingRef?.current) {
+                ({ bottom: boundingBottomPos, left: boundingLeftPos, right: boundingRightPos, top: boundingTopPos } = boundingRef.current.getBoundingClientRect());
+            }
+            if (horizontal) {
+                if (contentRightPos > boundingRightPos && contentLeftPos > boundingLeftPos) {
+                    setHorizontalAlign('right');
+                } else if (contentLeftPos < boundingLeftPos && contentRightPos < boundingRightPos) {
+                    setHorizontalAlign('left');
+                }
+            }
+            if (vertical) {
+                if (contentTopPos < boundingTopPos && contentBottomPos < boundingBottomPos) {
+                    setVerticalAlign('bottom');
+                } else if (contentBottomPos > boundingBottomPos && contentTopPos > boundingTopPos) {
+                    setVerticalAlign('top');
+                }
+            }
+        }
+    }, [
+        boundingRef
+    ]);
+    const handleClickOutside = (0, _react.useCallback)((e)=>{
+        if (contentRef.current.contains(e.target)) {
+            return;
+        }
+        setActive(false);
+    }, [
+        contentRef
+    ]);
+    (0, _react.useEffect)(()=>{
+        setPosition({
+            horizontal: true
+        });
+    }, [
+        intersectionEntry,
+        setPosition,
+        windowWidth
+    ]);
+    (0, _react.useEffect)(()=>{
+        setPosition({
+            vertical: true
+        });
+    }, [
+        intersectionEntry,
+        setPosition,
+        windowHeight
+    ]);
+    (0, _react.useEffect)(()=>{
+        if (typeof onToggleOpen === 'function') onToggleOpen(active);
+        if (active) {
+            document.addEventListener('mousedown', handleClickOutside);
+        } else {
+            document.removeEventListener('mousedown', handleClickOutside);
+        }
+        return ()=>{
+            document.removeEventListener('mousedown', handleClickOutside);
+        };
+    }, [
+        active,
+        handleClickOutside,
+        onToggleOpen
+    ]);
+    (0, _react.useEffect)(()=>{
+        setActive(forceOpen);
+    }, [
+        forceOpen
+    ]);
+    const classes = [
+        baseClass,
+        className,
+        `${baseClass}--size-${size}`,
+        `${baseClass}--v-align-${verticalAlign}`,
+        `${baseClass}--h-align-${horizontalAlign}`,
+        active && `${baseClass}--active`,
+        showScrollbar && `${baseClass}--show-scrollbar`
+    ].filter(Boolean).join(' ');
+    return /*#__PURE__*/ _react.default.createElement("div", {
+        className: classes
+    }, /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__trigger-wrap`
+    }, showOnHover ? /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__on-hover-watch`,
+        onMouseEnter: ()=>setActive(true),
+        onMouseLeave: ()=>setActive(false)
+    }, /*#__PURE__*/ _react.default.createElement(_PopupTrigger.PopupTrigger, {
+        active,
+        button,
+        buttonType,
+        className: buttonClassName,
+        setActive
+    })) : /*#__PURE__*/ _react.default.createElement(_PopupTrigger.PopupTrigger, {
+        active,
+        button,
+        buttonType,
+        className: buttonClassName,
+        setActive
+    })), /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__content`,
+        ref: contentRef
+    }, /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__hide-scrollbar`,
+        ref: intersectionRef
+    }, /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__scroll-container`
+    }, /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__scroll-content`
+    }, render && render({
+        close: ()=>setActive(false)
+    }), children && children))), caret && /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__caret`
+    })));
+};
+const _default = Popup;
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/elements/Popup/index.tsx"],"sourcesContent":["'use client'\nimport { useWindowInfo } from '@faceless-ui/window-info'\nimport React, { useCallback, useEffect, useRef, useState } from 'react'\n\nimport type { Props } from './types'\n\nimport { useIntersect } from '../../hooks/useIntersect'\nimport { PopupTrigger } from './PopupTrigger'\nimport './index.scss'\n\nconst baseClass = 'popup'\n\nconst Popup: React.FC<Props> = (props) => {\n  const {\n    boundingRef,\n    button,\n    buttonClassName,\n    buttonType = 'default',\n    caret = true,\n    children,\n    className,\n    forceOpen,\n    horizontalAlign: horizontalAlignFromProps = 'left',\n    initActive = false,\n    onToggleOpen,\n    render,\n    showOnHover = false,\n    showScrollbar = false,\n    size = 'medium',\n    verticalAlign: verticalAlignFromProps = 'top',\n  } = props\n\n  const { height: windowHeight, width: windowWidth } = useWindowInfo()\n  const [intersectionRef, intersectionEntry] = useIntersect({\n    root: boundingRef?.current || null,\n    rootMargin: '-100px 0px 0px 0px',\n    threshold: 1,\n  })\n\n  const contentRef = useRef(null)\n  const [active, setActive] = useState(initActive)\n  const [verticalAlign, setVerticalAlign] = useState(verticalAlignFromProps)\n  const [horizontalAlign, setHorizontalAlign] = useState(horizontalAlignFromProps)\n\n  const setPosition = useCallback(\n    ({ horizontal = false, vertical = false }) => {\n      if (contentRef.current) {\n        const bounds = contentRef.current.getBoundingClientRect()\n\n        const {\n          bottom: contentBottomPos,\n          left: contentLeftPos,\n          right: contentRightPos,\n          top: contentTopPos,\n        } = bounds\n\n        let boundingTopPos = 100\n        let boundingRightPos = document.documentElement.clientWidth\n        let boundingBottomPos = document.documentElement.clientHeight\n        let boundingLeftPos = 0\n\n        if (boundingRef?.current) {\n          ;({\n            bottom: boundingBottomPos,\n            left: boundingLeftPos,\n            right: boundingRightPos,\n            top: boundingTopPos,\n          } = boundingRef.current.getBoundingClientRect())\n        }\n\n        if (horizontal) {\n          if (contentRightPos > boundingRightPos && contentLeftPos > boundingLeftPos) {\n            setHorizontalAlign('right')\n          } else if (contentLeftPos < boundingLeftPos && contentRightPos < boundingRightPos) {\n            setHorizontalAlign('left')\n          }\n        }\n\n        if (vertical) {\n          if (contentTopPos < boundingTopPos && contentBottomPos < boundingBottomPos) {\n            setVerticalAlign('bottom')\n          } else if (contentBottomPos > boundingBottomPos && contentTopPos > boundingTopPos) {\n            setVerticalAlign('top')\n          }\n        }\n      }\n    },\n    [boundingRef],\n  )\n\n  const handleClickOutside = useCallback(\n    (e) => {\n      if (contentRef.current.contains(e.target)) {\n        return\n      }\n\n      setActive(false)\n    },\n    [contentRef],\n  )\n\n  useEffect(() => {\n    setPosition({ horizontal: true })\n  }, [intersectionEntry, setPosition, windowWidth])\n\n  useEffect(() => {\n    setPosition({ vertical: true })\n  }, [intersectionEntry, setPosition, windowHeight])\n\n  useEffect(() => {\n    if (typeof onToggleOpen === 'function') onToggleOpen(active)\n\n    if (active) {\n      document.addEventListener('mousedown', handleClickOutside)\n    } else {\n      document.removeEventListener('mousedown', handleClickOutside)\n    }\n\n    return () => {\n      document.removeEventListener('mousedown', handleClickOutside)\n    }\n  }, [active, handleClickOutside, onToggleOpen])\n\n  useEffect(() => {\n    setActive(forceOpen)\n  }, [forceOpen])\n\n  const classes = [\n    baseClass,\n    className,\n    `${baseClass}--size-${size}`,\n    `${baseClass}--v-align-${verticalAlign}`,\n    `${baseClass}--h-align-${horizontalAlign}`,\n    active && `${baseClass}--active`,\n    showScrollbar && `${baseClass}--show-scrollbar`,\n  ]\n    .filter(Boolean)\n    .join(' ')\n\n  return (\n    <div className={classes}>\n      <div className={`${baseClass}__trigger-wrap`}>\n        {showOnHover ? (\n          <div\n            className={`${baseClass}__on-hover-watch`}\n            onMouseEnter={() => setActive(true)}\n            onMouseLeave={() => setActive(false)}\n          >\n            <PopupTrigger\n              {...{ active, button, buttonType, className: buttonClassName, setActive }}\n            />\n          </div>\n        ) : (\n          <PopupTrigger\n            {...{ active, button, buttonType, className: buttonClassName, setActive }}\n          />\n        )}\n      </div>\n\n      <div className={`${baseClass}__content`} ref={contentRef}>\n        <div className={`${baseClass}__hide-scrollbar`} ref={intersectionRef}>\n          <div className={`${baseClass}__scroll-container`}>\n            <div className={`${baseClass}__scroll-content`}>\n              {render && render({ close: () => setActive(false) })}\n              {children && children}\n            </div>\n          </div>\n        </div>\n\n        {caret && <div className={`${baseClass}__caret`} />}\n      </div>\n    </div>\n  )\n}\n\nexport default Popup\n"],"names":["baseClass","Popup","props","boundingRef","button","buttonClassName","buttonType","caret","children","className","forceOpen","horizontalAlign","horizontalAlignFromProps","initActive","onToggleOpen","render","showOnHover","showScrollbar","size","verticalAlign","verticalAlignFromProps","height","windowHeight","width","windowWidth","useWindowInfo","intersectionRef","intersectionEntry","useIntersect","root","current","rootMargin","threshold","contentRef","useRef","active","setActive","useState","setVerticalAlign","setHorizontalAlign","setPosition","useCallback","horizontal","vertical","bounds","getBoundingClientRect","bottom","contentBottomPos","left","contentLeftPos","right","contentRightPos","top","contentTopPos","boundingTopPos","boundingRightPos","document","documentElement","clientWidth","boundingBottomPos","clientHeight","boundingLeftPos","handleClickOutside","e","contains","target","useEffect","addEventListener","removeEventListener","classes","filter","Boolean","join","div","onMouseEnter","onMouseLeave","PopupTrigger","ref","close"],"mappings":"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"}

package/dist/elements/Popup/types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist/elements/PreviewButton/index.js

@@ -0,0 +1,129 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _reacttoastify = require("react-toastify");
+const _RenderCustomComponent = require("../../elements/RenderCustomComponent");
+const _Auth = require("../../providers/Auth");
+const _Config = require("../../providers/Config");
+const _DocumentInfo = require("../../providers/DocumentInfo");
+const _Locale = require("../../providers/Locale");
+const _Translation = require("../../providers/Translation");
+const _Button = require("../Button");
+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 = {
+        __proto__: null
+    };
+    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 = 'preview-btn';
+const DefaultPreviewButton = ({ disabled, label, preview })=>{
+    return /*#__PURE__*/ _react.default.createElement(_Button.Button, {
+        buttonStyle: "secondary",
+        className: baseClass,
+        disabled: disabled,
+        onClick: preview,
+        size: "small"
+    }, label);
+};
+const PreviewButton = ({ CustomComponent, generatePreviewURL })=>{
+    const { id, collectionSlug, globalSlug } = (0, _DocumentInfo.useDocumentInfo)();
+    const [isLoading, setIsLoading] = (0, _react.useState)(false);
+    const { code: locale } = (0, _Locale.useLocale)();
+    const { token } = (0, _Auth.useAuth)();
+    const { routes: { api }, serverURL } = (0, _Config.useConfig)();
+    const { t } = (0, _Translation.useTranslation)();
+    const isGeneratingPreviewURL = (0, _react.useRef)(false);
+    // we need to regenerate the preview URL every time the button is clicked
+    // to do this we need to fetch the document data fresh from the API
+    // this will ensure the latest data is used when generating the preview URL
+    const preview = (0, _react.useCallback)(async ()=>{
+        if (!generatePreviewURL || isGeneratingPreviewURL.current) return;
+        isGeneratingPreviewURL.current = true;
+        try {
+            setIsLoading(true);
+            let url = `${serverURL}${api}`;
+            if (collectionSlug) url = `${url}/${collectionSlug}/${id}`;
+            if (globalSlug) url = `${url}/globals/${globalSlug}`;
+            const data = await fetch(`${url}?draft=true&locale=${locale}&fallback-locale=null`).then((res)=>res.json());
+            const previewURL = await generatePreviewURL(data, {
+                locale,
+                token
+            });
+            if (!previewURL) throw new Error();
+            setIsLoading(false);
+            isGeneratingPreviewURL.current = false;
+            window.open(previewURL, '_blank');
+        } catch (err) {
+            setIsLoading(false);
+            isGeneratingPreviewURL.current = false;
+            _reacttoastify.toast.error(t('error:previewing'));
+        }
+    }, [
+        serverURL,
+        api,
+        collectionSlug,
+        globalSlug,
+        id,
+        generatePreviewURL,
+        locale,
+        token,
+        t
+    ]);
+    return /*#__PURE__*/ _react.default.createElement(_RenderCustomComponent.RenderCustomComponent, {
+        CustomComponent: CustomComponent,
+        DefaultComponent: DefaultPreviewButton,
+        componentProps: {
+            DefaultButton: DefaultPreviewButton,
+            disabled: isLoading || !generatePreviewURL,
+            label: isLoading ? t('general:loading') : t('version:preview'),
+            preview
+        }
+    });
+};
+const _default = PreviewButton;
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/elements/PreviewSizes/index.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _FileMeta = /*#__PURE__*/ _interop_require_default(require("../FileDetails/FileMeta"));
+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 = {
+        __proto__: null
+    };
+    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 = 'preview-sizes';
+const sortSizes = (sizes, imageSizes)=>{
+    if (!imageSizes || imageSizes.length === 0) return sizes;
+    const orderedSizes = {};
+    imageSizes.forEach(({ name })=>{
+        if (sizes[name]) {
+            orderedSizes[name] = sizes[name];
+        }
+    });
+    return orderedSizes;
+};
+const PreviewSizeCard = ({ name, active, meta, onClick, previewSrc })=>{
+    return /*#__PURE__*/ _react.default.createElement("div", {
+        className: [
+            `${baseClass}__sizeOption`,
+            active && `${baseClass}--selected`
+        ].filter(Boolean).join(' '),
+        onClick: typeof onClick === 'function' ? onClick : undefined,
+        onKeyDown: (e)=>{
+            if (typeof onClick !== 'function') return;
+            if (e.key === 'Enter') onClick();
+        },
+        role: "button",
+        tabIndex: 0
+    }, /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__image`
+    }, /*#__PURE__*/ _react.default.createElement("img", {
+        alt: meta.filename,
+        src: previewSrc
+    })), /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__sizeMeta`
+    }, /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__sizeName`
+    }, name), /*#__PURE__*/ _react.default.createElement(_FileMeta.default, meta)));
+};
+const PreviewSizes = ({ doc, imageCacheTag, uploadConfig })=>{
+    const { imageSizes } = uploadConfig;
+    const { sizes } = doc;
+    const [orderedSizes, setOrderedSizes] = (0, _react.useState)(()=>sortSizes(sizes, imageSizes));
+    const [selectedSize, setSelectedSize] = (0, _react.useState)(null);
+    const generateImageUrl = (doc)=>{
+        if (!doc.filename) return null;
+        if (doc.url) return `${doc.url}${imageCacheTag ? `?${imageCacheTag}` : ''}`;
+    };
+    (0, _react.useEffect)(()=>{
+        setOrderedSizes(sortSizes(sizes, imageSizes));
+    }, [
+        sizes,
+        imageSizes,
+        imageCacheTag
+    ]);
+    const mainPreviewSrc = selectedSize ? generateImageUrl(doc.sizes[selectedSize]) : generateImageUrl(doc);
+    const originalImage = (0, _react.useMemo)(()=>({
+            filename: doc.filename,
+            filesize: doc.filesize,
+            height: doc.height,
+            mimeType: doc.mimeType,
+            url: doc.url,
+            width: doc.width
+        }), [
+        doc
+    ]);
+    const originalFilename = 'Original';
+    return /*#__PURE__*/ _react.default.createElement("div", {
+        className: baseClass
+    }, /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__imageWrap`
+    }, /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__meta`
+    }, /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__sizeName`
+    }, selectedSize || originalFilename), /*#__PURE__*/ _react.default.createElement(_FileMeta.default, selectedSize ? orderedSizes[selectedSize] : originalImage)), /*#__PURE__*/ _react.default.createElement("img", {
+        alt: doc.filename,
+        className: `${baseClass}__preview`,
+        src: mainPreviewSrc
+    })), /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__listWrap`
+    }, /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__list`
+    }, /*#__PURE__*/ _react.default.createElement(PreviewSizeCard, {
+        active: !selectedSize,
+        meta: originalImage,
+        name: originalFilename,
+        onClick: ()=>setSelectedSize(null),
+        previewSrc: generateImageUrl(doc)
+    }), Object.entries(orderedSizes).map(([key, val])=>{
+        const selected = selectedSize === key;
+        const previewSrc = generateImageUrl(val);
+        if (previewSrc) {
+            return /*#__PURE__*/ _react.default.createElement(PreviewSizeCard, {
+                active: selected,
+                key: key,
+                meta: val,
+                name: key,
+                onClick: ()=>setSelectedSize(key),
+                previewSrc: previewSrc
+            });
+        }
+        return null;
+    }))));
+};
+const _default = PreviewSizes;
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/elements/PreviewSizes/index.tsx"],"sourcesContent":["import type {\n  Data,\n  FileSize,\n  SanitizedCollectionConfig,\n  SanitizedUploadConfig,\n} from 'payload/types'\n\nimport React, { useEffect, useMemo, useState } from 'react'\n\nimport FileMeta from '../FileDetails/FileMeta'\nimport './index.scss'\n\nconst baseClass = 'preview-sizes'\n\ntype FileInfo = FileSize & {\n  url: string\n}\ntype FilesSizesWithUrl = {\n  [key: string]: FileInfo\n}\n\nconst sortSizes = (sizes: FilesSizesWithUrl, imageSizes: SanitizedUploadConfig['imageSizes']) => {\n  if (!imageSizes || imageSizes.length === 0) return sizes\n\n  const orderedSizes: FilesSizesWithUrl = {}\n\n  imageSizes.forEach(({ name }) => {\n    if (sizes[name]) {\n      orderedSizes[name] = sizes[name]\n    }\n  })\n\n  return orderedSizes\n}\n\ntype PreviewSizeCardProps = {\n  active: boolean\n  meta: FileInfo\n  name: string\n  onClick?: () => void\n  previewSrc: string\n}\nconst PreviewSizeCard: React.FC<PreviewSizeCardProps> = ({\n  name,\n  active,\n  meta,\n  onClick,\n  previewSrc,\n}) => {\n  return (\n    <div\n      className={[`${baseClass}__sizeOption`, active && `${baseClass}--selected`]\n        .filter(Boolean)\n        .join(' ')}\n      onClick={typeof onClick === 'function' ? onClick : undefined}\n      onKeyDown={(e) => {\n        if (typeof onClick !== 'function') return\n        if (e.key === 'Enter') onClick()\n      }}\n      role=\"button\"\n      tabIndex={0}\n    >\n      <div className={`${baseClass}__image`}>\n        <img alt={meta.filename} src={previewSrc} />\n      </div>\n      <div className={`${baseClass}__sizeMeta`}>\n        <div className={`${baseClass}__sizeName`}>{name}</div>\n        <FileMeta {...meta} />\n      </div>\n    </div>\n  )\n}\n\nconst PreviewSizes: React.FC<{\n  doc: Data & {\n    sizes?: FilesSizesWithUrl\n  }\n  imageCacheTag?: string\n  uploadConfig: SanitizedCollectionConfig['upload']\n}> = ({ doc, imageCacheTag, uploadConfig }) => {\n  const { imageSizes } = uploadConfig\n  const { sizes } = doc\n\n  const [orderedSizes, setOrderedSizes] = useState<FilesSizesWithUrl>(() =>\n    sortSizes(sizes, imageSizes),\n  )\n  const [selectedSize, setSelectedSize] = useState<null | string>(null)\n\n  const generateImageUrl = (doc) => {\n    if (!doc.filename) return null\n    if (doc.url) return `${doc.url}${imageCacheTag ? `?${imageCacheTag}` : ''}`\n  }\n  useEffect(() => {\n    setOrderedSizes(sortSizes(sizes, imageSizes))\n  }, [sizes, imageSizes, imageCacheTag])\n\n  const mainPreviewSrc = selectedSize\n    ? generateImageUrl(doc.sizes[selectedSize])\n    : generateImageUrl(doc)\n\n  const originalImage = useMemo(\n    (): FileInfo => ({\n      filename: doc.filename,\n      filesize: doc.filesize,\n      height: doc.height,\n      mimeType: doc.mimeType,\n      url: doc.url,\n      width: doc.width,\n    }),\n    [doc],\n  )\n  const originalFilename = 'Original'\n\n  return (\n    <div className={baseClass}>\n      <div className={`${baseClass}__imageWrap`}>\n        <div className={`${baseClass}__meta`}>\n          <div className={`${baseClass}__sizeName`}>{selectedSize || originalFilename}</div>\n          <FileMeta {...(selectedSize ? orderedSizes[selectedSize] : originalImage)} />\n        </div>\n        <img alt={doc.filename} className={`${baseClass}__preview`} src={mainPreviewSrc} />\n      </div>\n      <div className={`${baseClass}__listWrap`}>\n        <div className={`${baseClass}__list`}>\n          <PreviewSizeCard\n            active={!selectedSize}\n            meta={originalImage}\n            name={originalFilename}\n            onClick={() => setSelectedSize(null)}\n            previewSrc={generateImageUrl(doc)}\n          />\n\n          {Object.entries(orderedSizes).map(([key, val]) => {\n            const selected = selectedSize === key\n            const previewSrc = generateImageUrl(val)\n\n            if (previewSrc) {\n              return (\n                <PreviewSizeCard\n                  active={selected}\n                  key={key}\n                  meta={val}\n                  name={key}\n                  onClick={() => setSelectedSize(key)}\n                  previewSrc={previewSrc}\n                />\n              )\n            }\n\n            return null\n          })}\n        </div>\n      </div>\n    </div>\n  )\n}\nexport default PreviewSizes\n"],"names":["baseClass","sortSizes","sizes","imageSizes","length","orderedSizes","forEach","name","PreviewSizeCard","active","meta","onClick","previewSrc","div","className","filter","Boolean","join","undefined","onKeyDown","e","key","role","tabIndex","img","alt","filename","src","FileMeta","PreviewSizes","doc","imageCacheTag","uploadConfig","setOrderedSizes","useState","selectedSize","setSelectedSize","generateImageUrl","url","useEffect","mainPreviewSrc","originalImage","useMemo","filesize","height","mimeType","width","originalFilename","Object","entries","map","val","selected"],"mappings":"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"}