@strapi/upload 5.56.0 → 5.58.0

package/dist/admin/src/legacy/hooks/useEditAsset.d.ts

@@ -1,15 +1,6 @@
 import { File as FileAsset } from '../../../../shared/contracts/files';
-export type ErrorMutation = {
-    message: string;
-    response: {
-        status: number;
-        data: {
-            error: Error;
-        };
-    };
-} | null;
 export declare const useEditAsset: () => {
-    cancel: () => void;
+    cancel: () => void | undefined;
     editAsset: (asset: FileAsset, file: File) => Promise<FileAsset>;
     progress: number;
     status: "success" | "error" | "loading" | "idle";
@@ -19,7 +10,7 @@ export declare const useEditAsset: () => {
     isIdle: true;
     isLoading: false;
     isSuccess: false;
-    mutate: import("react-query").UseMutateFunction<FileAsset, ErrorMutation, {
+    mutate: import("react-query").UseMutateFunction<FileAsset, Error, {
         asset: FileAsset;
         file: File;
     }, unknown>;
@@ -31,12 +22,12 @@ export declare const useEditAsset: () => {
         asset: FileAsset;
         file: File;
     } | undefined;
-    mutateAsync: import("react-query").UseMutateAsyncFunction<FileAsset, ErrorMutation, {
+    mutateAsync: import("react-query").UseMutateAsyncFunction<FileAsset, Error, {
         asset: FileAsset;
         file: File;
     }, unknown>;
 } | {
-    cancel: () => void;
+    cancel: () => void | undefined;
     editAsset: (asset: FileAsset, file: File) => Promise<FileAsset>;
     progress: number;
     status: "success" | "error" | "loading" | "idle";
@@ -46,7 +37,7 @@ export declare const useEditAsset: () => {
     isIdle: false;
     isLoading: true;
     isSuccess: false;
-    mutate: import("react-query").UseMutateFunction<FileAsset, ErrorMutation, {
+    mutate: import("react-query").UseMutateFunction<FileAsset, Error, {
         asset: FileAsset;
         file: File;
     }, unknown>;
@@ -58,22 +49,22 @@ export declare const useEditAsset: () => {
         asset: FileAsset;
         file: File;
     } | undefined;
-    mutateAsync: import("react-query").UseMutateAsyncFunction<FileAsset, ErrorMutation, {
+    mutateAsync: import("react-query").UseMutateAsyncFunction<FileAsset, Error, {
         asset: FileAsset;
         file: File;
     }, unknown>;
 } | {
-    cancel: () => void;
+    cancel: () => void | undefined;
     editAsset: (asset: FileAsset, file: File) => Promise<FileAsset>;
     progress: number;
     status: "success" | "error" | "loading" | "idle";
     data: undefined;
-    error: ErrorMutation;
+    error: Error;
     isError: true;
     isIdle: false;
     isLoading: false;
     isSuccess: false;
-    mutate: import("react-query").UseMutateFunction<FileAsset, ErrorMutation, {
+    mutate: import("react-query").UseMutateFunction<FileAsset, Error, {
         asset: FileAsset;
         file: File;
     }, unknown>;
@@ -85,12 +76,12 @@ export declare const useEditAsset: () => {
         asset: FileAsset;
         file: File;
     } | undefined;
-    mutateAsync: import("react-query").UseMutateAsyncFunction<FileAsset, ErrorMutation, {
+    mutateAsync: import("react-query").UseMutateAsyncFunction<FileAsset, Error, {
         asset: FileAsset;
         file: File;
     }, unknown>;
 } | {
-    cancel: () => void;
+    cancel: () => void | undefined;
     editAsset: (asset: FileAsset, file: File) => Promise<FileAsset>;
     progress: number;
     status: "success" | "error" | "loading" | "idle";
@@ -100,7 +91,7 @@ export declare const useEditAsset: () => {
     isIdle: false;
     isLoading: false;
     isSuccess: true;
-    mutate: import("react-query").UseMutateFunction<FileAsset, ErrorMutation, {
+    mutate: import("react-query").UseMutateFunction<FileAsset, Error, {
         asset: FileAsset;
         file: File;
     }, unknown>;
@@ -112,7 +103,7 @@ export declare const useEditAsset: () => {
         asset: FileAsset;
         file: File;
     } | undefined;
-    mutateAsync: import("react-query").UseMutateAsyncFunction<FileAsset, ErrorMutation, {
+    mutateAsync: import("react-query").UseMutateAsyncFunction<FileAsset, Error, {
         asset: FileAsset;
         file: File;
     }, unknown>;

package/dist/admin/src/legacy/hooks/useUpload.d.ts

@@ -7,7 +7,7 @@ interface Asset extends Omit<File, 'id' | 'hash'> {
 export declare const useUpload: () => {
     upload: (assets: Asset | Asset[], folderId: number | null) => Promise<File[]>;
     isLoading: boolean;
-    cancel: () => void;
+    cancel: () => void | undefined;
     error: import("@strapi/utils/dist/errors").ApplicationError<"ApplicationError", string, unknown> | import("@strapi/utils/dist/errors").ValidationError<string, unknown> | null | undefined;
     progress: number;
     status: "success" | "error" | "loading" | "idle";

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

@@ -0,0 +1,70 @@
+import type { ReactNode } from 'react';
+import type { File } from '../../../../../shared/contracts/files';
+import type { DragFileData } from '../../../types/dnd';
+interface AssetActionsRender {
+    /** The `Menu.Item`s, for whichever trigger is rendering them. */
+    items: ReactNode;
+    /**
+     * The replace file input and 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;
+    /**
+     * False once RBAC has settled and every action is gated away. Callers render
+     * no trigger at all in that case — an empty popup is worse than none.
+     */
+    hasActions: boolean;
+    /**
+     * True while anything the actions own is still in play — a dialog, or the
+     * native file picker. 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;
+}
+/**
+ * The asset actions themselves — items, dialogs and handlers — with no opinion
+ * about how the menu is opened. A render-prop rather than a hook because it
+ * produces JSX, and the repo reserves `use*.tsx` for tests.
+ *
+ * Both entry points (the row's `•••` trigger and the right-click menu anchored
+ * at the cursor) render what this returns, so neither can drift from the other:
+ * adding an action or changing a permission gate happens here, once.
+ *
+ * Replace / copy link / download duplicate what the details drawer offers as
+ * icon buttons, so the same action is one click away without opening the asset
+ * first. They are re-implemented rather than lifted out of the drawer: the
+ * drawer versions render as `IconButton`s and report through its in-drawer toast
+ * slot, neither of which fits a menu item on a row.
+ *
+ * A successful move or delete deselects this one asset and leaves the rest of
+ * the selection intact: the mutations only invalidate RTK tags, so without it an
+ * `asset:<id>` key for a file that has been deleted — or has moved out of this
+ * list — would linger.
+ */
+/** The subset of the RBAC answer these actions are gated on. */
+export interface AssetActionPermissions {
+    isLoading: boolean;
+    canUpdate: boolean;
+    canDownload: boolean;
+    canCopyLink: boolean;
+}
+interface AssetActionsProps {
+    asset: File;
+    dragData: DragFileData;
+    /**
+     * Already-resolved permissions, for a caller that mounts on demand.
+     *
+     * `useRBAC` starts every instance at `isLoading: true` with each flag false,
+     * so a menu mounted by a right-click would render empty for a tick — an open
+     * popup with nothing in it. A caller that has been mounted all along (the
+     * context menu provider) has the answer already and passes it here. Omitted
+     * by the `•••` trigger, which is mounted with its row and has no such gap.
+     */
+    permissions?: AssetActionPermissions;
+    /** Receives the items and dialogs to place around whichever trigger it owns. */
+    children: (actions: AssetActionsRender) => ReactNode;
+}
+export declare const AssetActions: ({ asset, dragData, permissions, children }: AssetActionsProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -7,20 +7,11 @@ interface AssetActionsMenuProps {
 }
 /**
  * The "..." menu on an asset row/card. Always acts on that one asset, whatever
- * the current multi-selection is (the bulk actions bar is the selection-scoped
- * affordance) — the file mirror of `FolderActionsMenu`.
+ * the current multi-selection is (the bulk actions bar and the right-click menu
+ * are the selection-scoped affordances) — the file mirror of `FolderActionsMenu`.
  *
- * Replace / copy link / download duplicate what the details drawer offers as
- * icon buttons, so the same action is one click away without opening the asset
- * first. They are re-implemented rather than lifted out of the drawer: the
- * drawer versions render as `IconButton`s and report through its in-drawer toast
- * slot, neither of which fits a menu item on a row.
- *
- * A successful move or delete deselects this one asset and leaves the rest of
- * the selection intact: the mutations only invalidate RTK tags, so without it an
- * `asset:<id>` key for a file that has been deleted — or has moved out of this
- * list — would linger. The other selected rows are untouched, which is the whole
- * point of the menu being a single-item affordance.
+ * The actions themselves live in `AssetActions`, shared with
+ * `AssetContextMenu`. This component is only the trigger.
  */
-export declare const AssetActionsMenu: ({ asset, dragData }: AssetActionsMenuProps) => import("react/jsx-runtime").JSX.Element | null;
+export declare const AssetActionsMenu: ({ asset, dragData }: AssetActionsMenuProps) => import("react/jsx-runtime").JSX.Element;
 export {};

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";