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

package/dist/elements/EditUpload/index.js

@@ -0,0 +1,390 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "EditUpload", {
+    enumerable: true,
+    get: function() {
+        return EditUpload;
+    }
+});
+const _modal = require("@faceless-ui/modal");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _reactimagecrop = /*#__PURE__*/ _interop_require_default(require("react-image-crop"));
+require("react-image-crop/dist/ReactCrop.css");
+const _Upload = require("../../elements/Upload");
+const _Plus = require("../../icons/Plus");
+const _FormQueryParams = require("../../providers/FormQueryParams");
+const _Translation = require("../../providers/Translation");
+const _Button = require("../Button");
+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 = 'edit-upload';
+const Input = ({ name, onChange, value })=>/*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__input`
+    }, name, /*#__PURE__*/ _react.default.createElement("input", {
+        name: name,
+        onChange: (e)=>onChange(e.target.value),
+        type: "number",
+        value: value
+    }));
+const EditUpload = ({ fileName, fileSrc, imageCacheTag, showCrop, showFocalPoint })=>{
+    const { closeModal } = (0, _modal.useModal)();
+    const { t } = (0, _Translation.useTranslation)();
+    const { formQueryParams, setFormQueryParams } = (0, _FormQueryParams.useFormQueryParams)();
+    const { uploadEdits } = formQueryParams || {};
+    const [crop, setCrop] = (0, _react.useState)({
+        height: uploadEdits?.crop?.height || 100,
+        unit: '%',
+        width: uploadEdits?.crop?.width || 100,
+        x: uploadEdits?.crop?.x || 0,
+        y: uploadEdits?.crop?.y || 0
+    });
+    const [pointPosition, setPointPosition] = (0, _react.useState)({
+        x: uploadEdits?.focalPoint?.x || 50,
+        y: uploadEdits?.focalPoint?.y || 50
+    });
+    const [checkBounds, setCheckBounds] = (0, _react.useState)(false);
+    const [originalHeight, setOriginalHeight] = (0, _react.useState)(0);
+    const [originalWidth, setOriginalWidth] = (0, _react.useState)(0);
+    const focalWrapRef = (0, _react.useRef)();
+    const imageRef = (0, _react.useRef)();
+    const cropRef = (0, _react.useRef)();
+    const fineTuneCrop = ({ dimension, value })=>{
+        const intValue = parseInt(value);
+        if (dimension === 'width' && intValue >= originalWidth) return null;
+        if (dimension === 'height' && intValue >= originalHeight) return null;
+        const percentage = 100 * (intValue / (dimension === 'width' ? originalWidth : originalHeight));
+        if (percentage === 100 || percentage === 0) return null;
+        setCrop({
+            ...crop,
+            [dimension]: percentage
+        });
+    };
+    const fineTuneFocalPoint = ({ coordinate, value })=>{
+        const intValue = parseInt(value);
+        if (intValue >= 0 && intValue <= 100) {
+            setPointPosition((prevPosition)=>({
+                    ...prevPosition,
+                    [coordinate]: intValue
+                }));
+        }
+    };
+    const saveEdits = ()=>{
+        setFormQueryParams({
+            ...formQueryParams,
+            uploadEdits: {
+                crop: crop || undefined,
+                focalPoint: pointPosition ? pointPosition : undefined
+            }
+        });
+        closeModal(_Upload.editDrawerSlug);
+    };
+    const onDragEnd = _react.default.useCallback(({ x, y })=>{
+        setPointPosition({
+            x,
+            y
+        });
+        setCheckBounds(false);
+    }, []);
+    const centerFocalPoint = ()=>{
+        const containerRect = focalWrapRef.current.getBoundingClientRect();
+        const boundsRect = showCrop ? cropRef.current.getBoundingClientRect() : imageRef.current.getBoundingClientRect();
+        const xCenter = (boundsRect.left - containerRect.left + boundsRect.width / 2) / containerRect.width * 100;
+        const yCenter = (boundsRect.top - containerRect.top + boundsRect.height / 2) / containerRect.height * 100;
+        setPointPosition({
+            x: xCenter,
+            y: yCenter
+        });
+    };
+    const fileSrcToUse = imageCacheTag ? `${fileSrc}?${imageCacheTag}` : fileSrc;
+    return /*#__PURE__*/ _react.default.createElement("div", {
+        className: baseClass
+    }, /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__header`
+    }, /*#__PURE__*/ _react.default.createElement("h2", {
+        title: `${t('general:editing')} ${fileName}`
+    }, t('general:editing'), " ", fileName), /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__actions`
+    }, /*#__PURE__*/ _react.default.createElement(_Button.Button, {
+        "aria-label": t('general:cancel'),
+        buttonStyle: "secondary",
+        className: `${baseClass}__cancel`,
+        onClick: ()=>closeModal(_Upload.editDrawerSlug)
+    }, t('general:cancel')), /*#__PURE__*/ _react.default.createElement(_Button.Button, {
+        "aria-label": t('general:applyChanges'),
+        buttonStyle: "primary",
+        className: `${baseClass}__save`,
+        onClick: ()=>saveEdits()
+    }, t('general:applyChanges')))), /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__toolWrap`
+    }, /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__crop`
+    }, /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__focal-wrapper`,
+        ref: focalWrapRef,
+        style: {
+            aspectRatio: `${originalWidth / originalHeight}`
+        }
+    }, showCrop ? /*#__PURE__*/ _react.default.createElement(_reactimagecrop.default, {
+        className: `${baseClass}__reactCrop`,
+        crop: crop,
+        onChange: (_, c)=>setCrop(c),
+        onComplete: ()=>setCheckBounds(true),
+        renderSelectionAddon: ()=>{
+            return /*#__PURE__*/ _react.default.createElement("div", {
+                className: `${baseClass}__crop-window`,
+                ref: cropRef
+            });
+        }
+    }, /*#__PURE__*/ _react.default.createElement("img", {
+        alt: t('upload:setCropArea'),
+        onLoad: (e)=>{
+            setOriginalHeight(e.currentTarget.naturalHeight);
+            setOriginalWidth(e.currentTarget.naturalWidth);
+        },
+        ref: imageRef,
+        src: fileSrcToUse
+    })) : /*#__PURE__*/ _react.default.createElement("img", {
+        alt: t('upload:setFocalPoint'),
+        onLoad: (e)=>{
+            setOriginalHeight(e.currentTarget.naturalHeight);
+            setOriginalWidth(e.currentTarget.naturalWidth);
+        },
+        ref: imageRef,
+        src: fileSrcToUse
+    }), showFocalPoint && /*#__PURE__*/ _react.default.createElement(DraggableElement, {
+        boundsRef: showCrop ? cropRef : imageRef,
+        checkBounds: showCrop ? checkBounds : false,
+        className: `${baseClass}__focalPoint`,
+        containerRef: focalWrapRef,
+        initialPosition: pointPosition,
+        onDragEnd: onDragEnd,
+        setCheckBounds: showCrop ? setCheckBounds : false
+    }, /*#__PURE__*/ _react.default.createElement(_Plus.Plus, null)))), (showCrop || showFocalPoint) && /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__sidebar`
+    }, showCrop && /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__groupWrap`
+    }, /*#__PURE__*/ _react.default.createElement("div", null, /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__titleWrap`
+    }, /*#__PURE__*/ _react.default.createElement("h3", null, t('upload:crop')), /*#__PURE__*/ _react.default.createElement(_Button.Button, {
+        buttonStyle: "none",
+        className: `${baseClass}__reset`,
+        onClick: ()=>setCrop({
+                height: 100,
+                unit: '%',
+                width: 100,
+                x: 0,
+                y: 0
+            })
+    }, t('general:reset')))), /*#__PURE__*/ _react.default.createElement("span", {
+        className: `${baseClass}__description`
+    }, t('upload:cropToolDescription')), /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__inputsWrap`
+    }, /*#__PURE__*/ _react.default.createElement(Input, {
+        name: `${t('upload:width')} (px)`,
+        onChange: (value)=>fineTuneCrop({
+                dimension: 'width',
+                value
+            }),
+        value: (crop.width / 100 * originalWidth).toFixed(0)
+    }), /*#__PURE__*/ _react.default.createElement(Input, {
+        name: `${t('upload:height')} (px)`,
+        onChange: (value)=>fineTuneCrop({
+                dimension: 'height',
+                value
+            }),
+        value: (crop.height / 100 * originalHeight).toFixed(0)
+    }))), showFocalPoint && /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__groupWrap`
+    }, /*#__PURE__*/ _react.default.createElement("div", null, /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__titleWrap`
+    }, /*#__PURE__*/ _react.default.createElement("h3", null, t('upload:focalPoint')), /*#__PURE__*/ _react.default.createElement(_Button.Button, {
+        buttonStyle: "none",
+        className: `${baseClass}__reset`,
+        onClick: centerFocalPoint
+    }, t('general:reset')))), /*#__PURE__*/ _react.default.createElement("span", {
+        className: `${baseClass}__description`
+    }, t('upload:focalPointDescription')), /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__inputsWrap`
+    }, /*#__PURE__*/ _react.default.createElement(Input, {
+        name: "X %",
+        onChange: (value)=>fineTuneFocalPoint({
+                coordinate: 'x',
+                value
+            }),
+        value: pointPosition.x.toFixed(0)
+    }), /*#__PURE__*/ _react.default.createElement(Input, {
+        name: "Y %",
+        onChange: (value)=>fineTuneFocalPoint({
+                coordinate: 'y',
+                value
+            }),
+        value: pointPosition.y.toFixed(0)
+    }))))));
+};
+const DraggableElement = ({ boundsRef, checkBounds, children, className, containerRef, initialPosition = {
+    x: 50,
+    y: 50
+}, onDragEnd, setCheckBounds })=>{
+    const [position, setPosition] = (0, _react.useState)({
+        x: initialPosition.x,
+        y: initialPosition.y
+    });
+    const [isDragging, setIsDragging] = (0, _react.useState)(false);
+    const dragRef = (0, _react.useRef)();
+    const getCoordinates = _react.default.useCallback((mouseXArg, mouseYArg, recenter)=>{
+        const containerRect = containerRef.current.getBoundingClientRect();
+        const boundsRect = boundsRef.current.getBoundingClientRect();
+        const mouseX = mouseXArg ?? boundsRect.left;
+        const mouseY = mouseYArg ?? boundsRect.top;
+        const xOutOfBounds = mouseX < boundsRect.left || mouseX > boundsRect.right;
+        const yOutOfBounds = mouseY < boundsRect.top || mouseY > boundsRect.bottom;
+        let x = (mouseX - containerRect.left) / containerRect.width * 100;
+        let y = (mouseY - containerRect.top) / containerRect.height * 100;
+        const xCenter = (boundsRect.left - containerRect.left + boundsRect.width / 2) / containerRect.width * 100;
+        const yCenter = (boundsRect.top - containerRect.top + boundsRect.height / 2) / containerRect.height * 100;
+        if (xOutOfBounds || yOutOfBounds) {
+            setIsDragging(false);
+            if (mouseX < boundsRect.left) {
+                x = (boundsRect.left - containerRect.left) / containerRect.width * 100;
+            } else if (mouseX > boundsRect.right) {
+                x = (containerRect.width - (containerRect.right - boundsRect.right)) / containerRect.width * 100;
+            }
+            if (mouseY < boundsRect.top) {
+                y = (boundsRect.top - containerRect.top) / containerRect.height * 100;
+            } else if (mouseY > boundsRect.bottom) {
+                y = (containerRect.height - (containerRect.bottom - boundsRect.bottom)) / containerRect.height * 100;
+            }
+            if (recenter) {
+                x = xOutOfBounds ? xCenter : x;
+                y = yOutOfBounds ? yCenter : y;
+            }
+        }
+        return {
+            x,
+            y
+        };
+    }, [
+        boundsRef,
+        containerRef
+    ]);
+    const handleMouseDown = (event)=>{
+        event.preventDefault();
+        setIsDragging(true);
+    };
+    const handleMouseMove = (event)=>{
+        if (!isDragging) return null;
+        const { x, y } = getCoordinates(event.clientX, event.clientY);
+        setPosition({
+            x,
+            y
+        });
+    };
+    const onDrop = ()=>{
+        setIsDragging(false);
+        onDragEnd(position);
+    };
+    _react.default.useEffect(()=>{
+        if (isDragging || !dragRef.current) return;
+        if (checkBounds) {
+            const { height, left, top, width } = dragRef.current.getBoundingClientRect();
+            const { x, y } = getCoordinates(left + width / 2, top + height / 2, true);
+            onDragEnd({
+                x,
+                y
+            });
+            setPosition({
+                x,
+                y
+            });
+            setCheckBounds(false);
+            return;
+        }
+    }, [
+        getCoordinates,
+        isDragging,
+        checkBounds,
+        setCheckBounds,
+        position.x,
+        position.y,
+        onDragEnd
+    ]);
+    _react.default.useEffect(()=>{
+        setPosition({
+            x: initialPosition.x,
+            y: initialPosition.y
+        });
+    }, [
+        initialPosition.x,
+        initialPosition.y
+    ]);
+    return /*#__PURE__*/ _react.default.createElement("div", {
+        className: [
+            `${baseClass}__draggable-container`,
+            isDragging && `${baseClass}__draggable-container--dragging`
+        ].filter(Boolean).join(' '),
+        onMouseMove: handleMouseMove
+    }, /*#__PURE__*/ _react.default.createElement("button", {
+        className: [
+            `${baseClass}__draggable`,
+            className
+        ].filter(Boolean).join(' '),
+        onMouseDown: handleMouseDown,
+        onMouseUp: onDrop,
+        ref: dragRef,
+        style: {
+            left: `${position.x}%`,
+            top: `${position.y}%`
+        },
+        type: "button"
+    }, children), /*#__PURE__*/ _react.default.createElement("div", null));
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/elements/EditUpload/index.tsx"],"sourcesContent":["'use client'\nimport type { Data } from 'payload/types'\n\nimport { useModal } from '@faceless-ui/modal'\nimport React, { useRef, useState } from 'react'\nimport ReactCrop, { type Crop as CropType } from 'react-image-crop'\nimport 'react-image-crop/dist/ReactCrop.css'\n\nimport { editDrawerSlug } from '../../elements/Upload'\nimport { Plus } from '../../icons/Plus'\nimport { useFormQueryParams } from '../../providers/FormQueryParams'\nimport { useTranslation } from '../../providers/Translation'\nimport { Button } from '../Button'\nimport './index.scss'\n\nconst baseClass = 'edit-upload'\n\nconst Input: React.FC<{ name: string; onChange: (value: string) => void; value: string }> = ({\n  name,\n  onChange,\n  value,\n}) => (\n  <div className={`${baseClass}__input`}>\n    {name}\n    <input name={name} onChange={(e) => onChange(e.target.value)} type=\"number\" value={value} />\n  </div>\n)\n\nexport const EditUpload: React.FC<{\n  doc?: Data\n  fileName: string\n  fileSrc: string\n  imageCacheTag?: string\n  showCrop?: boolean\n  showFocalPoint?: boolean\n}> = ({ fileName, fileSrc, imageCacheTag, showCrop, showFocalPoint }) => {\n  const { closeModal } = useModal()\n  const { t } = useTranslation()\n  const { formQueryParams, setFormQueryParams } = useFormQueryParams()\n  const { uploadEdits } = formQueryParams || {}\n  const [crop, setCrop] = useState<CropType>({\n    height: uploadEdits?.crop?.height || 100,\n    unit: '%',\n    width: uploadEdits?.crop?.width || 100,\n    x: uploadEdits?.crop?.x || 0,\n    y: uploadEdits?.crop?.y || 0,\n  })\n\n  const [pointPosition, setPointPosition] = useState<{ x: number; y: number }>({\n    x: uploadEdits?.focalPoint?.x || 50,\n    y: uploadEdits?.focalPoint?.y || 50,\n  })\n  const [checkBounds, setCheckBounds] = useState<boolean>(false)\n  const [originalHeight, setOriginalHeight] = useState<number>(0)\n  const [originalWidth, setOriginalWidth] = useState<number>(0)\n\n  const focalWrapRef = useRef<HTMLDivElement | undefined>()\n  const imageRef = useRef<HTMLImageElement | undefined>()\n  const cropRef = useRef<HTMLDivElement | undefined>()\n\n  const fineTuneCrop = ({ dimension, value }: { dimension: 'height' | 'width'; value: string }) => {\n    const intValue = parseInt(value)\n    if (dimension === 'width' && intValue >= originalWidth) return null\n    if (dimension === 'height' && intValue >= originalHeight) return null\n\n    const percentage = 100 * (intValue / (dimension === 'width' ? originalWidth : originalHeight))\n\n    if (percentage === 100 || percentage === 0) return null\n\n    setCrop({\n      ...crop,\n      [dimension]: percentage,\n    })\n  }\n\n  const fineTuneFocalPoint = ({ coordinate, value }: { coordinate: 'x' | 'y'; value: string }) => {\n    const intValue = parseInt(value)\n    if (intValue >= 0 && intValue <= 100) {\n      setPointPosition((prevPosition) => ({ ...prevPosition, [coordinate]: intValue }))\n    }\n  }\n\n  const saveEdits = () => {\n    setFormQueryParams({\n      ...formQueryParams,\n      uploadEdits: {\n        crop: crop || undefined,\n        focalPoint: pointPosition ? pointPosition : undefined,\n      },\n    })\n    closeModal(editDrawerSlug)\n  }\n\n  const onDragEnd = React.useCallback(({ x, y }) => {\n    setPointPosition({ x, y })\n    setCheckBounds(false)\n  }, [])\n\n  const centerFocalPoint = () => {\n    const containerRect = focalWrapRef.current.getBoundingClientRect()\n    const boundsRect = showCrop\n      ? cropRef.current.getBoundingClientRect()\n      : imageRef.current.getBoundingClientRect()\n    const xCenter =\n      ((boundsRect.left - containerRect.left + boundsRect.width / 2) / containerRect.width) * 100\n    const yCenter =\n      ((boundsRect.top - containerRect.top + boundsRect.height / 2) / containerRect.height) * 100\n    setPointPosition({ x: xCenter, y: yCenter })\n  }\n\n  const fileSrcToUse = imageCacheTag ? `${fileSrc}?${imageCacheTag}` : fileSrc\n\n  return (\n    <div className={baseClass}>\n      <div className={`${baseClass}__header`}>\n        <h2 title={`${t('general:editing')} ${fileName}`}>\n          {t('general:editing')} {fileName}\n        </h2>\n        <div className={`${baseClass}__actions`}>\n          <Button\n            aria-label={t('general:cancel')}\n            buttonStyle=\"secondary\"\n            className={`${baseClass}__cancel`}\n            onClick={() => closeModal(editDrawerSlug)}\n          >\n            {t('general:cancel')}\n          </Button>\n          <Button\n            aria-label={t('general:applyChanges')}\n            buttonStyle=\"primary\"\n            className={`${baseClass}__save`}\n            onClick={() => saveEdits()}\n          >\n            {t('general:applyChanges')}\n          </Button>\n        </div>\n      </div>\n      <div className={`${baseClass}__toolWrap`}>\n        <div className={`${baseClass}__crop`}>\n          <div\n            className={`${baseClass}__focal-wrapper`}\n            ref={focalWrapRef}\n            style={{\n              aspectRatio: `${originalWidth / originalHeight}`,\n            }}\n          >\n            {showCrop ? (\n              <ReactCrop\n                className={`${baseClass}__reactCrop`}\n                crop={crop}\n                onChange={(_, c) => setCrop(c)}\n                onComplete={() => setCheckBounds(true)}\n                renderSelectionAddon={() => {\n                  return <div className={`${baseClass}__crop-window`} ref={cropRef} />\n                }}\n              >\n                <img\n                  alt={t('upload:setCropArea')}\n                  onLoad={(e) => {\n                    setOriginalHeight(e.currentTarget.naturalHeight)\n                    setOriginalWidth(e.currentTarget.naturalWidth)\n                  }}\n                  ref={imageRef}\n                  src={fileSrcToUse}\n                />\n              </ReactCrop>\n            ) : (\n              <img\n                alt={t('upload:setFocalPoint')}\n                onLoad={(e) => {\n                  setOriginalHeight(e.currentTarget.naturalHeight)\n                  setOriginalWidth(e.currentTarget.naturalWidth)\n                }}\n                ref={imageRef}\n                src={fileSrcToUse}\n              />\n            )}\n            {showFocalPoint && (\n              <DraggableElement\n                boundsRef={showCrop ? cropRef : imageRef}\n                checkBounds={showCrop ? checkBounds : false}\n                className={`${baseClass}__focalPoint`}\n                containerRef={focalWrapRef}\n                initialPosition={pointPosition}\n                onDragEnd={onDragEnd}\n                setCheckBounds={showCrop ? setCheckBounds : false}\n              >\n                <Plus />\n              </DraggableElement>\n            )}\n          </div>\n        </div>\n        {(showCrop || showFocalPoint) && (\n          <div className={`${baseClass}__sidebar`}>\n            {showCrop && (\n              <div className={`${baseClass}__groupWrap`}>\n                <div>\n                  <div className={`${baseClass}__titleWrap`}>\n                    <h3>{t('upload:crop')}</h3>\n                    <Button\n                      buttonStyle=\"none\"\n                      className={`${baseClass}__reset`}\n                      onClick={() =>\n                        setCrop({\n                          height: 100,\n                          unit: '%',\n                          width: 100,\n                          x: 0,\n                          y: 0,\n                        })\n                      }\n                    >\n                      {t('general:reset')}\n                    </Button>\n                  </div>\n                </div>\n                <span className={`${baseClass}__description`}>\n                  {t('upload:cropToolDescription')}\n                </span>\n                <div className={`${baseClass}__inputsWrap`}>\n                  <Input\n                    name={`${t('upload:width')} (px)`}\n                    onChange={(value) => fineTuneCrop({ dimension: 'width', value })}\n                    value={((crop.width / 100) * originalWidth).toFixed(0)}\n                  />\n                  <Input\n                    name={`${t('upload:height')} (px)`}\n                    onChange={(value) => fineTuneCrop({ dimension: 'height', value })}\n                    value={((crop.height / 100) * originalHeight).toFixed(0)}\n                  />\n                </div>\n              </div>\n            )}\n\n            {showFocalPoint && (\n              <div className={`${baseClass}__groupWrap`}>\n                <div>\n                  <div className={`${baseClass}__titleWrap`}>\n                    <h3>{t('upload:focalPoint')}</h3>\n                    <Button\n                      buttonStyle=\"none\"\n                      className={`${baseClass}__reset`}\n                      onClick={centerFocalPoint}\n                    >\n                      {t('general:reset')}\n                    </Button>\n                  </div>\n                </div>\n                <span className={`${baseClass}__description`}>\n                  {t('upload:focalPointDescription')}\n                </span>\n                <div className={`${baseClass}__inputsWrap`}>\n                  <Input\n                    name=\"X %\"\n                    onChange={(value) => fineTuneFocalPoint({ coordinate: 'x', value })}\n                    value={pointPosition.x.toFixed(0)}\n                  />\n                  <Input\n                    name=\"Y %\"\n                    onChange={(value) => fineTuneFocalPoint({ coordinate: 'y', value })}\n                    value={pointPosition.y.toFixed(0)}\n                  />\n                </div>\n              </div>\n            )}\n          </div>\n        )}\n      </div>\n    </div>\n  )\n}\n\nconst DraggableElement = ({\n  boundsRef,\n  checkBounds,\n  children,\n  className,\n  containerRef,\n  initialPosition = { x: 50, y: 50 },\n  onDragEnd,\n  setCheckBounds,\n}) => {\n  const [position, setPosition] = useState({ x: initialPosition.x, y: initialPosition.y })\n  const [isDragging, setIsDragging] = useState(false)\n  const dragRef = useRef<HTMLButtonElement | undefined>()\n\n  const getCoordinates = React.useCallback(\n    (mouseXArg?: number, mouseYArg?: number, recenter?: boolean) => {\n      const containerRect = containerRef.current.getBoundingClientRect()\n      const boundsRect = boundsRef.current.getBoundingClientRect()\n      const mouseX = mouseXArg ?? boundsRect.left\n      const mouseY = mouseYArg ?? boundsRect.top\n\n      const xOutOfBounds = mouseX < boundsRect.left || mouseX > boundsRect.right\n      const yOutOfBounds = mouseY < boundsRect.top || mouseY > boundsRect.bottom\n\n      let x = ((mouseX - containerRect.left) / containerRect.width) * 100\n      let y = ((mouseY - containerRect.top) / containerRect.height) * 100\n      const xCenter =\n        ((boundsRect.left - containerRect.left + boundsRect.width / 2) / containerRect.width) * 100\n      const yCenter =\n        ((boundsRect.top - containerRect.top + boundsRect.height / 2) / containerRect.height) * 100\n      if (xOutOfBounds || yOutOfBounds) {\n        setIsDragging(false)\n        if (mouseX < boundsRect.left) {\n          x = ((boundsRect.left - containerRect.left) / containerRect.width) * 100\n        } else if (mouseX > boundsRect.right) {\n          x =\n            ((containerRect.width - (containerRect.right - boundsRect.right)) /\n              containerRect.width) *\n            100\n        }\n\n        if (mouseY < boundsRect.top) {\n          y = ((boundsRect.top - containerRect.top) / containerRect.height) * 100\n        } else if (mouseY > boundsRect.bottom) {\n          y =\n            ((containerRect.height - (containerRect.bottom - boundsRect.bottom)) /\n              containerRect.height) *\n            100\n        }\n\n        if (recenter) {\n          x = xOutOfBounds ? xCenter : x\n          y = yOutOfBounds ? yCenter : y\n        }\n      }\n\n      return { x, y }\n    },\n    [boundsRef, containerRef],\n  )\n\n  const handleMouseDown = (event) => {\n    event.preventDefault()\n    setIsDragging(true)\n  }\n\n  const handleMouseMove = (event) => {\n    if (!isDragging) return null\n    const { x, y } = getCoordinates(event.clientX, event.clientY)\n\n    setPosition({ x, y })\n  }\n\n  const onDrop = () => {\n    setIsDragging(false)\n    onDragEnd(position)\n  }\n\n  React.useEffect(() => {\n    if (isDragging || !dragRef.current) return\n    if (checkBounds) {\n      const { height, left, top, width } = dragRef.current.getBoundingClientRect()\n      const { x, y } = getCoordinates(left + width / 2, top + height / 2, true)\n      onDragEnd({ x, y })\n      setPosition({ x, y })\n      setCheckBounds(false)\n      return\n    }\n  }, [getCoordinates, isDragging, checkBounds, setCheckBounds, position.x, position.y, onDragEnd])\n\n  React.useEffect(() => {\n    setPosition({ x: initialPosition.x, y: initialPosition.y })\n  }, [initialPosition.x, initialPosition.y])\n\n  return (\n    <div\n      className={[\n        `${baseClass}__draggable-container`,\n        isDragging && `${baseClass}__draggable-container--dragging`,\n      ]\n        .filter(Boolean)\n        .join(' ')}\n      onMouseMove={handleMouseMove}\n    >\n      <button\n        className={[`${baseClass}__draggable`, className].filter(Boolean).join(' ')}\n        onMouseDown={handleMouseDown}\n        onMouseUp={onDrop}\n        ref={dragRef}\n        style={{ left: `${position.x}%`, top: `${position.y}%` }}\n        type=\"button\"\n      >\n        {children}\n      </button>\n      <div />\n    </div>\n  )\n}\n"],"names":["EditUpload","baseClass","Input","name","onChange","value","div","className","input","e","target","type","fileName","fileSrc","imageCacheTag","showCrop","showFocalPoint","closeModal","useModal","t","useTranslation","formQueryParams","setFormQueryParams","useFormQueryParams","uploadEdits","crop","setCrop","useState","height","unit","width","x","y","pointPosition","setPointPosition","focalPoint","checkBounds","setCheckBounds","originalHeight","setOriginalHeight","originalWidth","setOriginalWidth","focalWrapRef","useRef","imageRef","cropRef","fineTuneCrop","dimension","intValue","parseInt","percentage","fineTuneFocalPoint","coordinate","prevPosition","saveEdits","undefined","editDrawerSlug","onDragEnd","React","useCallback","centerFocalPoint","containerRect","current","getBoundingClientRect","boundsRect","xCenter","left","yCenter","top","fileSrcToUse","h2","title","Button","aria-label","buttonStyle","onClick","ref","style","aspectRatio","ReactCrop","_","c","onComplete","renderSelectionAddon","img","alt","onLoad","currentTarget","naturalHeight","naturalWidth","src","DraggableElement","boundsRef","containerRef","initialPosition","Plus","h3","span","toFixed","children","position","setPosition","isDragging","setIsDragging","dragRef","getCoordinates","mouseXArg","mouseYArg","recenter","mouseX","mouseY","xOutOfBounds","right","yOutOfBounds","bottom","handleMouseDown","event","preventDefault","handleMouseMove","clientX","clientY","onDrop","useEffect","filter","Boolean","join","onMouseMove","button","onMouseDown","onMouseUp"],"mappings":"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"}

