@strapi/upload 5.56.0 → 5.57.0

package/dist/admin/src/pages/Assets/components/AssetContextMenu.d.ts

@@ -0,0 +1,27 @@
+import { type AssetActionPermissions } from './AssetActions';
+import { type CursorPosition } from './CursorAnchoredMenu';
+import type { File } from '../../../../../shared/contracts/files';
+import type { DragFileData } from '../../../types/dnd';
+interface AssetContextMenuProps {
+    asset: File;
+    dragData: DragFileData;
+    /** Resolved by the provider, so this menu never renders while RBAC loads. */
+    permissions: AssetActionPermissions;
+    position: CursorPosition;
+    returnFocusTo: HTMLElement | null;
+    /** Mounted only while it has something on screen, so the parent drops it on this. */
+    onClose: () => void;
+}
+/**
+ * The right-click twin of `AssetActionsMenu`: same actions, opened at the
+ * cursor instead of from the row's `•••`. Both render what `AssetActions`
+ * gives them, so the two can't offer different things.
+ *
+ * Picking "Replace", "Move" or "Delete" closes the menu and opens a dialog in
+ * the same tick, and that dialog is rendered here — so the menu being shut and
+ * this being unmounted are two different things, tracked apart. Unmounting
+ * early would take the dialog with it, and for "Replace" the hidden file input
+ * too, which is why `isBusy` also covers the native picker.
+ */
+export declare const AssetContextMenu: ({ asset, dragData, permissions, position, returnFocusTo, onClose, }: AssetContextMenuProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/pages/Assets/components/AssetDetails/useCropImg.d.ts

@@ -26,6 +26,20 @@ export declare const resolveCornerResize: ({ anchorX, anchorY, point, aspectRati
     };
     aspectRatio: number | null;
 }) => CropRect;
