@strapi/upload 5.60.0 → 5.61.0

package/dist/admin/pages/Assets/components/AssetDetails/AssetCropEditor.mjs

@@ -1,10 +1,10 @@
 import { jsx, jsxs } from 'react/jsx-runtime';
 import * as React from 'react';
 import { useNotification } from '@strapi/admin/strapi-admin';
-import { Portal, FocusTrap, Typography, IconButton, Flex, Field, Button, Box, NumberInput } from '@strapi/design-system';
+import { Flex, Box, Field, NumberInput, Portal, FocusTrap, Typography, IconButton, Button } from '@strapi/design-system';
 import { Crop, ArrowClockwise, ArrowsHorizontal, ArrowsVertical, Link } from '@strapi/icons';
 import { useIntl } from 'react-intl';
-import { useTheme, styled } from 'styled-components';
+import { styled, useTheme } from 'styled-components';
 import { prefixFileUrlWithBackendUrl } from '../../../../utils/files.mjs';
 import { getTranslationKey } from '../../../../utils/translations.mjs';
 import { useCropImg, resolveCornerResize } from './useCropImg.mjs';

package/dist/admin/pages/Assets/components/AssetDetails/AssetDetailsDrawer.js

@@ -64,35 +64,12 @@ const useAssetOperation = ()=>{
     return ctx;
 };
 /* -------------------------------------------------------------------------------------------------
- * useAssetDetailsParam - sync drawer visibility with URL ?{ASSET_DETAILS_URL_PARAM}={id}
+ * useAssetDetailsParam - read and write the open asset in URL ?{ASSET_DETAILS_URL_PARAM}={id}
  * -----------------------------------------------------------------------------------------------*/ const useAssetDetailsParam = ()=>{
     const [{ query }, setQuery] = strapiAdmin.useQueryParams();
     const assetId = useIsAssetDetailsOpen.parseAssetDetailsId(query?.[useIsAssetDetailsOpen.ASSET_DETAILS_URL_PARAM]);
-    const hasValidId = assetId !== null;
     // Closing is driven by removing the URL param (a navigation), so navigation
-    // guards like <Blocker> can intercept it. `isMounted` keeps the drawer in the
-    // tree through the slide-out: it stays true once opened and only flips false
-    // when the close animation actually ends (see onCloseAnimationEnd), so the
-    // close duration lives entirely in CSS — no JS timer.
-    const [isMounted, setIsMounted] = React__namespace.useState(hasValidId);
-    const displayAssetId = React__namespace.useRef(null);
-    React__namespace.useEffect(()=>{
-        if (hasValidId) {
-            displayAssetId.current = assetId;
-            setIsMounted(true);
-        }
-    }, [
-        hasValidId,
-        assetId
-    ]);
-    const onCloseAnimationEnd = React__namespace.useCallback((event)=>{
-        // Ignore animations bubbling up from descendants, and the slide-in.
-        if (event.target === event.currentTarget && !hasValidId) {
-            setIsMounted(false);
-        }
-    }, [
-        hasValidId
-    ]);
+    // guards like <Blocker> can intercept it.
     const openDetails = React__namespace.useCallback((id)=>{
         setQuery(strapiAdmin.withEncodedUserParams(query, {
             [useIsAssetDetailsOpen.ASSET_DETAILS_URL_PARAM]: String(id)
@@ -110,14 +87,44 @@ const useAssetOperation = ()=>{
         setQuery
     ]);
     return {
-        assetId: hasValidId ? assetId : displayAssetId.current,
-        isVisible: hasValidId,
-        shouldRenderDrawer: isMounted,
-        onCloseAnimationEnd,
+        assetId,
         openDetails,
         closeDetails
     };
 };
+/* -------------------------------------------------------------------------------------------------
+ * useDrawerPresence - keep the drawer mounted through its slide-out
+ * -----------------------------------------------------------------------------------------------*/ const useDrawerPresence = (assetId)=>{
+    const isVisible = assetId !== null;
+    // `isMounted` stays true once opened and only flips false when the close
+    // animation actually ends (see onCloseAnimationEnd), so the close duration
+    // lives entirely in CSS — no JS timer. The last id is kept so the content
+    // doesn't go blank mid-slide.
+    const [isMounted, setIsMounted] = React__namespace.useState(isVisible);
+    const displayAssetId = React__namespace.useRef(assetId);
+    React__namespace.useEffect(()=>{
+        if (assetId !== null) {
+            displayAssetId.current = assetId;
+            setIsMounted(true);
+        }
+    }, [
+        assetId
+    ]);
+    const onCloseAnimationEnd = React__namespace.useCallback((event)=>{
+        // Ignore animations bubbling up from descendants, and the slide-in.
+        if (event.target === event.currentTarget && !isVisible) {
+            setIsMounted(false);
+        }
+    }, [
+        isVisible
+    ]);
+    return {
+        displayAssetId: isVisible ? assetId : displayAssetId.current,
+        isVisible,
+        shouldRender: isMounted,
+        onCloseAnimationEnd
+    };
+};
 const DetailItemContainer = styledComponents.styled(designSystem.Flex)`
   flex: 0 0 calc(50% - ${({ theme })=>theme.spaces[2]});
 `;
@@ -213,13 +220,14 @@ const DetailField = ({ name, label, required, disabled })=>{
     const { formatMessage } = reactIntl.useIntl();
     const field = strapiAdmin.useField(name);
     const isSubmitting = strapiAdmin.useForm('DetailField', (state)=>state.isSubmitting);
-    // The form context (use-context-selector) echoes changes back
-    // asynchronously — driving the input straight from `field.value` makes
-    // React rewrite the DOM value after the keystroke, which throws the cursor
-    // to the end of the field. The input is therefore controlled by local state
-    // (synchronous, cursor-safe) and the form follows; the effect below only
-    // matters for EXTERNAL value changes (discard/reset), where a cursor jump
-    // is fine because the user isn't typing.
+    // The input is controlled by local state (synchronous, cursor-safe) and the
+    // form follows. This was needed when the form context echoed changes back
+    // asynchronously: driving the input straight from `field.value` made React
+    // rewrite the DOM value after the keystroke, which threw the cursor to the
+    // end of the field. The form context now updates synchronously, but the
+    // local state is kept as a safe default. The effect below only matters for
+    // EXTERNAL value changes (discard/reset), where a cursor jump is fine
+    // because the user isn't typing.
     const fieldValue = field.value ?? '';
     const [value, setValue] = React__namespace.useState(fieldValue);
     React__namespace.useEffect(()=>{
@@ -562,7 +570,26 @@ const AssetImageActions = ({ onCrop })=>{
         })
     });
 };
-const AssetDetails = ({ asset, closeDetails })=>{
+/* -------------------------------------------------------------------------------------------------
+ * AssetDetails
+ * -----------------------------------------------------------------------------------------------*/ /**
+ * Writes whether the form has unsaved edits into the drawer's ref. Only the
+ * drawer's close handlers read it, so a ref rather than state: toggling dirty
+ * doesn't re-render the drawer. A component, not a hook, because the form state
+ * is only reachable inside <Form>'s render prop.
+ */ const ReportUnsavedEdits = ({ target, hasUnsavedEdits })=>{
+    React__namespace.useLayoutEffect(()=>{
+        target.current = hasUnsavedEdits;
+        return ()=>{
+            target.current = false;
+        };
+    }, [
+        target,
+        hasUnsavedEdits
+    ]);
+    return null;
+};
+const AssetDetails = ({ asset, closeDetails, hasUnsavedEditsRef, guardNavigation = false, onAssetChange, onAssetDelete, trackedLocation = useTracking.MEDIA_LIBRARY_LOCATION })=>{
     const { formatMessage, formatDate } = reactIntl.useIntl();
     const getErrorMessage = useApiErrorMessage.useApiErrorMessage();
     const { canCreate, canUpdate, canDownload, canCopyLink } = useMediaLibraryPermissions.useMediaLibraryPermissions();
@@ -587,13 +614,21 @@ const AssetDetails = ({ asset, closeDetails })=>{
     // own handlers (replace, update) read like the consumers do.
     const notify = React__namespace.useCallback((toast)=>setDrawerToast(toast), []);
     const isImage = asset.mime?.includes(enums.ASSET_TYPES.Image);
-    const initialValues = {
-        name: asset.name ?? '',
-        caption: asset.caption ?? '',
-        alternativeText: asset.alternativeText ?? '',
-        folder: typeof asset.folder === 'object' && asset.folder !== null ? asset.folder.id ?? null : asset.folder ?? null
-    };
-    const handleSubmit = async (values)=>{
+    // Stable until the asset changes: <Form> resets its values whenever this
+    // object does, which on every render would throw away the baseline a save
+    // sets and show the pre-save values until the refetch lands.
+    const initialValues = React__namespace.useMemo(()=>({
+            name: asset.name ?? '',
+            caption: asset.caption ?? '',
+            alternativeText: asset.alternativeText ?? '',
+            folder: typeof asset.folder === 'object' && asset.folder !== null ? asset.folder.id ?? null : asset.folder ?? null
+        }), [
+        asset.name,
+        asset.caption,
+        asset.alternativeText,
+        asset.folder
+    ]);
+    const handleSubmit = async (values, { resetForm })=>{
         const fileInfo = {
             name: values.name,
             caption: values.caption,
@@ -614,8 +649,13 @@ const AssetDetails = ({ asset, closeDetails })=>{
             });
             return;
         }
+        // What was saved is the new baseline. Otherwise the form stays "modified"
+        // until the refetched asset resets it, and closing in that gap asks about
+        // edits that are already saved.
+        resetForm(values);
+        onAssetChange?.(res.data);
         trackUsage('didEditMediaLibraryElements', {
-            location: useTracking.MEDIA_LIBRARY_LOCATION,
+            location: trackedLocation,
             // Legacy sends the mime top-level type (image/video/audio/application…).
             type: asset.mime?.split('/')[0],
             changeLocation: values.folder !== initialValues.folder
@@ -648,8 +688,9 @@ const AssetDetails = ({ asset, closeDetails })=>{
             });
             return;
         }
+        onAssetChange?.(res.data);
         trackUsage('didReplaceMedia', {
-            location: useTracking.MEDIA_LIBRARY_LOCATION
+            location: trackedLocation
         });
         notify({
             type: 'success',
@@ -664,7 +705,9 @@ const AssetDetails = ({ asset, closeDetails })=>{
         formatMessage,
         getErrorMessage,
         notify,
+        onAssetChange,
         replaceMutation,
+        trackedLocation,
         trackUsage
     ]);
     // Owns the delete: on error notify in-drawer (drawer stays), on success fire
@@ -690,6 +733,7 @@ const AssetDetails = ({ asset, closeDetails })=>{
                 folderName
             })
         });
+        onAssetDelete?.(asset.id);
         closeDetails();
     }, [
         asset.id,
@@ -699,6 +743,7 @@ const AssetDetails = ({ asset, closeDetails })=>{
         formatMessage,
         getErrorMessage,
         notify,
+        onAssetDelete,
         toggleNotification
     ]);
     const notifyCropError = (error)=>{
@@ -726,8 +771,9 @@ const AssetDetails = ({ asset, closeDetails })=>{
             notifyCropError(res.error);
             return;
         }
+        onAssetChange?.(res.data);
         trackUsage('didCropFile', {
-            location: useTracking.MEDIA_LIBRARY_LOCATION,
+            location: trackedLocation,
             duplicatedFile: false
         });
         notify({
@@ -739,6 +785,7 @@ const AssetDetails = ({ asset, closeDetails })=>{
         });
     };
     // Save as copy: upload the cropped file as a new asset in the same folder.
+    // The original is untouched, so `onAssetChange` stays silent.
     const handleCropSaveAsCopy = async (file, focalPoint)=>{
         setIsCropOpen(false);
         // Silent single-file upload (no global progress dialog). Carry over the
@@ -758,7 +805,7 @@ const AssetDetails = ({ asset, closeDetails })=>{
             return;
         }
         trackUsage('didCropFile', {
-            location: useTracking.MEDIA_LIBRARY_LOCATION,
+            location: trackedLocation,
             duplicatedFile: true
         });
         notify({
@@ -800,9 +847,12 @@ const AssetDetails = ({ asset, closeDetails })=>{
                         });
                         return /*#__PURE__*/ jsxRuntime.jsxs(jsxRuntime.Fragment, {
                             children: [
-                                /*#__PURE__*/ jsxRuntime.jsx(strapiAdmin.Blocker, {
+                                guardNavigation ? /*#__PURE__*/ jsxRuntime.jsx(strapiAdmin.Blocker, {
                                     onProceed: resetForm
-                                }),
+                                }) : hasUnsavedEditsRef ? /*#__PURE__*/ jsxRuntime.jsx(ReportUnsavedEdits, {
+                                    target: hasUnsavedEditsRef,
+                                    hasUnsavedEdits: modified && !isSubmitting
+                                }) : null,
                                 isCropOpen && isImage ? /*#__PURE__*/ jsxRuntime.jsx(AssetCropEditor.AssetCropEditor, {
                                     asset: asset,
                                     onClose: ()=>setIsCropOpen(false),
@@ -1060,7 +1110,7 @@ const DrawerHeader = ({ asset, closeDetails })=>{
         ]
     });
 };
-const DrawerContent = ({ assetId, closeDetails })=>{
+const DrawerContent = ({ assetId, requestClose, closeDetails, hasUnsavedEditsRef, guardNavigation, onAssetChange, onAssetDelete, trackedLocation })=>{
     const { formatMessage } = reactIntl.useIntl();
     const { data: asset, isLoading, error } = assets.useGetAssetQuery(assetId, {
         refetchOnMountOrArgChange: false,
@@ -1091,7 +1141,7 @@ const DrawerContent = ({ assetId, closeDetails })=>{
                     id: 'global.close',
                     defaultMessage: 'Close'
                 }),
-                onClose: closeDetails,
+                onClose: requestClose,
                 children: formatMessage({
                     id: translations.getTranslationKey('asset-details.error'),
                     defaultMessage: 'Failed to load file details.'
@@ -1103,11 +1153,16 @@ const DrawerContent = ({ assetId, closeDetails })=>{
         children: [
             /*#__PURE__*/ jsxRuntime.jsx(DrawerHeader, {
                 asset: asset,
-                closeDetails: closeDetails
+                closeDetails: requestClose
             }),
             /*#__PURE__*/ jsxRuntime.jsx(AssetDetails, {
                 asset: asset,
-                closeDetails: closeDetails
+                closeDetails: closeDetails,
+                hasUnsavedEditsRef: hasUnsavedEditsRef,
+                guardNavigation: guardNavigation,
+                onAssetChange: onAssetChange,
+                onAssetDelete: onAssetDelete,
+                trackedLocation: trackedLocation
             })
         ]
     });
@@ -1140,15 +1195,29 @@ const DrawerContent = ({ assetId, closeDetails })=>{
     // and stop the card's click, so no switch follows and the press dismisses.
     return event.target.closest(constants.ASSET_DETAILS_TRIGGER_SELECTOR) !== null && event.target.closest(constants.ASSET_ITEM_CONTROL_SELECTOR) === null;
 };
-const AssetDetailsDrawer = ()=>{
+const AssetDetailsDrawer = ({ assetId, onClose, guardNavigation = false, onAssetChange, onAssetDelete, trackedLocation })=>{
     const { formatMessage } = reactIntl.useIntl();
-    const { assetId, isVisible, shouldRenderDrawer, onCloseAnimationEnd, closeDetails } = useAssetDetailsParam();
-    if (!shouldRenderDrawer || assetId === null) {
+    const { displayAssetId, isVisible, shouldRender, onCloseAnimationEnd } = useDrawerPresence(assetId);
+    const hasUnsavedEditsRef = React__namespace.useRef(false);
+    const [isConfirmingClose, setIsConfirmingClose] = React__namespace.useState(false);
+    // Where focus was when the drawer opened — the card or the field's edit
+    // button — so closing can hand it back instead of dropping it on <body>.
+    const returnFocusRef = React__namespace.useRef(null);
+    const requestClose = React__namespace.useCallback(()=>{
+        if (hasUnsavedEditsRef.current) {
+            setIsConfirmingClose(true);
+            return;
+        }
+        onClose();
+    }, [
+        onClose
+    ]);
+    if (!shouldRender || displayAssetId === null) {
         return null;
     }
     return /*#__PURE__*/ jsxRuntime.jsxs(Drawer.Drawer.Root, {
         isVisible: isVisible,
-        onClose: closeDetails,
+        onClose: requestClose,
         children: [
             /*#__PURE__*/ jsxRuntime.jsx("div", {
                 children: /*#__PURE__*/ jsxRuntime.jsxs(designSystem.VisuallyHidden, {
@@ -1168,7 +1237,7 @@ const AssetDetailsDrawer = ()=>{
                     ]
                 })
             }),
-            /*#__PURE__*/ jsxRuntime.jsx(Drawer.Drawer.Body, {
+            /*#__PURE__*/ jsxRuntime.jsxs(Drawer.Drawer.Body, {
                 animationDirection: "left",
                 width: "41.6rem",
                 // dvh, not vh: the drawer is anchored to the bottom, so with 100vh on
@@ -1177,24 +1246,71 @@ const AssetDetailsDrawer = ()=>{
                 // off-screen. dvh tracks the actual visible height.
                 height: "100dvh",
                 onAnimationEnd: onCloseAnimationEnd,
-                // Opt in to dismiss-on-outside-click; `closeDetails` is the same path
-                // as the header's close button, so unsaved edits are still guarded.
+                // Runs before focus moves in, so this is still the element that opened it.
+                onOpenAutoFocus: ()=>{
+                    returnFocusRef.current = document.activeElement instanceof HTMLElement ? document.activeElement : null;
+                },
+                // By now the panel is gone: focus is on <body> unless the user moved it
+                // somewhere — a press on another control dismissed the drawer — and that
+                // choice wins.
+                onCloseAutoFocus: (event)=>{
+                    const target = returnFocusRef.current;
+                    const active = document.activeElement;
+                    if (target?.isConnected && (active === null || active === document.body)) {
+                        event.preventDefault();
+                        target.focus();
+                    }
+                },
+                // Opt in to dismiss-on-outside-click; it goes through `requestClose`,
+                // like the header's close button, so unsaved edits are still guarded.
                 onPointerDownOutside: (event)=>{
                     if (shouldKeepDrawerOpen(event, isVisible)) {
                         event.preventDefault();
                     }
                 },
-                children: /*#__PURE__*/ jsxRuntime.jsx(DrawerContent, {
-                    assetId: assetId,
-                    closeDetails: closeDetails
-                })
+                children: [
+                    /*#__PURE__*/ jsxRuntime.jsx(DrawerContent, {
+                        assetId: displayAssetId,
+                        requestClose: requestClose,
+                        closeDetails: onClose,
+                        hasUnsavedEditsRef: hasUnsavedEditsRef,
+                        guardNavigation: guardNavigation,
+                        onAssetChange: onAssetChange,
+                        onAssetDelete: onAssetDelete,
+                        trackedLocation: trackedLocation
+                    }),
+                    /*#__PURE__*/ jsxRuntime.jsx(designSystem.Dialog.Root, {
+                        open: isConfirmingClose,
+                        onOpenChange: setIsConfirmingClose,
+                        children: /*#__PURE__*/ jsxRuntime.jsx(strapiAdmin.ConfirmDialog, {
+                            onConfirm: onClose,
+                            variant: "danger",
+                            children: formatMessage({
+                                id: translations.getTranslationKey('asset-details.unsaved.confirm'),
+                                defaultMessage: "You have unsaved changes, are you sure you want to close this file's details? Your changes will be lost."
+                            })
+                        })
+                    })
+                ]
             })
         ]
     });
 };
+/**
+ * The drawer bound to the URL's `?assetId=`, as the Media Library page uses it:
+ * linkable, survives a refresh, and closing is a navigation.
+ */ const AssetDetailsDrawerFromUrl = ()=>{
+    const { assetId, closeDetails } = useAssetDetailsParam();
+    return /*#__PURE__*/ jsxRuntime.jsx(AssetDetailsDrawer, {
+        assetId: assetId,
+        onClose: closeDetails,
+        guardNavigation: true
+    });
+};
 
 exports.AssetDetails = AssetDetails;
 exports.AssetDetailsDrawer = AssetDetailsDrawer;
+exports.AssetDetailsDrawerFromUrl = AssetDetailsDrawerFromUrl;
 exports.AssetOperationsContext = AssetOperationsContext;
 exports.DrawerNotifyContext = DrawerNotifyContext;
 exports.getBusyMessage = getBusyMessage;