package/dist/elements/ErrorPill/index.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ErrorPill", {
+    enumerable: true,
+    get: function() {
+        return ErrorPill;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_default(require("react"));
+require("./index.scss");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const baseClass = 'error-pill';
+const ErrorPill = (props)=>{
+    const { className, count, i18n, withMessage } = props;
+    const lessThan3Chars = !withMessage && count < 99;
+    const classes = [
+        baseClass,
+        lessThan3Chars && `${baseClass}--fixed-width`,
+        className && className
+    ].filter(Boolean).join(' ');
+    if (count === 0) return null;
+    return /*#__PURE__*/ _react.default.createElement("div", {
+        className: classes
+    }, /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__content`
+    }, /*#__PURE__*/ _react.default.createElement("span", {
+        className: `${baseClass}__count`
+    }, count), withMessage && ` ${count > 1 ? i18n.t('general:errors') : i18n.t('general:error')}`));
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/elements/ErrorPill/types.js

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

package/dist/elements/FieldSelect/index.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "FieldSelect", {
+    enumerable: true,
+    get: function() {
+        return FieldSelect;
+    }
+});
+const _translations = require("@payloadcms/translations");
+const _types = require("payload/types");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _context = require("../../forms/Form/context");
+const _createNestedFieldPath = require("../../forms/Form/createNestedFieldPath");
+const _Label = /*#__PURE__*/ _interop_require_default(require("../../forms/Label"));
+const _Translation = require("../../providers/Translation");
+const _ReactSelect = /*#__PURE__*/ _interop_require_default(require("../ReactSelect"));
+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 = 'field-select';
+const combineLabel = (prefix, field, i18n)=>`${prefix === '' ? '' : `${prefix} > `}${(0, _translations.getTranslation)(field.label || field.name, i18n) || ''}`;
+const reduceFields = (fields, i18n, path = '', labelPrefix = '')=>fields.reduce((fieldsToUse, field)=>{
+        // escape for a variety of reasons
+        if ((0, _types.fieldAffectsData)(field) && (field.admin?.disableBulkEdit || field.unique || field.hidden || field.admin?.hidden || field.admin?.readOnly)) {
+            return fieldsToUse;
+        }
+        if (!(field.type === 'array' || field.type === 'blocks') && (0, _types.fieldHasSubFields)(field)) {
+            return [
+                ...fieldsToUse,
+                ...reduceFields(field.fields, i18n, (0, _createNestedFieldPath.createNestedFieldPath)(path, field), combineLabel(labelPrefix, field, i18n))
+            ];
+        }
+        if (field.type === 'tabs') {
+            return [
+                ...fieldsToUse,
+                ...field.tabs.reduce((tabFields, tab)=>{
+                    return [
+                        ...tabFields,
+                        ...reduceFields(tab.fields, i18n, (0, _types.tabHasName)(tab) ? (0, _createNestedFieldPath.createNestedFieldPath)(path, field) : path, combineLabel(labelPrefix, field, i18n))
+                    ];
+                }, [])
+            ];
+        }
+        const formattedField = {
+            label: combineLabel(labelPrefix, field, i18n),
+            value: {
+                ...field,
+                path: (0, _createNestedFieldPath.createNestedFieldPath)(path, field)
+            }
+        };
+        return [
+            ...fieldsToUse,
+            formattedField
+        ];
+    }, []);
+const FieldSelect = ({ fields, setSelected })=>{
+    const { i18n, t } = (0, _Translation.useTranslation)();
+    const [options] = (0, _react.useState)(()=>reduceFields(fields, i18n));
+    const { dispatchFields, getFields } = (0, _context.useForm)();
+    const handleChange = (selected)=>{
+        const activeFields = getFields();
+        if (selected === null) {
+            setSelected([]);
+        } else {
+            setSelected(selected.map(({ value })=>value));
+        }
+        // remove deselected values from form state
+        if (selected === null || Object.keys(activeFields || []).length > selected.length) {
+            Object.keys(activeFields).forEach((path)=>{
+                if (selected === null || !selected.find((field)=>{
+                    return field.value.path === path;
+                })) {
+                    dispatchFields({
+                        type: 'REMOVE',
+                        path
+                    });
+                }
+            });
+        }
+    };
+    return /*#__PURE__*/ _react.default.createElement("div", {
+        className: baseClass
+    }, /*#__PURE__*/ _react.default.createElement(_Label.default, {
+        label: t('fields:selectFieldsToEdit')
+    }), /*#__PURE__*/ _react.default.createElement(_ReactSelect.default, {
+        isMulti: true,
+        onChange: handleChange,
+        options: options
+    }));
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/elements/FieldSelect/index.tsx"],"sourcesContent":["import type { Field, FieldWithPath } from 'payload/types'\n\nimport { getTranslation } from '@payloadcms/translations'\nimport { fieldAffectsData, fieldHasSubFields, tabHasName } from 'payload/types'\nimport React, { useState } from 'react'\n\nimport { useForm } from '../../forms/Form/context'\nimport { createNestedFieldPath } from '../../forms/Form/createNestedFieldPath'\nimport Label from '../../forms/Label'\nimport { useTranslation } from '../../providers/Translation'\nimport ReactSelect from '../ReactSelect'\nimport './index.scss'\n\nconst baseClass = 'field-select'\n\ntype Props = {\n  fields: Field[]\n  setSelected: (fields: FieldWithPath[]) => void\n}\n\nconst combineLabel = (prefix, field, i18n): string =>\n  `${prefix === '' ? '' : `${prefix} > `}${getTranslation(field.label || field.name, i18n) || ''}`\nconst reduceFields = (\n  fields: Field[],\n  i18n,\n  path = '',\n  labelPrefix = '',\n): { label: string; value: FieldWithPath }[] =>\n  fields.reduce((fieldsToUse, field) => {\n    // escape for a variety of reasons\n    if (\n      fieldAffectsData(field) &&\n      (field.admin?.disableBulkEdit ||\n        field.unique ||\n        field.hidden ||\n        field.admin?.hidden ||\n        field.admin?.readOnly)\n    ) {\n      return fieldsToUse\n    }\n    if (!(field.type === 'array' || field.type === 'blocks') && fieldHasSubFields(field)) {\n      return [\n        ...fieldsToUse,\n        ...reduceFields(\n          field.fields,\n          i18n,\n          createNestedFieldPath(path, field),\n          combineLabel(labelPrefix, field, i18n),\n        ),\n      ]\n    }\n    if (field.type === 'tabs') {\n      return [\n        ...fieldsToUse,\n        ...field.tabs.reduce((tabFields, tab) => {\n          return [\n            ...tabFields,\n            ...reduceFields(\n              tab.fields,\n              i18n,\n              tabHasName(tab) ? createNestedFieldPath(path, field) : path,\n              combineLabel(labelPrefix, field, i18n),\n            ),\n          ]\n        }, []),\n      ]\n    }\n    const formattedField = {\n      label: combineLabel(labelPrefix, field, i18n),\n      value: {\n        ...field,\n        path: createNestedFieldPath(path, field),\n      },\n    }\n\n    return [...fieldsToUse, formattedField]\n  }, [])\nexport const FieldSelect: React.FC<Props> = ({ fields, setSelected }) => {\n  const { i18n, t } = useTranslation()\n  const [options] = useState(() => reduceFields(fields, i18n))\n  const { dispatchFields, getFields } = useForm()\n  const handleChange = (selected) => {\n    const activeFields = getFields()\n    if (selected === null) {\n      setSelected([])\n    } else {\n      setSelected(selected.map(({ value }) => value))\n    }\n    // remove deselected values from form state\n    if (selected === null || Object.keys(activeFields || []).length > selected.length) {\n      Object.keys(activeFields).forEach((path) => {\n        if (\n          selected === null ||\n          !selected.find((field) => {\n            return field.value.path === path\n          })\n        ) {\n          dispatchFields({\n            type: 'REMOVE',\n            path,\n          })\n        }\n      })\n    }\n  }\n\n  return (\n    <div className={baseClass}>\n      <Label label={t('fields:selectFieldsToEdit')} />\n      <ReactSelect isMulti onChange={handleChange} options={options} />\n    </div>\n  )\n}\n"],"names":["FieldSelect","baseClass","combineLabel","prefix","field","i18n","getTranslation","label","name","reduceFields","fields","path","labelPrefix","reduce","fieldsToUse","fieldAffectsData","admin","disableBulkEdit","unique","hidden","readOnly","type","fieldHasSubFields","createNestedFieldPath","tabs","tabFields","tab","tabHasName","formattedField","value","setSelected","t","useTranslation","options","useState","dispatchFields","getFields","useForm","handleChange","selected","activeFields","map","Object","keys","length","forEach","find","div","className","Label","ReactSelect","isMulti","onChange"],"mappings":"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"}