@strapi/upload 5.51.0 → 5.51.1

package/dist/admin/future/utils/getFolderLabel.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"getFolderLabel.mjs","sources":["../../../../admin/src/future/utils/getFolderLabel.ts"],"sourcesContent":["import type { FolderNode } from '../../../../shared/contracts/folders';\n\n/**\n * Leaf display name for a folder id. `null` (root) → the Media Library label.\n * Used by both the DnD success toast and the dialog success toast so the two\n * paths name folders identically. Ancestry paths belong only in the dialog's\n * select options (see `flattenFolderStructure`).\n *\n * `id === null` returns `rootLabel`; an unknown id falls back to `rootLabel`\n * too (defensive — mirrors the dialog's previous `?? rootLabel`).\n */\nexport const getFolderLabel = (\n  folderStructure: FolderNode[],\n  id: number | null,\n  rootLabel: string\n): string => {\n  if (id === null) {\n    return rootLabel;\n  }\n\n  const findNode = (nodes: FolderNode[]): FolderNode | null => {\n    for (const node of nodes) {\n      if (node.id === id) {\n        return node;\n      }\n\n      const found = findNode(node.children ?? []);\n      if (found) {\n        return found;\n      }\n    }\n\n    return null;\n  };\n\n  return findNode(folderStructure)?.name ?? rootLabel;\n};\n"],"names":["getFolderLabel","folderStructure","id","rootLabel","findNode","nodes","node","found","children","name"],"mappings":"AAEA;;;;;;;;AAQC,IACM,MAAMA,cAAAA,GAAiB,CAC5BC,iBACAC,EAAAA,EACAC,SAAAA,GAAAA;AAEA,IAAA,IAAID,OAAO,IAAA,EAAM;QACf,OAAOC,SAAAA;AACT,IAAA;AAEA,IAAA,MAAMC,WAAW,CAACC,KAAAA,GAAAA;QAChB,KAAK,MAAMC,QAAQD,KAAAA,CAAO;YACxB,IAAIC,IAAAA,CAAKJ,EAAE,KAAKA,EAAAA,EAAI;gBAClB,OAAOI,IAAAA;AACT,YAAA;AAEA,YAAA,MAAMC,KAAAA,GAAQH,QAAAA,CAASE,IAAAA,CAAKE,QAAQ,IAAI,EAAE,CAAA;AAC1C,YAAA,IAAID,KAAAA,EAAO;gBACT,OAAOA,KAAAA;AACT,YAAA;AACF,QAAA;QAEA,OAAO,IAAA;AACT,IAAA,CAAA;IAEA,OAAOH,QAAAA,CAASH,kBAAkBQ,IAAAA,IAAQN,SAAAA;AAC5C;;;;"}

package/dist/admin/src/future/pages/Assets/components/AssetsTable.d.ts

@@ -1,9 +1,15 @@
+import { type MixedItem } from '../utils/mergeMixedList';
 import type { File } from '../../../../../../shared/contracts/files';
 import type { Folder } from '../../../../../../shared/contracts/folders';
 interface AssetsTableProps {
     assets: File[];
     folders?: Folder[];
+    /**
+     * When set ("Folders: Mixed with files"), rows render in this interleaved
+     * order instead of folders-first. Range selection follows the same order.
+     */
+    mixedItems?: MixedItem[] | null;
     onAssetItemClick: (assetId: number) => void;
 }
-export declare const AssetsTable: ({ assets, folders, onAssetItemClick }: AssetsTableProps) => import("react/jsx-runtime").JSX.Element | null;
+export declare const AssetsTable: ({ assets, folders, mixedItems, onAssetItemClick, }: AssetsTableProps) => import("react/jsx-runtime").JSX.Element | null;
 export {};

package/dist/admin/src/future/pages/Assets/components/BulkActionsBar.d.ts

@@ -0,0 +1 @@
+export declare const BulkActionsBar: () => import("react/jsx-runtime").JSX.Element | null;

package/dist/admin/src/future/pages/Assets/components/BulkMoveDialog.d.ts