+export type Rotation = 0 | 90 | 180 | 270;
+/**
+ * Remap a crop rect through a quarter-turn. `size` is the image size *before* the
+ * turn, so the returned rect is expressed against the swapped size for 90/270.
+ * Pure: the caller swaps `naturalSize` to match.
+ */
+export declare const rotateCropRect: (crop: CropRect, direction: "left" | "right", size: NaturalSize) => CropRect;
+/**
+ * The crop rect expressed against the *unrotated* source, by undoing each quarter-turn
+ * already applied. `produceFile` needs it to know which source pixels to sample.
+ */
+export declare const sourceCropRect: (crop: CropRect, rotation: Rotation, rotatedSize: NaturalSize) => CropRect;
+/** Advance a rotation by one quarter-turn, wrapping at 360. */
+export declare const nextRotation: (current: Rotation, direction: "left" | "right") => Rotation;
 /**
  * Custom crop state + file producer. Replaces a cropperjs-based version: the
  * crop rectangle is stored in natural-image pixels (so it stays locked across
@@ -37,6 +51,8 @@ export declare const useCropImg: () => {
     init: (image: HTMLImageElement) => void;
     crop: CropRect;
     naturalSize: NaturalSize;
+    rotation: Rotation;
+    rotate: (direction: "left" | "right") => void;
     aspectRatio: number | null;
     setCropSize: (next: Partial<Pick<CropRect, "width" | "height">>) => void;
     setCropPosition: (next: Partial<Pick<CropRect, "x" | "y">>) => void;

package/dist/admin/src/pages/Assets/components/CursorAnchoredMenu.d.ts

@@ -0,0 +1,32 @@
+import type { ReactNode } from 'react';
+export interface CursorPosition {
+    x: number;
+    y: number;
+}
+interface CursorAnchoredMenuProps {
+    position: CursorPosition;
+    /**
+     * Controlled, because a caller may need the menu shut while staying mounted —
+     * picking an item that opens a dialog is exactly that case.
+     */
+    open: boolean;
+    /** Names the menu for assistive tech — Radix points `aria-labelledby` at the anchor. */
+    label: string;
+    /** Where focus goes back on close — the element that was right-clicked. */
+    returnFocusTo?: HTMLElement | null;
+    /**
+     * Asked to close. Callers that opened a dialog from an item must defer
+     * unmounting until the dialog is done, or the dialog goes with them.
+     */
+    onClose: () => void;
+    children: ReactNode;
+}
+/**
+ * A menu opened at the cursor by a right-click, rather than from a trigger the
+ * user can see.
+ *
+ * Extracted from `MainAreaContextMenu`, which opened the background create menu
+ * this way first; the item menus reuse it so the anchoring trick exists once.
+ */
+export declare const CursorAnchoredMenu: ({ position, open, label, returnFocusTo, onClose, children, }: CursorAnchoredMenuProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/pages/Assets/components/FolderActions.d.ts

@@ -0,0 +1,48 @@
+import { type ReactNode } from 'react';
+import type { Folder } from '../../../../../shared/contracts/folders';
+import type { DragFolderData } from '../../../types/dnd';
+interface FolderActionsRender {
+    /** The `Menu.Item`s, for whichever trigger is rendering them. */
+    items: ReactNode;
+    /**
+     * The three dialogs. Rendered outside `Menu.Root` by every caller: Radix
+     * unmounts menu content on close, and a dialog opened from a menu item has to
+     * outlive the menu that opened it.
+     */
+    dialogs: ReactNode;
+    /**
+     * True while a dialog is open. A cursor-anchored caller is mounted only as
+     * long as it has something on screen, so it needs this to know it must stay
+     * around after the menu closes.
+     */
+    isBusy: boolean;
+}
+interface FolderActionsProps {
+    /** Only the id and name are read, so a tree node satisfies this too. */
+    folder: Pick<Folder, 'id' | 'name'>;
+    /** Drag data for this folder, so the move dialog validates against its real parent. */
+    dragData: DragFolderData;
+    /**
+     * Renaming is a list affordance. The folder tree offers the same menu without
+     * it, so the two entry points there stay identical to each other.
+     */
+    showRename?: boolean;
+    /** Receives the items and dialogs to place around whichever trigger it owns. */
+    children: (actions: FolderActionsRender) => ReactNode;
+}
+/**
+ * The folder actions themselves — items, dialogs and handlers — with no opinion
+ * about how the menu is opened, mirroring `AssetActions`.
+ *
+ * Both entry points (the row's `•••` trigger and the right-click menu anchored
+ * at the cursor) render what this gives them, so neither can drift from the
+ * other.
+ *
+ * A successful move or delete deselects this one folder and leaves the rest of
+ * the selection intact: they only invalidate RTK tags, so without it a
+ * `folder:<id>` key for a folder that no longer lives where the selection thinks
+ * it does would linger. A rename leaves the id valid and the folder in place, so
+ * it touches the selection not at all.
+ */
+export declare const FolderActions: ({ folder, dragData, showRename, children, }: FolderActionsProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/pages/Assets/components/FolderActionsMenu.d.ts

@@ -7,15 +7,11 @@ interface FolderActionsMenuProps {
 }
 /**
  * The "..." menu on a folder row/card. Always acts on that one folder, whatever
- * the current multi-selection is (the bulk actions bar is the selection-scoped
- * affordance). It reuses the shared move and delete dialogs, which mount only
- * while open.
+ * the current multi-selection is (the bulk actions bar and the right-click menu
+ * are the selection-scoped affordances).
  *
- * A successful move or delete deselects this one folder and leaves the rest of
- * the selection intact: they only invalidate RTK tags, so without it a
- * `folder:<id>` key for a folder that no longer lives where the selection thinks
- * it does would linger. A rename leaves the id valid and the folder in place, so
- * it touches the selection not at all.
+ * The actions themselves live in `FolderActions`, shared with
+ * `FolderContextMenu`. This component is only the trigger.
  */
 export declare const FolderActionsMenu: ({ folder, dragData }: FolderActionsMenuProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/admin/src/pages/Assets/components/FolderContextMenu.d.ts

@@ -0,0 +1,21 @@
+import { type CursorPosition } from './CursorAnchoredMenu';
+import type { Folder } from '../../../../../shared/contracts/folders';
+import type { DragFolderData } from '../../../types/dnd';
+interface FolderContextMenuProps {
+    folder: Pick<Folder, 'id' | 'name'>;
+    dragData: DragFolderData;
+    /** Passed through — the folder tree offers the menu without Rename. */
+    showRename?: boolean;
+    position: CursorPosition;
+    returnFocusTo: HTMLElement | null;
+    /** Mounted only while it has something on screen, so the parent drops it on this. */
+    onClose: () => void;
+}
+/**
+ * The right-click twin of `FolderActionsMenu`: same actions, opened at the
+ * cursor. Mirrors `AssetContextMenu`, including keeping "the menu is shut" and
+ * "this is unmounted" as separate things — a dialog opened from an item is
+ * rendered here and would go with an early unmount.
+ */
+export declare const FolderContextMenu: ({ folder, dragData, showRename, position, returnFocusTo, onClose, }: FolderContextMenuProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/pages/Assets/components/FolderTree/FolderTree.d.ts

@@ -1,3 +1,4 @@
+import { type ReactNode } from 'react';
 interface FolderTreeProps {
     currentFolderId: number | null;
     /**
@@ -6,7 +7,10 @@ interface FolderTreeProps {
      * */
     showActiveFolder?: boolean;
     onSelectFolder: (folderId: number | null) => void;
+    /** Rendered inside the sidebar, which it can listen on through `FOLDER_TREE_ROOT_SELECTOR`. */
+    backgroundContextMenu?: ReactNode;
 }
+export declare const FOLDER_TREE_ROOT_SELECTOR = "[data-folder-tree-root]";
 /**
  * Left-rail navigation for the Media Library. Fetches folder structure internally
  * and renders:
@@ -24,5 +28,5 @@ interface FolderTreeProps {
  * via `onSelectFolder` so the URL stays the single source of truth (see
  * `useFolderNavigation`).
  */
-export declare const FolderTree: ({ currentFolderId, showActiveFolder, onSelectFolder, }: FolderTreeProps) => import("react/jsx-runtime").JSX.Element;
+export declare const FolderTree: ({ currentFolderId, showActiveFolder, onSelectFolder, backgroundContextMenu, }: FolderTreeProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/admin/src/pages/Assets/components/FolderTree/FolderTreeRowMenu.d.ts

@@ -0,0 +1,25 @@
+import type { CursorPosition } from '../CursorAnchoredMenu';
+interface FolderTreeRowMenuProps {
+    folder: {
+        id: number;
+        name: string;
+    };
+    /** Its parent's id, so a move validates against where it actually lives. */
+    parentId: number | null;
+    /** Set by the row's right-click; null when the menu is closed. */
+    menuPosition: CursorPosition | null;
+    returnFocusTo: HTMLElement | null;
+    onCloseMenu: () => void;
+}
+/**
+ * Folder actions on a tree row, from either the `•••` or a right-click.
+ *
+ * Both render the same `FolderActions`, minus Rename — renaming is a list
+ * affordance and the tree does not offer it. Unlike the list, a tree row has no
+ * selection, so a right-click always means the row it landed on.
+ *
+ * One `FolderActions` serves both triggers here rather than two instances, so
+ * the dialogs it owns are not duplicated per row.
+ */
+export declare const FolderTreeRowMenu: ({ folder, parentId, menuPosition, returnFocusTo, onCloseMenu, }: FolderTreeRowMenuProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/pages/Assets/components/ItemContextMenu.d.ts

@@ -0,0 +1,53 @@
+import { type ReactNode } from 'react';
+import type { File } from '../../../../../shared/contracts/files';
+import type { Folder } from '../../../../../shared/contracts/folders';
+import type { DragFileData, DragFolderData } from '../../../types/dnd';
+import type { ItemLocations } from '../../../utils/itemLocations';
+import type { ItemKey } from '../utils/selection';
+/**
+ * What a card or row hands over when it is right-clicked. It passes its own
+ * asset rather than a key alone, so nothing here has to resolve keys back to
+ * items — the item is already in scope where the gesture happens.
+ */
+export type ContextMenuPayload = {
+    kind: 'asset';
+    asset: File;
+    dragData: DragFileData;
+} | {
+    kind: 'folder';
+    folder: Folder;
+    dragData: DragFolderData;
+};
+type OpenForItem = (event: React.MouseEvent, key: ItemKey, payload: ContextMenuPayload) => void;
+/**
+ * Called by the list items. Returns `null` outside the provider — the asset
+ * picker renders the same cards without a context menu, and a missing provider
+ * there should be a no-op rather than a crash.
+ */
+export declare const useItemContextMenuTrigger: () => OpenForItem | null;
+interface ItemContextMenuProviderProps {
+    /**
+     * Real location of every loaded row, so a selection move validates each item
+     * against its own parent — same input the bulk bar takes.
+     */
+    locations: ItemLocations;
+    children: ReactNode;
+}
+/**
+ * Owns the right-click menu for the list, above both the grid and the table so
+ * one instance serves either view and the selection case has the `locations` it
+ * needs.
+ *
+ * The rule, in one place:
+ *
+ * - right-clicking an item **inside a multi-selection** opens the selection
+ *   menu, acting on all of it — the file-manager behaviour, and the menu leads
+ *   with the count so what it acts on is stated before the actions are
+ * - **anything else** replaces the selection with the clicked item and opens
+ *   that item's own menu. That includes right-clicking an unselected item while
+ *   others are selected: every file manager drops the old selection there, and
+ *   the visible deselection is what stops the menu looking like it applies to
+ *   items it doesn't
+ */
+export declare const ItemContextMenuProvider: ({ locations, children }: ItemContextMenuProviderProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/pages/Assets/components/MainAreaContextMenu.d.ts

@@ -1,3 +1,4 @@
+import type { ItemLocations } from '../../../utils/itemLocations';
 interface MainAreaContextMenuProps {
     /** Opens the "new folder" dialog in the folder currently on screen. */
     onCreateFolder: () => void;
@@ -11,6 +12,19 @@ interface MainAreaContextMenuProps {
      * permission gate can't silently regress to permissive.
      */
     disabled: boolean;
+    /**
+     * The element to listen on, found from where this renders. Defaults to the
+     * scrolling main column.
+     */
+    containerSelector?: string;
+    /**
+     * Real location of every loaded row. Supplying it turns on the selection
+     * section: with items selected, their bulk actions lead the menu, above the
+     * creation ones. Omitted, the menu offers creation only — which is what the
+     * folder tree wants, where the asset selection is not what you are pointing
+     * at.
+     */
+    locations?: ItemLocations;
 }
 /**
  * Drive/Dropbox-style right-click on the empty parts of the assets area: the
@@ -24,5 +38,5 @@ interface MainAreaContextMenuProps {
  * row is left alone — those carry `data-native-context-menu` and keep the
  * browser's menu (which is what you want over a thumbnail or a filename).
  */
-export declare const MainAreaContextMenu: ({ onCreateFolder, onImportFiles, onImportFromUrl, disabled, }: MainAreaContextMenuProps) => import("react/jsx-runtime").JSX.Element;
+export declare const MainAreaContextMenu: ({ onCreateFolder, onImportFiles, onImportFromUrl, disabled, containerSelector, locations, }: MainAreaContextMenuProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/admin/src/pages/Assets/components/SelectionActions.d.ts

@@ -0,0 +1,40 @@
+import { type ReactNode } from 'react';
+import type { ItemLocations } from '../../../utils/itemLocations';
+interface SelectionActionsRender {
+    /** How many items the actions would act on. Zero means nothing is selected. */
+    count: number;
+    /**
+     * Whether there is anything to offer. False for a role that can read but not
+     * update; true while the RBAC check is still settling, so a menu built on it
+     * does not flash empty.
+     */
+    hasActions: boolean;
+    /** The count label, a separator, then Move and Delete. */
+    items: ReactNode;
+    /** Rendered outside `Menu.Root` — a dialog has to outlive the menu that opened it. */
+    dialogs: ReactNode;
+    /** True while a dialog is open, for callers that unmount once nothing is on screen. */
+    isBusy: boolean;
+}
+interface SelectionActionsProps {
+    /**
+     * Real location of every loaded row, so the move dialog validates each
+     * selected item against its own parent — same input the bulk bar takes.
+     */
+    locations: ItemLocations;
+    children: (actions: SelectionActionsRender) => ReactNode;
+}
+/**
+ * The actions that apply to the current selection — move and delete — with no
+ * opinion about which menu shows them.
+ *
+ * Two menus offer them: the one a right-click on a selected item opens, and the
+ * background menu, which prepends them to its own creation actions whenever
+ * something is selected. Sharing the items keeps the two from drifting, and
+ * keeps one copy of the dialogs they open.
+ *
+ * Only move and delete: the rest of an item's menu has no meaning for a set —
+ * there is no one link to copy and no one file to replace.
+ */
+export declare const SelectionActions: ({ locations, children }: SelectionActionsProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/pages/Assets/components/SelectionContextMenu.d.ts

@@ -0,0 +1,25 @@
+import { type CursorPosition } from './CursorAnchoredMenu';
+import type { ItemLocations } from '../../../utils/itemLocations';
+interface SelectionContextMenuProps {
+    position: CursorPosition;
+    returnFocusTo: HTMLElement | null;
+    /**
+     * Real location of every loaded row, so the move dialog validates each
+     * selected item against its own parent — same input the bulk bar takes.
+     */
+    locations: ItemLocations;
+    onClose: () => void;
+}
+/**
+ * Right-clicking one of several selected items acts on the selection, the way a
+ * file manager does.
+ *
+ * The count leads, so what the menu is about to act on is stated before the
+ * actions are. Right-clicking an item that is *not* in the selection replaces
+ * the selection with it first, and `AssetContextMenu` handles it instead.
+ *
+ * Right-clicking the background with a selection live is a different menu:
+ * `MainAreaContextMenu` shows these same actions above its creation ones.
+ */
+export declare const SelectionContextMenu: ({ position, returnFocusTo, locations, onClose, }: SelectionContextMenuProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/pages/Assets/hooks/useAssetSelection.d.ts

@@ -27,6 +27,11 @@ export interface AssetSelection {
     selectRange: (orderedKeys: ItemKey[], targetKey: ItemKey) => void;
     /** Header checkbox — selects every rendered item (folders and assets). */
     selectAll: (orderedKeys: ItemKey[]) => void;
+    /**
+     * Replaces the selection with this one key, as a right-click on an unselected
+     * item does: what the menu then acts on is what the user can see is selected.
+     */
+    selectOnly: (key: ItemKey) => void;
     /** Row-level "..." menu — drops one key when its item leaves the list (move, delete). */
     deselect: (key: ItemKey) => void;
     /** Close button / folder navigation / list-identity changes. */

package/dist/admin/src/utils/mediaLibraryVersion.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Which Media Library a project is configured to use, stamped on every event
+ * both trees fire. They emit the SAME event names, so without this there is no
+ * way to tell a project that kept the legacy library from one that did not.
+ *
+ * Read from the feature flag rather than from whichever tree fired the event,
+ * because the two do not line up. Several surfaces are registered outside the
+ * flag's branch in `index.ts` and so run under both settings — the Content
+ * Manager media field and picker are legacy code for everyone, and the Media
+ * Library settings page is current code for everyone. Tagging by tree would
+ * report a project running the current library as legacy the moment an editor
+ * attached an image to an entry, and vice versa.
+ *
+ * Bump these if a future revamp ever needs its own bucket.
+ */
+export declare const MEDIA_LIBRARY_VERSION_CURRENT = "v2";
+export declare const MEDIA_LIBRARY_VERSION_LEGACY = "v1";
+export declare const getMediaLibraryVersion: () => "v2" | "v1";

package/dist/admin/translations/en.json.js

@@ -47,6 +47,7 @@ var en = {
     "asset-details.download.error": "Failed to download the file.",
     "asset-details.crop.trigger": "Crop",
     "asset-details.crop.title": "Crop & Focus area",
+    "asset-details.crop.rotate-right": "Rotate 90° right",
     "asset-details.crop.hint": "Set the crop area with the rectangle. Pin the always-visible area with the circle.",
     "asset-details.crop.width": "Width (px)",
     "asset-details.crop.height": "Height (px)",
@@ -64,10 +65,10 @@ var en = {
     "asset-details.crop.cancel": "Cancel",
     "asset-details.crop.save-as-copy": "Save as copy",
     "asset-details.crop.apply": "Apply",
-    "asset-details.crop.success": "File cropped.",
+    "asset-details.crop.success": "File updated",
     "asset-details.crop.copy-success": "Copy created.",
-    "asset-details.crop.error": "Failed to crop the file.",
-    "asset-details.crop.loading": "Saving the cropped copy…",
+    "asset-details.crop.error": "Failed to update the file.",
+    "asset-details.crop.loading": "Saving the copy…",
     "asset-details.noPreview": "No preview available",
     "upload.generic-error": "An error occurred while uploading the file.",
     "upload.progress": "Upload progress",
@@ -233,6 +234,7 @@ var en = {
     "list.assets.selected": "{numberFolders, plural, one {1 folder} other {# folders}} - {numberAssets, plural, one {1 asset} other {# assets}}",
     "list-assets-select": "Select {name} asset",
     "list.assets.actions.replace": "Replace media",
+    "list.assets.context-menu.label": "Asset actions",
     "list.assets.actions.copy-link": "Copy link to media",
     "list.assets.actions.download": "Download media",
     "list.assets.actions.move": "Move to folder",
@@ -240,6 +242,7 @@ var en = {
     "list.assets.type-not-allowed": "This type of file is not allowed.",
     "list.assets.to-upload": "{number, plural, =0 {No asset} one {1 asset} other {# assets}} ready to upload",
     "list.folder.actions.copy-link": "Copy link to folder",
+    "list.folder.context-menu.label": "Folder actions",
     "list.folder.actions.copy-link.success": "Folder link copied.",
     "list.folder.actions.copy-link.error": "Failed to copy the folder link.",
     "list.folder.actions.rename": "Rename folder",
@@ -360,6 +363,7 @@ var en = {
     "list.bulk-actions.move.success-multiple-sources": "{count, plural, =1 {# element has} other {# elements have}} been moved to {destination}",
     "list.bulk-actions.move.error": "An error occurred while moving the items.",
     "list.bulk-actions.delete": "Delete",
+    "list.selection.context-menu.label": "Selection actions",
     "list.bulk-actions.delete.confirm.title": "Delete {count, plural, =1 {# item} other {# items}}?",
     "list.bulk-actions.delete.confirm.description.are-you-sure": "Are you sure you want to delete the selected items?",
     "list.bulk-actions.delete.confirm.description.cant-be-undone": "This action can’t be undone. Deleting a folder also removes everything inside it, and any linked content will break – media asset containers will appear empty.",
@@ -390,6 +394,7 @@ var en = {
     "sidebar.tree.expand": "Expand {name}",
     "sidebar.tree.no-subfolders": "The folder {name} has no subfolders",
     "sidebar.tree.collapse": "Collapse {name}",
+    "sidebar.tree.actions": "Actions for {name}",
     "sidebar.tree.empty": "No folders yet",
     "sidebar.tree.loading": "Loading folders...",
     "sidebar.tree.error": "Could not load folders."

package/dist/admin/translations/en.json.js.map

@@ -1 +1 @@
-{"version":3,"file":"en.json.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"en.json.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/admin/translations/en.json.mjs

@@ -45,6 +45,7 @@ var en = {
     "asset-details.download.error": "Failed to download the file.",
     "asset-details.crop.trigger": "Crop",
     "asset-details.crop.title": "Crop & Focus area",
+    "asset-details.crop.rotate-right": "Rotate 90° right",
     "asset-details.crop.hint": "Set the crop area with the rectangle. Pin the always-visible area with the circle.",
     "asset-details.crop.width": "Width (px)",
     "asset-details.crop.height": "Height (px)",
@@ -62,10 +63,10 @@ var en = {
     "asset-details.crop.cancel": "Cancel",
     "asset-details.crop.save-as-copy": "Save as copy",
     "asset-details.crop.apply": "Apply",
-    "asset-details.crop.success": "File cropped.",
+    "asset-details.crop.success": "File updated",
     "asset-details.crop.copy-success": "Copy created.",
-    "asset-details.crop.error": "Failed to crop the file.",
-    "asset-details.crop.loading": "Saving the cropped copy…",
+    "asset-details.crop.error": "Failed to update the file.",
+    "asset-details.crop.loading": "Saving the copy…",
     "asset-details.noPreview": "No preview available",
     "upload.generic-error": "An error occurred while uploading the file.",
     "upload.progress": "Upload progress",
@@ -231,6 +232,7 @@ var en = {
     "list.assets.selected": "{numberFolders, plural, one {1 folder} other {# folders}} - {numberAssets, plural, one {1 asset} other {# assets}}",
     "list-assets-select": "Select {name} asset",
     "list.assets.actions.replace": "Replace media",
+    "list.assets.context-menu.label": "Asset actions",
     "list.assets.actions.copy-link": "Copy link to media",
     "list.assets.actions.download": "Download media",
     "list.assets.actions.move": "Move to folder",
@@ -238,6 +240,7 @@ var en = {
     "list.assets.type-not-allowed": "This type of file is not allowed.",
     "list.assets.to-upload": "{number, plural, =0 {No asset} one {1 asset} other {# assets}} ready to upload",
     "list.folder.actions.copy-link": "Copy link to folder",
+    "list.folder.context-menu.label": "Folder actions",
     "list.folder.actions.copy-link.success": "Folder link copied.",
     "list.folder.actions.copy-link.error": "Failed to copy the folder link.",
     "list.folder.actions.rename": "Rename folder",
@@ -358,6 +361,7 @@ var en = {
     "list.bulk-actions.move.success-multiple-sources": "{count, plural, =1 {# element has} other {# elements have}} been moved to {destination}",
     "list.bulk-actions.move.error": "An error occurred while moving the items.",
     "list.bulk-actions.delete": "Delete",
+    "list.selection.context-menu.label": "Selection actions",
     "list.bulk-actions.delete.confirm.title": "Delete {count, plural, =1 {# item} other {# items}}?",
     "list.bulk-actions.delete.confirm.description.are-you-sure": "Are you sure you want to delete the selected items?",
     "list.bulk-actions.delete.confirm.description.cant-be-undone": "This action can’t be undone. Deleting a folder also removes everything inside it, and any linked content will break – media asset containers will appear empty.",
@@ -388,6 +392,7 @@ var en = {
     "sidebar.tree.expand": "Expand {name}",
     "sidebar.tree.no-subfolders": "The folder {name} has no subfolders",
     "sidebar.tree.collapse": "Collapse {name}",
+    "sidebar.tree.actions": "Actions for {name}",
     "sidebar.tree.empty": "No folders yet",
     "sidebar.tree.loading": "Loading folders...",
     "sidebar.tree.error": "Could not load folders."

package/dist/admin/translations/en.json.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"en.json.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"en.json.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/admin/utils/mediaLibraryVersion.js

@@ -0,0 +1,24 @@
+'use strict';
+
+/**
+ * Which Media Library a project is configured to use, stamped on every event
+ * both trees fire. They emit the SAME event names, so without this there is no
+ * way to tell a project that kept the legacy library from one that did not.
+ *
+ * Read from the feature flag rather than from whichever tree fired the event,
+ * because the two do not line up. Several surfaces are registered outside the
+ * flag's branch in `index.ts` and so run under both settings — the Content
+ * Manager media field and picker are legacy code for everyone, and the Media
+ * Library settings page is current code for everyone. Tagging by tree would
+ * report a project running the current library as legacy the moment an editor
+ * attached an image to an entry, and vice versa.
+ *
+ * Bump these if a future revamp ever needs its own bucket.
+ */ const MEDIA_LIBRARY_VERSION_CURRENT = 'v2';
+const MEDIA_LIBRARY_VERSION_LEGACY = 'v1';
+const getMediaLibraryVersion = ()=>window.strapi.featureFlags.isEnabled('useLegacyMediaLibrary') ? MEDIA_LIBRARY_VERSION_LEGACY : MEDIA_LIBRARY_VERSION_CURRENT;
+
+exports.MEDIA_LIBRARY_VERSION_CURRENT = MEDIA_LIBRARY_VERSION_CURRENT;
+exports.MEDIA_LIBRARY_VERSION_LEGACY = MEDIA_LIBRARY_VERSION_LEGACY;
+exports.getMediaLibraryVersion = getMediaLibraryVersion;
+//# sourceMappingURL=mediaLibraryVersion.js.map

package/dist/admin/utils/mediaLibraryVersion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mediaLibraryVersion.js","sources":["../../../admin/src/utils/mediaLibraryVersion.ts"],"sourcesContent":["/**\n * Which Media Library a project is configured to use, stamped on every event\n * both trees fire. They emit the SAME event names, so without this there is no\n * way to tell a project that kept the legacy library from one that did not.\n *\n * Read from the feature flag rather than from whichever tree fired the event,\n * because the two do not line up. Several surfaces are registered outside the\n * flag's branch in `index.ts` and so run under both settings — the Content\n * Manager media field and picker are legacy code for everyone, and the Media\n * Library settings page is current code for everyone. Tagging by tree would\n * report a project running the current library as legacy the moment an editor\n * attached an image to an entry, and vice versa.\n *\n * Bump these if a future revamp ever needs its own bucket.\n */\nexport const MEDIA_LIBRARY_VERSION_CURRENT = 'v2';\nexport const MEDIA_LIBRARY_VERSION_LEGACY = 'v1';\n\nexport const getMediaLibraryVersion = () =>\n  window.strapi.featureFlags.isEnabled('useLegacyMediaLibrary')\n    ? MEDIA_LIBRARY_VERSION_LEGACY\n    : MEDIA_LIBRARY_VERSION_CURRENT;\n"],"names":["MEDIA_LIBRARY_VERSION_CURRENT","MEDIA_LIBRARY_VERSION_LEGACY","getMediaLibraryVersion","window","strapi","featureFlags","isEnabled"],"mappings":";;AAAA;;;;;;;;;;;;;;IAeO,MAAMA,6BAAAA,GAAgC;AACtC,MAAMC,+BAA+B;AAErC,MAAMC,sBAAAA,GAAyB,IACpCC,MAAAA,CAAOC,MAAM,CAACC,YAAY,CAACC,SAAS,CAAC,uBAAA,CAAA,GACjCL,4BAAAA,GACAD;;;;;;"}

package/dist/admin/utils/mediaLibraryVersion.mjs

@@ -0,0 +1,20 @@
+/**
+ * Which Media Library a project is configured to use, stamped on every event
+ * both trees fire. They emit the SAME event names, so without this there is no
+ * way to tell a project that kept the legacy library from one that did not.
+ *
+ * Read from the feature flag rather than from whichever tree fired the event,
+ * because the two do not line up. Several surfaces are registered outside the
+ * flag's branch in `index.ts` and so run under both settings — the Content
+ * Manager media field and picker are legacy code for everyone, and the Media
+ * Library settings page is current code for everyone. Tagging by tree would
+ * report a project running the current library as legacy the moment an editor
+ * attached an image to an entry, and vice versa.
+ *
+ * Bump these if a future revamp ever needs its own bucket.
+ */ const MEDIA_LIBRARY_VERSION_CURRENT = 'v2';
+const MEDIA_LIBRARY_VERSION_LEGACY = 'v1';
+const getMediaLibraryVersion = ()=>window.strapi.featureFlags.isEnabled('useLegacyMediaLibrary') ? MEDIA_LIBRARY_VERSION_LEGACY : MEDIA_LIBRARY_VERSION_CURRENT;
+
+export { MEDIA_LIBRARY_VERSION_CURRENT, MEDIA_LIBRARY_VERSION_LEGACY, getMediaLibraryVersion };
+//# sourceMappingURL=mediaLibraryVersion.mjs.map

package/dist/admin/utils/mediaLibraryVersion.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mediaLibraryVersion.mjs","sources":["../../../admin/src/utils/mediaLibraryVersion.ts"],"sourcesContent":["/**\n * Which Media Library a project is configured to use, stamped on every event\n * both trees fire. They emit the SAME event names, so without this there is no\n * way to tell a project that kept the legacy library from one that did not.\n *\n * Read from the feature flag rather than from whichever tree fired the event,\n * because the two do not line up. Several surfaces are registered outside the\n * flag's branch in `index.ts` and so run under both settings — the Content\n * Manager media field and picker are legacy code for everyone, and the Media\n * Library settings page is current code for everyone. Tagging by tree would\n * report a project running the current library as legacy the moment an editor\n * attached an image to an entry, and vice versa.\n *\n * Bump these if a future revamp ever needs its own bucket.\n */\nexport const MEDIA_LIBRARY_VERSION_CURRENT = 'v2';\nexport const MEDIA_LIBRARY_VERSION_LEGACY = 'v1';\n\nexport const getMediaLibraryVersion = () =>\n  window.strapi.featureFlags.isEnabled('useLegacyMediaLibrary')\n    ? MEDIA_LIBRARY_VERSION_LEGACY\n    : MEDIA_LIBRARY_VERSION_CURRENT;\n"],"names":["MEDIA_LIBRARY_VERSION_CURRENT","MEDIA_LIBRARY_VERSION_LEGACY","getMediaLibraryVersion","window","strapi","featureFlags","isEnabled"],"mappings":"AAAA;;;;;;;;;;;;;;IAeO,MAAMA,6BAAAA,GAAgC;AACtC,MAAMC,+BAA+B;AAErC,MAAMC,sBAAAA,GAAyB,IACpCC,MAAAA,CAAOC,MAAM,CAACC,YAAY,CAACC,SAAS,CAAC,uBAAA,CAAA,GACjCL,4BAAAA,GACAD;;;;"}

package/dist/server/controllers/admin-file.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var fp = require('lodash/fp');
+var _ = require('lodash');
 var utils = require('@strapi/utils');
 var index = require('../utils/index.js');
 var constants = require('../constants.js');
@@ -27,7 +27,7 @@ var adminFile = {
         await pm.validateQuery(ctx.query);
         const query = await utils.async.pipe(// Start by sanitizing the incoming query
         (q)=>pm.sanitizeQuery(q), // Add the default query which should not be validated or sanitized
-        (q)=>fp.merge(defaultQuery, q), // Add the dynamic filters based on permissions' conditions
+        (q)=>_.merge({}, defaultQuery, q), // Add the dynamic filters based on permissions' conditions
         (q)=>pm.addPermissionsQueryTo(q))(ctx.query);
         const { results: files, pagination } = await index.getService('upload').findPage(query);
         // Sign file urls for private providers