payload 1.15.8 → 1.15.9

package/packages/payload/dist/admin/components/elements/EditUpload/index.js

@@ -0,0 +1,406 @@
+"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 _reacti18next = require("react-i18next");
+const _reactimagecrop = /*#__PURE__*/ _interop_require_default(require("react-image-crop"));
+require("react-image-crop/dist/ReactCrop.css");
+const _Plus = /*#__PURE__*/ _interop_require_default(require("../../icons/Plus"));
+const _Upload = require("../../views/collections/Edit/Upload");
+const _Button = /*#__PURE__*/ _interop_require_default(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 = /*#__PURE__*/ (0, _react.forwardRef)((props, ref)=>{
+    const { name, onChange, value } = props;
+    return /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__input`
+    }, name, /*#__PURE__*/ _react.default.createElement("input", {
+        name: name,
+        onChange: (e)=>onChange(e.target.value),
+        ref: ref,
+        type: "number",
+        value: value
+    }));
+});
+const defaultCrop = {
+    height: 100,
+    unit: '%',
+    width: 100,
+    x: 0,
+    y: 0
+};
+const EditUpload = ({ fileName, fileSrc, imageCacheTag, initialCrop, initialFocalPoint, onSave, showCrop, showFocalPoint })=>{
+    const { closeModal } = (0, _modal.useModal)();
+    const { t } = (0, _reacti18next.useTranslation)([
+        'general',
+        'upload'
+    ]);
+    const [crop, setCrop] = (0, _react.useState)(()=>({
+            ...defaultCrop,
+            ...initialCrop || {}
+        }));
+    const defaultFocalPosition = {
+        x: 50,
+        y: 50
+    };
+    const [focalPosition, setFocalPosition] = (0, _react.useState)(()=>({
+            ...defaultFocalPosition,
+            ...initialFocalPoint
+        }));
+    const [checkBounds, setCheckBounds] = (0, _react.useState)(false);
+    const [uncroppedPixelHeight, setUncroppedPixelHeight] = (0, _react.useState)(0);
+    const [uncroppedPixelWidth, setUncroppedPixelWidth] = (0, _react.useState)(0);
+    const focalWrapRef = (0, _react.useRef)();
+    const imageRef = (0, _react.useRef)();
+    const cropRef = (0, _react.useRef)();
+    const heightInputRef = (0, _react.useRef)(null);
+    const widthInputRef = (0, _react.useRef)(null);
+    const [imageLoaded, setImageLoaded] = (0, _react.useState)(false);
+    const onImageLoad = (e)=>{
+        // set the default image height/width on load
+        setUncroppedPixelHeight(e.currentTarget.naturalHeight);
+        setUncroppedPixelWidth(e.currentTarget.naturalWidth);
+        setImageLoaded(true);
+    };
+    const fineTuneCrop = ({ dimension, value })=>{
+        const intValue = parseInt(value);
+        if (dimension === 'width' && intValue >= uncroppedPixelWidth) return null;
+        if (dimension === 'height' && intValue >= uncroppedPixelHeight) return null;
+        const percentage = 100 * (intValue / (dimension === 'width' ? uncroppedPixelWidth : uncroppedPixelHeight));
+        if (percentage === 100 || percentage === 0) return null;
+        setCrop({
+            ...crop,
+            [dimension]: percentage
+        });
+    };
+    const fineTuneFocalPosition = ({ coordinate, value })=>{
+        const intValue = parseInt(value);
+        if (intValue >= 0 && intValue <= 100) {
+            setFocalPosition((prevPosition)=>({
+                    ...prevPosition,
+                    [coordinate]: intValue
+                }));
+        }
+    };
+    const saveEdits = ()=>{
+        if (typeof onSave === 'function') onSave({
+            crop: crop ? crop : undefined,
+            focalPoint: focalPosition,
+            heightInPixels: Number(heightInputRef?.current?.value ?? uncroppedPixelHeight),
+            widthInPixels: Number(widthInputRef?.current?.value ?? uncroppedPixelWidth)
+        });
+        closeModal(_Upload.editDrawerSlug);
+    };
+    const onDragEnd = _react.default.useCallback(({ x, y })=>{
+        setFocalPosition({
+            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;
+        setFocalPosition({
+            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.default, {
+        "aria-label": t('cancel'),
+        buttonStyle: "secondary",
+        className: `${baseClass}__cancel`,
+        onClick: ()=>closeModal(_Upload.editDrawerSlug)
+    }, t('general:cancel')), /*#__PURE__*/ _react.default.createElement(_Button.default, {
+        "aria-label": t('general:applyChanges'),
+        buttonStyle: "primary",
+        className: `${baseClass}__save`,
+        disabled: !imageLoaded,
+        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: `${uncroppedPixelWidth / uncroppedPixelHeight}`
+        }
+    }, 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: onImageLoad,
+        ref: imageRef,
+        src: fileSrcToUse
+    })) : /*#__PURE__*/ _react.default.createElement("img", {
+        alt: t('upload:setFocalPoint'),
+        onLoad: onImageLoad,
+        ref: imageRef,
+        src: fileSrcToUse
+    }), showFocalPoint && /*#__PURE__*/ _react.default.createElement(DraggableElement, {
+        boundsRef: showCrop ? cropRef : imageRef,
+        checkBounds: showCrop ? checkBounds : false,
+        className: `${baseClass}__focalPoint`,
+        containerRef: focalWrapRef,
+        initialPosition: focalPosition,
+        onDragEnd: onDragEnd,
+        setCheckBounds: showCrop ? setCheckBounds : false
+    }, /*#__PURE__*/ _react.default.createElement(_Plus.default, 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.default, {
+        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
+            }),
+        ref: widthInputRef,
+        value: (crop.width / 100 * uncroppedPixelWidth).toFixed(0)
+    }), /*#__PURE__*/ _react.default.createElement(Input, {
+        name: `${t('upload:height')} (px)`,
+        onChange: (value)=>fineTuneCrop({
+                dimension: 'height',
+                value
+            }),
+        ref: heightInputRef,
+        value: (crop.height / 100 * uncroppedPixelHeight).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.default, {
+        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)=>fineTuneFocalPosition({
+                coordinate: 'x',
+                value
+            }),
+        value: focalPosition.x.toFixed(0)
+    }), /*#__PURE__*/ _react.default.createElement(Input, {
+        name: "Y %",
+        onChange: (value)=>fineTuneFocalPosition({
+                coordinate: 'y',
+                value
+            }),
+        value: focalPosition.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/admin/components/elements/EditUpload/index.tsx"],"sourcesContent":["import { useModal } from '@faceless-ui/modal'\nimport React, { forwardRef, useRef, useState } from 'react'\nimport { useTranslation } from 'react-i18next'\nimport ReactCrop from 'react-image-crop'\nimport 'react-image-crop/dist/ReactCrop.css'\n\nimport type { UploadEdits } from '../../../../uploads/types'\n\nimport Plus from '../../icons/Plus'\nimport { editDrawerSlug } from '../../views/collections/Edit/Upload'\nimport Button from '../Button'\nimport './index.scss'\n\nconst baseClass = 'edit-upload'\n\ntype Props = {\n  name: string\n  onChange: (value: string) => void\n  value: string\n}\n\nconst Input = forwardRef<HTMLInputElement, Props>((props, ref) => {\n  const { name, onChange, value } = props\n\n  return (\n    <div className={`${baseClass}__input`}>\n      {name}\n      <input\n        name={name}\n        onChange={(e) => onChange(e.target.value)}\n        ref={ref}\n        type=\"number\"\n        value={value}\n      />\n    </div>\n  )\n})\n\ntype FocalPosition = {\n  x: number\n  y: number\n}\n\nexport type EditUploadProps = {\n  fileName: string\n  fileSrc: string\n  imageCacheTag?: string\n  initialCrop?: UploadEdits['crop']\n  initialFocalPoint?: FocalPosition\n  onSave?: (uploadEdits: UploadEdits) => void\n  showCrop?: boolean\n  showFocalPoint?: boolean\n}\n\nconst defaultCrop: UploadEdits['crop'] = {\n  height: 100,\n  unit: '%',\n  width: 100,\n  x: 0,\n  y: 0,\n}\n\nexport const EditUpload: React.FC<EditUploadProps> = ({\n  fileName,\n  fileSrc,\n  imageCacheTag,\n  initialCrop,\n  initialFocalPoint,\n  onSave,\n  showCrop,\n  showFocalPoint,\n}) => {\n  const { closeModal } = useModal()\n  const { t } = useTranslation(['general', 'upload'])\n\n  const [crop, setCrop] = useState<UploadEdits['crop']>(() => ({\n    ...defaultCrop,\n    ...(initialCrop || {}),\n  }))\n\n  const defaultFocalPosition: FocalPosition = {\n    x: 50,\n    y: 50,\n  }\n\n  const [focalPosition, setFocalPosition] = useState<FocalPosition>(() => ({\n    ...defaultFocalPosition,\n    ...initialFocalPoint,\n  }))\n\n  const [checkBounds, setCheckBounds] = useState<boolean>(false)\n  const [uncroppedPixelHeight, setUncroppedPixelHeight] = useState<number>(0)\n  const [uncroppedPixelWidth, setUncroppedPixelWidth] = 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 heightInputRef = useRef<HTMLInputElement | null>(null)\n  const widthInputRef = useRef<HTMLInputElement | null>(null)\n\n  const [imageLoaded, setImageLoaded] = useState<boolean>(false)\n\n  const onImageLoad = (e) => {\n    // set the default image height/width on load\n    setUncroppedPixelHeight(e.currentTarget.naturalHeight)\n    setUncroppedPixelWidth(e.currentTarget.naturalWidth)\n    setImageLoaded(true)\n  }\n\n  const fineTuneCrop = ({ dimension, value }: { dimension: 'height' | 'width'; value: string }) => {\n    const intValue = parseInt(value)\n    if (dimension === 'width' && intValue >= uncroppedPixelWidth) return null\n    if (dimension === 'height' && intValue >= uncroppedPixelHeight) return null\n\n    const percentage =\n      100 * (intValue / (dimension === 'width' ? uncroppedPixelWidth : uncroppedPixelHeight))\n\n    if (percentage === 100 || percentage === 0) return null\n\n    setCrop({\n      ...crop,\n      [dimension]: percentage,\n    })\n  }\n\n  const fineTuneFocalPosition = ({\n    coordinate,\n    value,\n  }: {\n    coordinate: 'x' | 'y'\n    value: string\n  }) => {\n    const intValue = parseInt(value)\n    if (intValue >= 0 && intValue <= 100) {\n      setFocalPosition((prevPosition) => ({ ...prevPosition, [coordinate]: intValue }))\n    }\n  }\n\n  const saveEdits = () => {\n    if (typeof onSave === 'function')\n      onSave({\n        crop: crop ? crop : undefined,\n        focalPoint: focalPosition,\n        heightInPixels: Number(heightInputRef?.current?.value ?? uncroppedPixelHeight),\n        widthInPixels: Number(widthInputRef?.current?.value ?? uncroppedPixelWidth),\n      })\n    closeModal(editDrawerSlug)\n  }\n\n  const onDragEnd = React.useCallback(({ x, y }) => {\n    setFocalPosition({ 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    setFocalPosition({ 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('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            disabled={!imageLoaded}\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: `${uncroppedPixelWidth / uncroppedPixelHeight}`,\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={onImageLoad}\n                  ref={imageRef}\n                  src={fileSrcToUse}\n                />\n              </ReactCrop>\n            ) : (\n              <img\n                alt={t('upload:setFocalPoint')}\n                onLoad={onImageLoad}\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={focalPosition}\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                    ref={widthInputRef}\n                    value={((crop.width / 100) * uncroppedPixelWidth).toFixed(0)}\n                  />\n                  <Input\n                    name={`${t('upload:height')} (px)`}\n                    onChange={(value) => fineTuneCrop({ dimension: 'height', value })}\n                    ref={heightInputRef}\n                    value={((crop.height / 100) * uncroppedPixelHeight).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) => fineTuneFocalPosition({ coordinate: 'x', value })}\n                    value={focalPosition.x.toFixed(0)}\n                  />\n                  <Input\n                    name=\"Y %\"\n                    onChange={(value) => fineTuneFocalPosition({ coordinate: 'y', value })}\n                    value={focalPosition.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","forwardRef","props","ref","name","onChange","value","div","className","input","e","target","type","defaultCrop","height","unit","width","x","y","fileName","fileSrc","imageCacheTag","initialCrop","initialFocalPoint","onSave","showCrop","showFocalPoint","closeModal","useModal","t","useTranslation","crop","setCrop","useState","defaultFocalPosition","focalPosition","setFocalPosition","checkBounds","setCheckBounds","uncroppedPixelHeight","setUncroppedPixelHeight","uncroppedPixelWidth","setUncroppedPixelWidth","focalWrapRef","useRef","imageRef","cropRef","heightInputRef","widthInputRef","imageLoaded","setImageLoaded","onImageLoad","currentTarget","naturalHeight","naturalWidth","fineTuneCrop","dimension","intValue","parseInt","percentage","fineTuneFocalPosition","coordinate","prevPosition","saveEdits","undefined","focalPoint","heightInPixels","Number","current","widthInPixels","editDrawerSlug","onDragEnd","React","useCallback","centerFocalPoint","containerRect","getBoundingClientRect","boundsRect","xCenter","left","yCenter","top","fileSrcToUse","h2","title","Button","aria-label","buttonStyle","onClick","disabled","style","aspectRatio","ReactCrop","_","c","onComplete","renderSelectionAddon","img","alt","onLoad","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"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}