@@ -0,0 +1,13 @@
+interface BulkMoveDialogProps {
+    open: boolean;
+    onClose: () => void;
+}
+/**
+ * "Move elements to" modal for the bulk actions bar. Moves the current
+ * selection (assets and/or folders) into the picked destination folder via
+ * `POST /upload/actions/bulk-move`. The mutation invalidates the asset list,
+ * folder list and the sidebar folder-structure, so both panes refresh on
+ * success. On failure the modal stays open so the user can retry or cancel.
+ */
+export declare const BulkMoveDialog: ({ open, onClose }: BulkMoveDialogProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/future/pages/Assets/components/Dnd/AssetsDndProvider.d.ts

@@ -2,6 +2,8 @@ import { type ReactNode } from 'react';
 interface AssetsDndContextValue {
     isInternalDragActive: boolean;
     isMovePending: boolean;
+    /** O(1) lookup of whether the current drag set may drop on this destination. */
+    isValidDropTarget: (targetFolderId: number | null) => boolean;
 }
 export declare const useAssetsDnd: () => AssetsDndContextValue;
 export declare const useAssetsDndOptional: () => AssetsDndContextValue | null;

package/dist/admin/src/future/pages/Assets/components/Dnd/DragOverlayChip.d.ts

@@ -1,6 +1,6 @@
 import type { DragItemData } from '../../../../types/dnd';
 interface DragOverlayChipProps {
-    item: DragItemData;
+    items: DragItemData[];
 }
-export declare const DragOverlayChip: ({ item }: DragOverlayChipProps) => import("react/jsx-runtime").JSX.Element;
+export declare const DragOverlayChip: ({ items }: DragOverlayChipProps) => import("react/jsx-runtime").JSX.Element | null;
 export {};

package/dist/admin/src/future/pages/Assets/components/Dnd/buildDragSet.d.ts

@@ -0,0 +1,17 @@
+import { type ItemKey } from '../../utils/selection';
+import type { DragItemData } from '../../../../types/dnd';
+export interface DragSet {
+    items: DragItemData[];
+    /** True when the active item was already selected — membership is the full selection. */
+    fromSelection: boolean;
+}
+/**
+ * Derive the drag payload once at drag start.
+ *
+ * - Dragging a selected item moves the complete current selection.
+ * - Dragging an unselected item moves only that item.
+ *
+ * Selection is page-scoped to the current folder, so every item is stamped with
+ * `currentFolderId` as its location for move validation.
+ */
+export declare const buildDragSet: (activeData: DragItemData, selectedKeys: Set<ItemKey> | undefined, currentFolderId: number | null) => DragSet;

package/dist/admin/src/future/pages/Assets/components/Dnd/computeValidDropTargets.d.ts

@@ -0,0 +1,7 @@
+import type { FolderNode } from '../../../../../../../shared/contracts/folders';
+import type { DragItemData } from '../../../../types/dnd';
+/**
+ * Evaluate destination validity once for the full drag set. Callers look up
+ * targets in O(1) via {@link Set.has} — `null` represents the Home/root drop.
+ */
+export declare const computeValidDropTargets: (items: DragItemData[], folderStructure: FolderNode[]) => Set<number | null>;

package/dist/admin/src/future/pages/Assets/components/Dnd/dndIds.d.ts

@@ -2,3 +2,6 @@ export declare const toFileDraggableId: (id: number) => `file:${number}`;
 export declare const toFolderDraggableId: (id: number) => `folder:${number}`;
 export declare const toFolderTargetId: (id: number) => `folder-target:${number}`;
 export declare const parseFolderTargetId: (dndId: string | number) => number | null;
+export declare const toFolderTreeTargetId: (id: number) => `folder-tree-target:${number}`;
+export declare const HOME_TREE_TARGET_ID: "folder-tree-target:home";
+export declare const parseFolderTreeTargetId: (dndId: string | number) => number | "root" | null;

package/dist/admin/src/future/pages/Assets/components/Dnd/useAssetDnd.d.ts

@@ -2,7 +2,9 @@ import type { DragFolderData } from '../../../../types/dnd';
 export declare const useFileDraggable: (asset: {
     id: number;
     name: string;
-    folder?: number | string | null;
+    folder?: number | string | {
+        id?: number;
+    } | null;
 }) => {
     active: import("@dnd-kit/core").Active | null;
     activatorEvent: Event | null;

package/dist/admin/src/future/pages/Assets/components/Dnd/useFolderTreeDroppable.d.ts

@@ -0,0 +1,19 @@
+export declare const useFolderTreeDroppable: (target: {
+    id: number;
+    name: string;
+} | {
+    id: null;
+    name: string;
+}) => {
+    droppable: {
+        active: import("@dnd-kit/core").Active | null;
+        rect: import("react").MutableRefObject<import("@dnd-kit/core").ClientRect | null>;
+        isOver: boolean;
+        node: import("react").MutableRefObject<HTMLElement | null>;
+        over: import("@dnd-kit/core").Over | null;
+        setNodeRef: (element: HTMLElement | null) => void;
+    };
+    isOver: boolean;
+    showValidDropHighlight: boolean;
+    showInvalidDropCursor: boolean;
+};

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

@@ -0,0 +1,6 @@
+export declare const SPRING_LOAD_DELAY_MS = 600;
+export declare const useSpringLoadedExpand: ({ isOver, canExpand, onExpand, }: {
+    isOver: boolean;
+    canExpand: boolean;
+    onExpand: () => void;
+}) => void;

package/dist/admin/src/future/pages/Assets/components/SortMenu.d.ts

@@ -0,0 +1,17 @@
+import { type ListSort } from '../hooks/useListSort';
+interface SortMenuProps {
+    sort: ListSort;
+    /**
+     * The grid view forces folders on top (mixing folder cards with asset cards
+     * is not supported there), so it hides the Folders group entirely.
+     */
+    showFoldersGroup?: boolean;
+}
+/**
+ * Toolbar "Sort" dropdown: single-select sections (Sort / Folders). Picking an
+ * option keeps the menu open (`onSelect` preventDefault) so several facets can
+ * be tuned in one visit; clicking a checked facet clears it (the hook
+ * guarantees at least one sort rule stays active).
+ */
+export declare const SortMenu: ({ sort, showFoldersGroup }: SortMenuProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,39 @@
+import { type ReactNode } from 'react';
+import { type ItemKey } from '../utils/selection';
+/**
+ * Ephemeral, view-state-only multi-select for the future Media Library. Selection
+ * is page-scoped and reset on folder navigation or sort/filter changes (the
+ * table/grid toggle keeps it — same list, different presentation).
+ *
+ * The actual computation lives in `../utils/selection.ts` (pure + unit-tested);
+ * this hook is a thin React wrapper. Assets and folders share one mechanism —
+ * items are tracked as namespaced keys (`asset:1` / `folder:1`) so toggle, range
+ * and select-all behave the same for both. Range / select-all receive the
+ * ordered key array from the caller (the view owns the rendered order), keeping
+ * the context data-source-agnostic.
+ */
+export interface AssetSelection {
+    /** Every selected item key (assets and folders), render-order agnostic. */
+    selectedKeys: Set<ItemKey>;
+    /** Selected asset ids, derived from {@link selectedKeys}. */
+    selectedIds: Set<number>;
+    /** Selected folder ids, derived from {@link selectedKeys}. */
+    selectedFolderIds: Set<number>;
+    anchorKey: ItemKey | null;
+    isSelected: (key: ItemKey) => boolean;
+    /** Additive toggle (Cmd/Ctrl+click, item checkbox). */
+    toggle: (key: ItemKey) => void;
+    /** Shift+click — selects the contiguous range from the anchor to the target. */
+    selectRange: (orderedKeys: ItemKey[], targetKey: ItemKey) => void;
+    /** Header checkbox — selects every rendered item (folders and assets). */
+    selectAll: (orderedKeys: ItemKey[]) => void;
+    /** Close button / folder navigation / list-identity changes. */
+    clear: () => void;
+}
+interface AssetSelectionProviderProps {
+    children: ReactNode;
+}
+export declare const AssetSelectionProvider: ({ children }: AssetSelectionProviderProps) => import("react").FunctionComponentElement<import("react").ProviderProps<AssetSelection | null>>;
+export declare const useAssetSelection: () => AssetSelection;
+export declare const useAssetSelectionOptional: () => AssetSelection | null;
+export {};

package/dist/admin/src/future/pages/Assets/hooks/useListSort.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Sort state for the assets list, backed by URL query params so the current
+ * ordering is shareable and survives Back/refresh:
+ *
+ * - `?sort=<rule>` — a single whitelisted rule. Omitted → default (most
+ *   recent updates).
+ * - `?folders=mixed` — folders interleaved with files. Omitted → folders on top.
+ *
+ * The date rules and the direction rules are mutually exclusive: exactly one
+ * rule is active at a time (one checkmark total, like the design mock). Picking
+ * an option in one group clears the other; clearing the active option falls
+ * back to the default — an unsorted list is not a state the UI offers.
+ */
+export declare const SORT_BY_RULES: {
+    readonly oldestUploads: "createdAt:ASC";
+    readonly mostRecentUpdates: "updatedAt:DESC";
+};
+export declare const SORT_DIRECTION_RULES: {
+    readonly nameAsc: "name:ASC";
+    readonly nameDesc: "name:DESC";
+    readonly sizeAsc: "size:ASC";
+    readonly sizeDesc: "size:DESC";
+};
+export type SortByKey = keyof typeof SORT_BY_RULES;
+export type SortDirectionKey = keyof typeof SORT_DIRECTION_RULES;
+export type FoldersPosition = 'top' | 'mixed';
+export interface ListSort {
+    sortBy: SortByKey | null;
+    direction: SortDirectionKey | null;
+    foldersPosition: FoldersPosition;
+    /**
+     * The active rule for the files query, e.g. `updatedAt:DESC` — always a
+     * single rule since the sort groups are mutually exclusive.
+     */
+    assetsSort: string;
+    /**
+     * Rule applicable to the folders query. In the default state (no sort in the
+     * URL) folders keep their alphabetical order so the band matches the sidebar
+     * tree; an explicit user sort applies, except size rules (folders have no
+     * `size` column), which fall back to alphabetical.
+     */
+    foldersSort: string;
+    setSortBy: (key: SortByKey | null) => void;
+    setDirection: (key: SortDirectionKey | null) => void;
+    setFoldersPosition: (position: FoldersPosition) => void;
+}
+export declare const useListSort: () => ListSort;

package/dist/admin/src/future/pages/Assets/utils/listQueryKey.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Fingerprint for "which asset list the user is looking at".
+ *
+ * Selection clears when this key changes (see ClearSelectionOnChange in AssetsPage).
+ *
+ * Hybrid rule
+ * - Folder, search, sort, filter changes → new key → selection clears.
+ * - Switching table/grid view does NOT change the key — both views render the
+ *   same list, so the selection survives the toggle.
+ * - Infinite scroll (load more) does NOT change any segment → selection persists.
+ *
+ * Search/filter use stable defaults until their header controls are wired;
+ * follow-up PRs only pass real values — no selection logic changes needed.
+ */
+export interface ListQueryKeyInput {
+    folderId: number | null;
+    /** Empty string until search UI ships. */
+    search: string;
+    /** Null until sort UI ships. */
+    sort: string | null;
+    /** Null until filter UI ships. */
+    filter: string | null;
+}
+/**
+ * Builds a stable fingerprint for the current asset list query.
+ *
+ * Selection clears when this key changes. Infinite scroll does not change any
+ * segment, so selection persists across load-more.
+ */
+export declare const getListQueryKey: ({ folderId, search, sort, filter }: ListQueryKeyInput) => string;

package/dist/admin/src/future/pages/Assets/utils/mergeMixedList.d.ts

@@ -0,0 +1,40 @@
+import type { File } from '../../../../../../shared/contracts/files';
+import type { Folder } from '../../../../../../shared/contracts/folders';
+export type MixedItem = {
+    kind: 'folder';
+    folder: Folder;
+} | {
+    kind: 'asset';
+    asset: File;
+};
+type SortableRecord = {
+    name?: string | null;
+    createdAt?: string | null;
+    updatedAt?: string | null;
+    size?: number | null;
+};
+/**
+ * Builds a comparator from comma-separated sort rules (`updatedAt:DESC,name:ASC`).
+ * Rules apply in order; the first non-equal field decides. Client-side
+ * approximation of the server ordering — good enough to slot folders between
+ * files that were sorted server-side by the same rules.
+ */
+export declare const buildComparator: (sort: string) => (a: SortableRecord, b: SortableRecord) => number;
+interface MergeMixedListParams {
+    folders: Folder[];
+    assets: File[];
+    /** Combined sort rules used for the assets query. */
+    sort: string;
+    /**
+     * More asset pages exist. A folder may only be placed once we know no
+     * not-yet-loaded asset sorts before it — i.e. it compares ≤ the last loaded
+     * asset. Later pages release the remaining folders progressively.
+     */
+    hasNextPage: boolean;
+}
+/**
+ * Interleaves the complete folder list into the (possibly partially loaded)
+ * asset stream according to the active sort. Ties order folders first.
+ */
+export declare const mergeMixedList: ({ folders, assets, sort, hasNextPage, }: MergeMixedListParams) => MixedItem[];
+export {};

package/dist/admin/src/future/pages/Assets/utils/selection.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Pure, view-agnostic selection logic for the future Media Library multi-select.
+ *
+ * Selection covers both assets and folders. Since their numeric ids live in
+ * different tables (and can collide), items are tracked as namespaced keys
+ * (`asset:1` / `folder:1`). Views build their rendered order as a key array so
+ * range / select-all work across the folder and asset sections seamlessly.
+ */
+export type SelectableKind = 'asset' | 'folder';
+export type ItemKey = `${SelectableKind}:${number}`;
+export declare const assetKey: (id: number) => ItemKey;
+export declare const folderKey: (id: number) => ItemKey;
+/** Extracts the numeric ids of one kind from a set of item keys. */
+export declare const getIdsOfKind: (keys: Set<ItemKey>, kind: SelectableKind) => Set<number>;
+export interface SelectionState {
+    /** Currently selected item keys (assets and folders). */
+    selectedKeys: Set<ItemKey>;
+    /** Anchor used as the start of a Shift+click range. */
+    anchorKey: ItemKey | null;
+}
+export declare const createEmptySelection: () => SelectionState;
+/**
+ * Additive toggle — adds the key if absent, removes it otherwise, without
+ * touching the rest of the selection. Used by the item checkbox and Cmd/Ctrl+click.
+ * The toggled key becomes the new anchor.
+ */
+export declare const toggleSelection: (state: SelectionState, key: ItemKey) => SelectionState;
+/**
+ * Shift+click — selects the contiguous range between the current anchor and the
+ * target in render order, replacing the current selection. The anchor stays put.
+ *
+ * Falls back to a single selection when there is no usable anchor (e.g. first
+ * click was a Shift+click, or the anchor is no longer in the list).
+ */
+export declare const selectRange: (state: SelectionState, orderedKeys: ItemKey[], targetKey: ItemKey) => SelectionState;
+/**
+ * Select-all — selects every key in the provided ordered array. Used by the header
+ * checkbox when not everything is already selected.
+ */
+export declare const selectAll: (orderedKeys: ItemKey[]) => SelectionState;
+export declare const clearSelection: () => SelectionState;
+export interface SelectAllState {
+    allSelected: boolean;
+    isIndeterminate: boolean;
+}
+/**
+ * Derives the header checkbox state: everything selected, some (indeterminate),
+ * or none. Only considers the currently-rendered items (orderedKeys).
+ */
+export declare const getSelectAllState: (selectedKeys: Set<ItemKey>, orderedKeys: ItemKey[]) => SelectAllState;

package/dist/admin/src/future/services/assets.d.ts

@@ -18,5 +18,8 @@ interface ReplaceAssetArgs {
     file: globalThis.File;
     fileInfo?: Partial<UploadFileInfo>;
 }
-export declare const useGetAssetsQuery: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseQuery<import("@reduxjs/toolkit/query").QueryDefinition<void | GetAssetsParams, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", GetAssetsResponse, "adminApi">>, useGetAssetQuery: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseQuery<import("@reduxjs/toolkit/query").QueryDefinition<number, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", AssetWithPopulatedCreatedBy, "adminApi">>, useUpdateAssetMutation: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseMutation<import("@reduxjs/toolkit/query").MutationDefinition<UpdateAssetArgs, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", AssetWithPopulatedCreatedBy, "adminApi">>, useReplaceAssetMutation: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseMutation<import("@reduxjs/toolkit/query").MutationDefinition<ReplaceAssetArgs, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", AssetWithPopulatedCreatedBy, "adminApi">>, useDeleteAssetMutation: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseMutation<import("@reduxjs/toolkit/query").MutationDefinition<number, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", unknown, "adminApi">>;
+export declare const useGetAssetsQuery: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseQuery<import("@reduxjs/toolkit/query").QueryDefinition<void | GetAssetsParams, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", GetAssetsResponse, "adminApi">>, useGetAssetQuery: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseQuery<import("@reduxjs/toolkit/query").QueryDefinition<number, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", AssetWithPopulatedCreatedBy, "adminApi">>, useUpdateAssetMutation: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseMutation<import("@reduxjs/toolkit/query").MutationDefinition<UpdateAssetArgs, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", AssetWithPopulatedCreatedBy, "adminApi">>, useReplaceAssetMutation: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseMutation<import("@reduxjs/toolkit/query").MutationDefinition<ReplaceAssetArgs, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", AssetWithPopulatedCreatedBy, "adminApi">>, useDeleteAssetMutation: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseMutation<import("@reduxjs/toolkit/query").MutationDefinition<number, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", unknown, "adminApi">>, useBulkDeleteItemsMutation: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseMutation<import("@reduxjs/toolkit/query").MutationDefinition<{
+    fileIds: number[];
+    folderIds: number[];
+}, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", unknown, "adminApi">>;
 export {};

package/dist/admin/src/future/services/folders.d.ts

@@ -9,11 +9,14 @@ export type FolderWithCounts = Omit<Folder, 'children' | 'files'> & {
 };
 interface GetFoldersParams {
     parentId?: number | null;
+    /** Comma-separated rules, e.g. `updatedAt:DESC,name:ASC`. Defaults to alphabetical. */
+    sort?: string;
 }
 interface BulkMoveParams {
     fileIds?: number[];
     folderIds?: number[];
-    destinationFolderId: number;
+    /** `null` moves the items to the root of the Media Library. */
+    destinationFolderId: number | null;
 }
 export declare const useCreateFolderMutation: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseMutation<import("@reduxjs/toolkit/query").MutationDefinition<Pick<Folder, "name" | "parent">, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", Folder, "adminApi">>, useGetFoldersQuery: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseQuery<import("@reduxjs/toolkit/query").QueryDefinition<void | GetFoldersParams, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", Folder[], "adminApi">>, useGetFolderQuery: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseQuery<import("@reduxjs/toolkit/query").QueryDefinition<{
     id: number;

package/dist/admin/src/future/types/dnd.d.ts

@@ -16,6 +16,11 @@ export interface FolderTargetData {
     id: number;
     name: string;
 }
+export interface FolderTreeTargetData {
+    kind: 'folder-tree-target';
+    id: number | null;
+    name: string;
+}
 export interface BulkMovePayload {
     fileIds: number[];
     folderIds: number[];

package/dist/admin/src/future/utils/buildDragSetFromSelection.d.ts

@@ -0,0 +1,11 @@
+import type { DragItemData } from '../types/dnd';
+/**
+ * Reconstruct the drag set from a bulk-actions selection so the dialog can feed
+ * the exact same `DragItemData[]` into `computeValidDropTargets` / the canonical
+ * `canDropItemOnFolder` predicate that pointer drag uses.
+ *
+ * Selection is page-scoped to the current folder, so every selected item shares
+ * `currentFolderId` as its location (files → `folderId`, folders → `parentId`).
+ * Names are irrelevant to drop validation, so they are left empty.
+ */
+export declare const buildDragSetFromSelection: (selectedIds: ReadonlySet<number>, selectedFolderIds: ReadonlySet<number>, currentFolderId: number | null) => DragItemData[];

package/dist/admin/src/future/utils/canDropItemOnFolder.d.ts

@@ -2,7 +2,7 @@ import type { FolderNode } from '../../../../shared/contracts/folders';
 import type { DragItemData } from '../types/dnd';
 export interface CanDropItemOnFolderParams {
     items: DragItemData[];
-    targetFolderId: number;
+    targetFolderId: number | null;
     folderStructure: FolderNode[];
 }
 export declare const isFolderDescendantOf: (folderStructure: FolderNode[], ancestorId: number, candidateId: number) => boolean;

package/dist/admin/src/future/utils/flattenFolderStructure.d.ts

@@ -0,0 +1,18 @@
+import type { FolderNode } from '../../../../shared/contracts/folders';
+export interface FlatFolderOption {
+    id: number;
+    /** Full ancestry label, e.g. "About / Images". */
+    label: string;
+}
+/**
+ * Flattens the nested folder structure (`/upload/folder-structure`) into a
+ * depth-first list of `{ id, label }` options where the label carries the full
+ * ancestry path. Used by destination selects so folders sharing a name stay
+ * distinguishable ("About / Images" vs "Tech / Images"), with children listed
+ * right under their parent.
+ *
+ * `excludeSubtreeIds` prunes a folder *and everything below it* in the same
+ * single pass — used to drop the selected folders (and their descendants) from
+ * bulk-move destinations without re-walking the tree per option.
+ */
+export declare const flattenFolderStructure: (nodes: FolderNode[], excludeSubtreeIds?: ReadonlySet<number>, parentLabel?: string) => FlatFolderOption[];

package/dist/admin/src/future/utils/formatMoveSuccessMessage.d.ts

@@ -0,0 +1,14 @@
+import type { IntlShape } from 'react-intl';
+interface FormatMoveSuccessArgs {
+    formatMessage: IntlShape['formatMessage'];
+    count: number;
+    source: string;
+    destination: string;
+}
+/**
+ * Single source of truth for the bulk-move success wording. Both the DnD drop
+ * and the BulkMoveDialog format the toast (and DnD live-region announcement)
+ * through here so the two paths stay identical for the same move.
+ */
+export declare const formatMoveSuccessMessage: ({ formatMessage, count, source, destination, }: FormatMoveSuccessArgs) => string;
+export {};

package/dist/admin/src/future/utils/getFolderLabel.d.ts

@@ -0,0 +1,11 @@
+import type { FolderNode } from '../../../../shared/contracts/folders';
+/**
+ * Leaf display name for a folder id. `null` (root) → the Media Library label.
+ * Used by both the DnD success toast and the dialog success toast so the two
+ * paths name folders identically. Ancestry paths belong only in the dialog's
+ * select options (see `flattenFolderStructure`).
+ *
+ * `id === null` returns `rootLabel`; an unknown id falls back to `rootLabel`
+ * too (defensive — mirrors the dialog's previous `?? rootLabel`).
+ */
+export declare const getFolderLabel: (folderStructure: FolderNode[], id: number | null, rootLabel: string) => string;

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

@@ -162,6 +162,18 @@ var en = {
     "list.empty.title": "No assets yet",
     "list.empty.description": "Get started by uploading assets or creating a folder.",
     "list.empty.add-assets": "Add assets",
+    "list.sort.trigger": "Sort: {active}",
+    "list.sort.section": "Sort",
+    "list.sort.oldest-uploads": "Oldest uploads",
+    "list.sort.most-recent-updates": "Most recent updates",
+    "list.sort.name-asc": "A to Z",
+    "list.sort.name-desc": "Z to A",
+    "list.sort.size-asc": "File size ascending",
+    "list.sort.size-desc": "File size descending",
+    "list.sort.folders": "Folders",
+    "list.sort.folders-on-top": "On top",
+    "list.sort.folders-mixed": "Mixed with files",
+    "list.sort.active": "(active)",
     "list.assets.loading-more": "Loading more assets...",
     "list.assets.loading-asset": "Loading the preview for the media: {path}",
     "list.assets.not-supported-content": "No preview available",
@@ -203,6 +215,8 @@ var en = {
     "dnd.announce.invalid-drop": "Cannot move item to this folder.",
     "dnd.announce.move-failure": "Move failed. {message}",
     "dnd.announce.cancel": "Drag cancelled.",
+    "dnd.overlay.folders": "{count, plural, one {# folder} other {# folders}}",
+    "dnd.overlay.files": "{count, plural, one {# file} other {# files}}",
     "modal.selected-list.sub-header-subtitle": "Drag & drop to reorder the assets in the field",
     "modal.upload-list.footer.button": "Upload {number, plural, one {# asset} other {# assets}} to the library",
     "modal.upload-list.sub-header-subtitle": "Manage the assets before adding them to the Media Library",
@@ -258,7 +272,26 @@ var en = {
     "list.table.header.creationDate": "Creation Date",
     "list.table.header.lastModified": "Last Modified",
     "list.table.header.sort": "Sort on {label}",
+    "list.table.header.select-all": "Select all",
+    "list.table.row.select": "Select {name}",
     "list.table.content.empty-label": "This field is empty",
+    "list.bulk-actions.label": "Bulk actions",
+    "list.bulk-actions.selected-count": "{count, plural, =1 {# item selected} other {# items selected}}",
+    "list.bulk-actions.clear": "Clear selection",
+    "list.bulk-actions.create-metadata": "Create metadata",
+    "list.bulk-actions.move": "Move",
+    "list.bulk-actions.move.title": "Move elements to",
+    "list.bulk-actions.move.location": "Location",
+    "list.bulk-actions.move.submit": "Move",
+    "list.bulk-actions.move.success": "{count, plural, =1 {# element has} other {# elements have}} been moved from {source} to {destination}",
+    "list.bulk-actions.move.error": "An error occurred while moving the items.",
+    "list.bulk-actions.delete": "Delete",
+    "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.",
+    "list.bulk-actions.delete.success": "{count, plural, =1 {# item has been deleted} other {# items have been deleted}}",
+    "list.bulk-actions.delete.error": "An error occurred while deleting the items.",
+    "list.bulk-actions.create-metadata-not-available": "Generate metadata isn't available yet",
     "tabs.title": "How do you want to upload your assets?",
     "window.confirm.close-modal.file": "Are you sure? Your changes will be lost.",
     "window.confirm.close-modal.files": "Are you sure? You have some files that have not been uploaded yet.",

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

@@ -160,6 +160,18 @@ var en = {
     "list.empty.title": "No assets yet",
     "list.empty.description": "Get started by uploading assets or creating a folder.",
     "list.empty.add-assets": "Add assets",
+    "list.sort.trigger": "Sort: {active}",
+    "list.sort.section": "Sort",
+    "list.sort.oldest-uploads": "Oldest uploads",
+    "list.sort.most-recent-updates": "Most recent updates",
+    "list.sort.name-asc": "A to Z",
+    "list.sort.name-desc": "Z to A",
+    "list.sort.size-asc": "File size ascending",
+    "list.sort.size-desc": "File size descending",
+    "list.sort.folders": "Folders",
+    "list.sort.folders-on-top": "On top",
+    "list.sort.folders-mixed": "Mixed with files",
+    "list.sort.active": "(active)",
     "list.assets.loading-more": "Loading more assets...",
     "list.assets.loading-asset": "Loading the preview for the media: {path}",
     "list.assets.not-supported-content": "No preview available",
@@ -201,6 +213,8 @@ var en = {
     "dnd.announce.invalid-drop": "Cannot move item to this folder.",
     "dnd.announce.move-failure": "Move failed. {message}",
     "dnd.announce.cancel": "Drag cancelled.",
+    "dnd.overlay.folders": "{count, plural, one {# folder} other {# folders}}",
+    "dnd.overlay.files": "{count, plural, one {# file} other {# files}}",
     "modal.selected-list.sub-header-subtitle": "Drag & drop to reorder the assets in the field",
     "modal.upload-list.footer.button": "Upload {number, plural, one {# asset} other {# assets}} to the library",
     "modal.upload-list.sub-header-subtitle": "Manage the assets before adding them to the Media Library",
@@ -256,7 +270,26 @@ var en = {
     "list.table.header.creationDate": "Creation Date",
     "list.table.header.lastModified": "Last Modified",
     "list.table.header.sort": "Sort on {label}",
+    "list.table.header.select-all": "Select all",
+    "list.table.row.select": "Select {name}",
     "list.table.content.empty-label": "This field is empty",
+    "list.bulk-actions.label": "Bulk actions",
+    "list.bulk-actions.selected-count": "{count, plural, =1 {# item selected} other {# items selected}}",
+    "list.bulk-actions.clear": "Clear selection",
+    "list.bulk-actions.create-metadata": "Create metadata",
+    "list.bulk-actions.move": "Move",
+    "list.bulk-actions.move.title": "Move elements to",
+    "list.bulk-actions.move.location": "Location",
+    "list.bulk-actions.move.submit": "Move",
+    "list.bulk-actions.move.success": "{count, plural, =1 {# element has} other {# elements have}} been moved from {source} to {destination}",
+    "list.bulk-actions.move.error": "An error occurred while moving the items.",
+    "list.bulk-actions.delete": "Delete",
+    "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.",
+    "list.bulk-actions.delete.success": "{count, plural, =1 {# item has been deleted} other {# items have been deleted}}",
+    "list.bulk-actions.delete.error": "An error occurred while deleting the items.",
+    "list.bulk-actions.create-metadata-not-available": "Generate metadata isn't available yet",
     "tabs.title": "How do you want to upload your assets?",
     "window.confirm.close-modal.file": "Are you sure? Your changes will be lost.",
     "window.confirm.close-modal.files": "Are you sure? You have some files that have not been uploaded yet.",

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