@strapi/upload 5.35.0 → 5.36.1

package/dist/admin/package.json.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var name = "@strapi/upload";
-var version = "5.35.0";
+var version = "5.36.1";
 var description = "Makes it easy to upload images and files to your Strapi Application.";
 var license = "SEE LICENSE IN LICENSE";
 var author = {
@@ -64,12 +64,14 @@ var scripts = {
 };
 var dependencies = {
     "@mux/mux-player-react": "3.1.0",
+    "@radix-ui/react-dialog": "1.1.15",
+    "@radix-ui/react-toggle-group": "1.1.11",
     "@reduxjs/toolkit": "1.9.7",
-    "@strapi/database": "5.33.3",
+    "@strapi/database": "5.36.1",
     "@strapi/design-system": "2.1.2",
     "@strapi/icons": "2.1.2",
-    "@strapi/provider-upload-local": "5.35.0",
-    "@strapi/utils": "5.35.0",
+    "@strapi/provider-upload-local": "5.36.1",
+    "@strapi/utils": "5.36.1",
     "byte-size": "8.1.1",
     cropperjs: "1.6.1",
     "date-fns": "2.30.0",
@@ -82,7 +84,7 @@ var dependencies = {
     lodash: "4.17.21",
     "mime-types": "2.1.35",
     "prop-types": "^15.8.1",
-    qs: "6.14.1",
+    qs: "6.14.2",
     "react-dnd": "16.0.1",
     "react-intl": "6.6.2",
     "react-query": "3.39.3",
@@ -93,8 +95,8 @@ var dependencies = {
     zod: "3.25.67"
 };
 var devDependencies = {
-    "@strapi/admin": "5.35.0",
-    "@strapi/types": "5.35.0",
+    "@strapi/admin": "5.36.1",
+    "@strapi/types": "5.36.1",
     "@testing-library/dom": "10.4.1",
     "@testing-library/react": "16.3.0",
     "@testing-library/user-event": "14.6.1",
@@ -109,14 +111,14 @@ var devDependencies = {
     msw: "1.3.0",
     react: "18.3.1",
     "react-dom": "18.3.1",
-    "react-router-dom": "6.22.3",
+    "react-router-dom": "6.30.3",
     "styled-components": "6.1.8"
 };
 var peerDependencies = {
     "@strapi/admin": "^5.0.0",
     react: "^17.0.0 || ^18.0.0",
     "react-dom": "^17.0.0 || ^18.0.0",
-    "react-router-dom": "^6.0.0",
+    "react-router-dom": "^6.30.3",
     "styled-components": "^6.0.0"
 };
 var engines = {

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

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

package/dist/admin/package.json.mjs

@@ -1,5 +1,5 @@
 var name = "@strapi/upload";
-var version = "5.35.0";
+var version = "5.36.1";
 var description = "Makes it easy to upload images and files to your Strapi Application.";
 var license = "SEE LICENSE IN LICENSE";
 var author = {
@@ -60,12 +60,14 @@ var scripts = {
 };
 var dependencies = {
     "@mux/mux-player-react": "3.1.0",
+    "@radix-ui/react-dialog": "1.1.15",
+    "@radix-ui/react-toggle-group": "1.1.11",
     "@reduxjs/toolkit": "1.9.7",
-    "@strapi/database": "5.33.3",
+    "@strapi/database": "5.36.1",
     "@strapi/design-system": "2.1.2",
     "@strapi/icons": "2.1.2",
-    "@strapi/provider-upload-local": "5.35.0",
-    "@strapi/utils": "5.35.0",
+    "@strapi/provider-upload-local": "5.36.1",
+    "@strapi/utils": "5.36.1",
     "byte-size": "8.1.1",
     cropperjs: "1.6.1",
     "date-fns": "2.30.0",
@@ -78,7 +80,7 @@ var dependencies = {
     lodash: "4.17.21",
     "mime-types": "2.1.35",
     "prop-types": "^15.8.1",
-    qs: "6.14.1",
+    qs: "6.14.2",
     "react-dnd": "16.0.1",
     "react-intl": "6.6.2",
     "react-query": "3.39.3",
@@ -89,8 +91,8 @@ var dependencies = {
     zod: "3.25.67"
 };
 var devDependencies = {
-    "@strapi/admin": "5.35.0",
-    "@strapi/types": "5.35.0",
+    "@strapi/admin": "5.36.1",
+    "@strapi/types": "5.36.1",
     "@testing-library/dom": "10.4.1",
     "@testing-library/react": "16.3.0",
     "@testing-library/user-event": "14.6.1",
@@ -105,14 +107,14 @@ var devDependencies = {
     msw: "1.3.0",
     react: "18.3.1",
     "react-dom": "18.3.1",
-    "react-router-dom": "6.22.3",
+    "react-router-dom": "6.30.3",
     "styled-components": "6.1.8"
 };
 var peerDependencies = {
     "@strapi/admin": "^5.0.0",
     react: "^17.0.0 || ^18.0.0",
     "react-dom": "^17.0.0 || ^18.0.0",
-    "react-router-dom": "^6.0.0",
+    "react-router-dom": "^6.30.3",
     "styled-components": "^6.0.0"
 };
 var engines = {

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

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

package/dist/admin/src/future/components/UploadProgressDialog.d.ts

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

package/dist/admin/src/future/enums.d.ts

@@ -0,0 +1,6 @@
+export declare enum AssetType {
+    Video = "video",
+    Image = "image",
+    Document = "doc",
+    Audio = "audio"
+}

package/dist/admin/src/future/pages/Assets/AssetsPage.d.ts

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

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

@@ -0,0 +1,6 @@
+import type { File } from '../../../../../../shared/contracts/files';
+interface AssetsGridProps {
+    assets: File[];
+}
+export declare const AssetsGrid: ({ assets }: AssetsGridProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,6 @@
+import type { File } from '../../../../../../shared/contracts/files';
+interface AssetsTableProps {
+    assets: File[];
+}
+export declare const AssetsTable: ({ assets }: AssetsTableProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,9 @@
+import * as React from 'react';
+declare const DropZoneWithOverlay: ({ children }: {
+    children: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+interface DropFilesMessageProps {
+    uploadDropZoneRef?: React.RefObject<HTMLDivElement>;
+}
+declare const DropFilesMessage: ({ uploadDropZoneRef }: DropFilesMessageProps) => import("react/jsx-runtime").JSX.Element | null;
+export { DropZoneWithOverlay, DropFilesMessage };

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

@@ -0,0 +1,11 @@
+import { type ReactNode } from 'react';
+type DropHandler = (files: File[]) => void | Promise<void>;
+interface UploadDropZoneProps {
+    children: ReactNode;
+    onDrop?: DropHandler;
+}
+export declare const UploadDropZoneProvider: ({ children, onDrop }: UploadDropZoneProps) => import("react/jsx-runtime").JSX.Element;
+export declare const useUploadDropZone: () => {
+    isDragging: boolean;
+};
+export {};

package/dist/admin/src/future/pages/Assets/constants.d.ts

@@ -0,0 +1,17 @@
+export declare const localStorageKeys: {
+    view: string;
+};
+export declare const viewOptions: {
+    GRID: number;
+    TABLE: number;
+};
+interface TableHeader {
+    name: string;
+    label: {
+        id: string;
+        defaultMessage: string;
+    };
+    isVisuallyHidden?: boolean;
+}
+export declare const TABLE_HEADERS: TableHeader[];
+export {};

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

@@ -0,0 +1,17 @@
+import type { File } from '../../../../../../shared/contracts/files';
+declare const PAGE_SIZE = 20;
+interface UseInfiniteAssetsOptions {
+    folder?: number | null;
+    sort?: string;
+}
+declare const useInfiniteAssets: ({ folder, sort }?: UseInfiniteAssetsOptions) => {
+    assets: File[];
+    pagination: import("../../../../../../shared/contracts/files").Pagination | undefined;
+    isLoading: boolean;
+    isFetchingMore: boolean;
+    hasNextPage: boolean;
+    fetchNextPage: () => void;
+    error: import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError | undefined;
+};
+export { useInfiniteAssets };
+export { PAGE_SIZE };

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

@@ -1,6 +1,24 @@
-import type { CreateFile } from '../../../../shared/contracts/files';
+import type { CreateFilesStream } from '../../../../shared/contracts/files';
+interface UploadFilesArgs {
+    formData: FormData;
+    totalFiles: number;
+}
+/**
+ * Aborts an upload by its uploadId.
+ * Called from the UploadProgressDialog when the user clicks cancel or close.
+ */
+export declare const abortUpload: (uploadId: number) => void;
 declare const uploadApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError, {}, {}>, import("@reduxjs/toolkit/dist/query/endpointDefinitions").UpdateDefinitions<{}, "GuidedTourMeta" | "HomepageKeyStatistics" | "AIUsage" | "AIFeatureConfig" | "Asset" | "Folder", never> & {
-    uploadFiles: import("@reduxjs/toolkit/query").MutationDefinition<FormData, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AIUsage" | "AIFeatureConfig" | "Asset" | "Folder", CreateFile.Response, "adminApi">;
+    /**
+     * Stream upload files to the /upload/unstable/stream endpoint.
+     * Reads SSE stream for per-file progress updates.
+     */
+    uploadFilesStream: import("@reduxjs/toolkit/query").MutationDefinition<UploadFilesArgs, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AIUsage" | "AIFeatureConfig" | "Asset" | "Folder", CreateFilesStream.Response, "adminApi">;
+    /**
+     * Retry uploading cancelled files.
+     * Retrieves original File objects and re-uploads only the cancelled ones.
+     */
+    retryCancelledFilesStream: import("@reduxjs/toolkit/query").MutationDefinition<void, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AIUsage" | "AIFeatureConfig" | "Asset" | "Folder", CreateFilesStream.Response, "adminApi">;
 }, "adminApi", "GuidedTourMeta" | "HomepageKeyStatistics" | "AIUsage" | "AIFeatureConfig" | "Asset" | "Folder", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/dist/query/react").reactHooksModuleName>;
-export declare const useUploadFilesMutation: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseMutation<import("@reduxjs/toolkit/query").MutationDefinition<FormData, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AIUsage" | "AIFeatureConfig" | "Asset" | "Folder", CreateFile.Response, "adminApi">>;
+export declare const useUploadFilesStreamMutation: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseMutation<import("@reduxjs/toolkit/query").MutationDefinition<UploadFilesArgs, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AIUsage" | "AIFeatureConfig" | "Asset" | "Folder", CreateFilesStream.Response, "adminApi">>, useRetryCancelledFilesStreamMutation: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseMutation<import("@reduxjs/toolkit/query").MutationDefinition<void, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AIUsage" | "AIFeatureConfig" | "Asset" | "Folder", CreateFilesStream.Response, "adminApi">>;
 export { uploadApi };

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

@@ -0,0 +1,13 @@
+import type { File, Pagination } from '../../../../shared/contracts/files';
+interface GetAssetsParams {
+    page?: number;
+    pageSize?: number;
+    folder?: number | null;
+    sort?: string;
+}
+interface GetAssetsResponse {
+    results: File[];
+    pagination: Pagination;
+}
+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, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AIUsage" | "AIFeatureConfig" | "Asset" | "Folder", GetAssetsResponse, "adminApi">>;
+export {};

package/dist/admin/src/future/store/hooks.d.ts

@@ -0,0 +1,6 @@
+import { Dispatch } from '@reduxjs/toolkit';
+import { TypedUseSelectorHook } from 'react-redux';
+import type { RootState } from './uploadProgress';
+declare const useTypedDispatch: () => Dispatch;
+declare const useTypedSelector: TypedUseSelectorHook<RootState>;
+export { useTypedSelector, useTypedDispatch };

package/dist/admin/src/future/store/uploadProgress.d.ts

@@ -0,0 +1,46 @@
+import type { File } from '../../../../shared/contracts/files';
+export interface FileUploadError {
+    name: string;
+    message: string;
+}
+export type FileProgressStatus = 'pending' | 'uploading' | 'complete' | 'error' | 'cancelled';
+export interface FileProgress {
+    name: string;
+    index: number;
+    status: FileProgressStatus;
+    size: number;
+    file?: File;
+    error?: string;
+}
+export interface UploadProgressState {
+    isVisible: boolean;
+    isMinimized: boolean;
+    progress: number;
+    totalFiles: number;
+    files: FileProgress[];
+    errors: FileUploadError[];
+    uploadId: number;
+}
+export interface RootState {
+    uploadProgress: UploadProgressState;
+}
+export declare const openUploadProgress: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    totalFiles: number;
+    fileNames: string[];
+    fileSizes: number[];
+}, "uploadProgress/openUploadProgress">, setFileUploading: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    name: string;
+    index: number;
+    total: number;
+    size: number;
+}, "uploadProgress/setFileUploading">, setFileComplete: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    index: number;
+    file: File;
+}, "uploadProgress/setFileComplete">, setFileError: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    index: number;
+    name: string;
+    message: string;
+}, "uploadProgress/setFileError">, updateProgress: import("@reduxjs/toolkit").ActionCreatorWithPayload<number, "uploadProgress/updateProgress">, addUploadErrors: import("@reduxjs/toolkit").ActionCreatorWithPayload<FileUploadError[], "uploadProgress/addUploadErrors">, closeUploadProgress: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"uploadProgress/closeUploadProgress">, toggleMinimize: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"uploadProgress/toggleMinimize">, cancelUpload: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"uploadProgress/cancelUpload">, setUploadFailed: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    message: string;
+}, "uploadProgress/setUploadFailed">, retryCancelledFiles: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"uploadProgress/retryCancelledFiles">;
+export declare const uploadProgressReducer: import("redux").Reducer<UploadProgressState>;

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

@@ -0,0 +1,3 @@
+export declare function formatBytes(receivedBytes: number | string, decimals?: number): string;
+export declare const getFileExtension: (ext?: string | null) => string | null | undefined;
+export declare const prefixFileUrlWithBackendUrl: (fileURL?: string) => string | undefined;

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

@@ -0,0 +1,12 @@
+import { SVGProps } from 'react';
+import { DefaultTheme } from 'styled-components';
+interface IconProps extends Omit<SVGProps<SVGSVGElement>, 'fill' | 'stroke'> {
+    /**
+     * @default "currentColor"
+     */
+    fill?: keyof DefaultTheme['colors'] | string;
+    stroke?: keyof DefaultTheme['colors'] | string;
+}
+type IconComponent = React.FC<IconProps>;
+export declare const getAssetIcon: (mime: string | undefined, ext: string | undefined) => IconComponent;
+export {};

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

@@ -4,6 +4,28 @@ var en = {
     "apiError.FileTooBig": "The uploaded file exceeds the maximum allowed asset size.",
     "assets.uploaded": "{number, plural, one {# asset} other {# assets}} uploaded successfully",
     "upload.generic-error": "An error occurred while uploading the file.",
+    "upload.progress": "Upload progress",
+    "upload.progress.failed": "Upload failed",
+    "upload.progress.failed.subtitle": "Please try to upload files again",
+    "upload.progress.success": "Upload successful!",
+    "upload.progress.success.subtitle": "{count, plural, one {# file uploaded successfully} other {# files uploaded successfully}}",
+    "upload.progress.uploading.withCount": "Uploading {total} items ({percentage}%)",
+    "upload.progress.uploading-files": "Uploading {count, plural, one {# file} other {# files}}",
+    "upload.progress.indicator.in-progress": "Upload in progress indicator",
+    "upload.progress.indicator.complete": "Upload complete indicator",
+    "upload.progress.label": "Upload",
+    "upload.progress.errors.title": "Failed to upload:",
+    "upload.progress.cancel": "Cancel",
+    "upload.progress.canceled": "Uploads canceled",
+    "upload.progress.canceled.subtitle": "Some files were not uploaded",
+    "upload.progress.canceled.subtitle.all": "All uploads were canceled",
+    "upload.progress.retry": "Retry",
+    "upload.progress.file.uploading": "Uploading...",
+    "upload.progress.file.canceled": "Canceled",
+    "upload.progress.file.uploaded": "Uploaded",
+    "upload.progress.maximize": "Maximize",
+    "upload.progress.minimize": "Minimize",
+    "upload.progress.close": "Close",
     "bulk.select.label": "Select all assets",
     "button.next": "Next",
     "new": "New",
@@ -24,6 +46,7 @@ var en = {
     "control-card.replace-media": "Replace Media",
     "control-card.save": "Save",
     "control-card.stop-crop": "Stop cropping",
+    "dropzone.upload.message": "Drop here to upload to",
     "filter.add": "Add filter",
     "form.button.replace-media": "Replace media",
     "form.input.description.file-alt": "This text will be displayed if the asset can’t be shown.",
@@ -145,6 +168,8 @@ var en = {
     "list.table.header.size": "size",
     "list.table.header.createdAt": "created",
     "list.table.header.updatedAt": "last update",
+    "list.table.header.creationDate": "Creation Date",
+    "list.table.header.lastModified": "Last Modified",
     "list.table.header.sort": "Sort on {label}",
     "list.table.content.empty-label": "This field is empty",
     "tabs.title": "How do you want to upload your assets?",

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

@@ -2,6 +2,28 @@ var en = {
     "apiError.FileTooBig": "The uploaded file exceeds the maximum allowed asset size.",
     "assets.uploaded": "{number, plural, one {# asset} other {# assets}} uploaded successfully",
     "upload.generic-error": "An error occurred while uploading the file.",
+    "upload.progress": "Upload progress",
+    "upload.progress.failed": "Upload failed",
+    "upload.progress.failed.subtitle": "Please try to upload files again",
+    "upload.progress.success": "Upload successful!",
+    "upload.progress.success.subtitle": "{count, plural, one {# file uploaded successfully} other {# files uploaded successfully}}",
+    "upload.progress.uploading.withCount": "Uploading {total} items ({percentage}%)",
+    "upload.progress.uploading-files": "Uploading {count, plural, one {# file} other {# files}}",
+    "upload.progress.indicator.in-progress": "Upload in progress indicator",
+    "upload.progress.indicator.complete": "Upload complete indicator",
+    "upload.progress.label": "Upload",
+    "upload.progress.errors.title": "Failed to upload:",
+    "upload.progress.cancel": "Cancel",
+    "upload.progress.canceled": "Uploads canceled",
+    "upload.progress.canceled.subtitle": "Some files were not uploaded",
+    "upload.progress.canceled.subtitle.all": "All uploads were canceled",
+    "upload.progress.retry": "Retry",
+    "upload.progress.file.uploading": "Uploading...",
+    "upload.progress.file.canceled": "Canceled",
+    "upload.progress.file.uploaded": "Uploaded",
+    "upload.progress.maximize": "Maximize",
+    "upload.progress.minimize": "Minimize",
+    "upload.progress.close": "Close",
     "bulk.select.label": "Select all assets",
     "button.next": "Next",
     "new": "New",
@@ -22,6 +44,7 @@ var en = {
     "control-card.replace-media": "Replace Media",
     "control-card.save": "Save",
     "control-card.stop-crop": "Stop cropping",
+    "dropzone.upload.message": "Drop here to upload to",
     "filter.add": "Add filter",
     "form.button.replace-media": "Replace media",
     "form.input.description.file-alt": "This text will be displayed if the asset can’t be shown.",
@@ -143,6 +166,8 @@ var en = {
     "list.table.header.size": "size",
     "list.table.header.createdAt": "created",
     "list.table.header.updatedAt": "last update",
+    "list.table.header.creationDate": "Creation Date",
+    "list.table.header.lastModified": "Last Modified",
     "list.table.header.sort": "Sort on {label}",
     "list.table.content.empty-label": "This field is empty",
     "tabs.title": "How do you want to upload your assets?",

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/server/controllers/admin-upload.js

@@ -49,7 +49,10 @@ var adminUpload = {
         if (Array.isArray(files)) {
             throw new utils.errors.ApplicationError('Cannot replace a file with multiple ones');
         }
-        const { validFiles, filteredBody } = await mimeValidation.prepareUploadRequest(files, body, strapi);
+        const { validFiles, filteredBody, errors: validationErrors } = await mimeValidation.prepareUploadRequest(files, body, strapi);
+        if (validFiles.length === 0) {
+            throw new utils.errors.ValidationError(validationErrors[0].message);
+        }
         const data = await upload.validateUploadBody(filteredBody);
         const replacedFile = await uploadService.replace(id, {
             data,
@@ -74,7 +77,10 @@ var adminUpload = {
         if (!pm.isAllowed) {
             return ctx.forbidden();
         }
-        const { validFiles, filteredBody } = await mimeValidation.prepareUploadRequest(files, body, strapi);
+        const { validFiles, filteredBody, errors: validationErrors } = await mimeValidation.prepareUploadRequest(files, body, strapi);
+        if (validFiles.length === 0) {
+            throw new utils.errors.ValidationError(validationErrors[0].message);
+        }
         const isMultipleFiles = validFiles.length > 1;
         const data = await upload.validateUploadBody(filteredBody, isMultipleFiles);
         let filesArray = validFiles;
@@ -115,6 +121,149 @@ var adminUpload = {
         });
         ctx.status = 201;
     },
+    /**
+   * @experimental
+   * Stream upload files with SSE streaming for per-file progress
+   *
+   * Streams Server-Sent Events as each file is validated and uploaded:
+   * - file:uploading — when processing starts for a file
+   * - file:complete  — when a file is successfully uploaded
+   * - file:error     — when a file fails validation or upload
+   * - stream:complete — final summary with all results
+   *
+   */ async unstable_uploadFilesStream (ctx) {
+        const { state: { userAbility, user }, request: { body, files: { files } = {} } } = ctx;
+        const uploadService = index.getService('upload');
+        const pm = strapi.service('admin::permission').createPermissionsManager({
+            ability: userAbility,
+            action: constants.ACTIONS.create,
+            model: constants.FILE_MODEL_UID
+        });
+        if (!pm.isAllowed) {
+            return ctx.forbidden();
+        }
+        if (_.isEmpty(files) || !Array.isArray(files) && files.size === 0) {
+            throw new utils.errors.ApplicationError('Files are empty');
+        }
+        // Take manual control of the response for SSE streaming
+        ctx.respond = false;
+        const res = ctx.res;
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            Connection: 'keep-alive'
+        });
+        const writeSSE = (event, data)=>{
+            res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+        };
+        // Normalize files to an array
+        const filesArray = Array.isArray(files) ? files : [
+            files
+        ];
+        const total = filesArray.length;
+        // Parse fileInfo from body
+        // Multipart forms send fileInfo as either:
+        //   - An array of JSON strings (one per file)
+        //   - A single JSON string (one file, or a JSON-encoded array)
+        let parsedFileInfo = [];
+        if (body?.fileInfo) {
+            const raw = body.fileInfo;
+            if (Array.isArray(raw)) {
+                parsedFileInfo = raw.map((fi)=>typeof fi === 'string' ? JSON.parse(fi) : fi);
+            } else if (typeof raw === 'string') {
+                const parsed = JSON.parse(raw);
+                // Handle case where a single string contains a JSON array
+                parsedFileInfo = Array.isArray(parsed) ? parsed : [
+                    parsed
+                ];
+            } else {
+                parsedFileInfo = [
+                    raw
+                ];
+            }
+        }
+        const uploadErrors = [];
+        const successfulFiles = [];
+        // Process each file sequentially with inline validation
+        for(let i = 0; i < filesArray.length; i += 1){
+            const file = filesArray[i];
+            const fileName = file.originalFilename || 'unknown';
+            const fileInfo = parsedFileInfo[i] || {
+                name: fileName,
+                caption: null,
+                alternativeText: null,
+                folder: null
+            };
+            writeSSE('file:uploading', {
+                name: fileName,
+                index: i,
+                total,
+                size: file.size || 0
+            });
+            try {
+                // Validate this single file using security checks
+                const { validFiles, errors: validationErrors } = await mimeValidation.prepareUploadRequest(file, {
+                    fileInfo: JSON.stringify(fileInfo)
+                }, strapi);
+                if (validFiles.length === 0) {
+                    const errorMessage = validationErrors[0]?.message || 'Validation failed';
+                    uploadErrors.push({
+                        name: fileName,
+                        message: errorMessage
+                    });
+                    writeSSE('file:error', {
+                        name: fileName,
+                        index: i,
+                        message: errorMessage
+                    });
+                } else {
+                    // Validate using the already-parsed single fileInfo object directly
+                    const data = await upload.validateUploadBody({
+                        fileInfo
+                    }, false);
+                    const [uploadedFile] = await uploadService.upload({
+                        data,
+                        files: [
+                            validFiles[0]
+                        ]
+                    }, {
+                        user
+                    });
+                    // Sign file url
+                    const signedFile = await index.getService('file').signFileUrls(uploadedFile);
+                    successfulFiles.push(signedFile);
+                    writeSSE('file:complete', {
+                        name: fileName,
+                        index: i,
+                        file: signedFile
+                    });
+                }
+            } catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                uploadErrors.push({
+                    name: fileName,
+                    message: errorMessage
+                });
+                writeSSE('file:error', {
+                    name: fileName,
+                    index: i,
+                    message: errorMessage
+                });
+            }
+        }
+        // Track image upload metric once if any images were uploaded
+        if (successfulFiles.some((file)=>file.mime?.startsWith('image/'))) {
+            await index.getService('metrics').trackUsage('didUploadImage');
+        }
+        // Send final stream summary
+        writeSSE('stream:complete', {
+            data: await pm.sanitizeOutput(successfulFiles, {
+                action: constants.ACTIONS.read
+            }),
+            errors: uploadErrors
+        });
+        res.end();
+    },
     // TODO: split into multiple endpoints
     async upload (ctx) {
         const { query: { id }, request: { files: { files } = {} } } = ctx;