@strapi/upload 5.47.1 → 5.48.1

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

@@ -1,4 +1,4 @@
-import type { CreateFilesStream } from '../../../../shared/contracts/files';
+import type { CreateFilesStream, File as UploadedFile } from '../../../../shared/contracts/files';
 interface UploadFilesArgs {
     formData: FormData;
     totalFiles: number;
@@ -14,20 +14,21 @@ interface UploadFromUrlsArgs {
 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> & {
     /**
-     * Stream upload files to the /upload/unstable/stream endpoint.
-     * Reads SSE stream for per-file progress updates.
+     * Upload files sequentially, one request per file, to `/upload/unstable/upload-file`.
+     * Real per-file byte progress comes from `XHR.upload.onprogress`.
      */
-    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">;
+    uploadFiles: 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", UploadedFile[], "adminApi">;
     /**
      * Retry uploading cancelled files.
-     * Retrieves original File objects and re-uploads only the cancelled ones.
+     * Maps cancelled rows back to their original entries and re-runs only those
+     * through the same sequential loop with a fresh AbortController.
      */
-    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">;
+    retryCancelledFiles: 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", UploadedFile[], "adminApi">;
     /**
      * Upload files from URLs.
-     * Sends URLs to the server which fetches and uploads them.
+     * Sends URLs to the server which fetches and uploads them (SSE flow, unchanged).
      */
     uploadFromUrls: import("@reduxjs/toolkit/query").MutationDefinition<UploadFromUrlsArgs, 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 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">>, useUploadFromUrlsMutation: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseMutation<import("@reduxjs/toolkit/query").MutationDefinition<UploadFromUrlsArgs, 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 declare const useUploadFilesMutation: 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", UploadedFile[], "adminApi">>, useRetryCancelledFilesMutation: 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", UploadedFile[], "adminApi">>, useUploadFromUrlsMutation: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseMutation<import("@reduxjs/toolkit/query").MutationDefinition<UploadFromUrlsArgs, 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

@@ -13,5 +13,10 @@ interface UpdateAssetArgs {
     id: number;
     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, {}, {}>, "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, {}, {}>, "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, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", AssetWithPopulatedCreatedBy, "adminApi">>;
+interface ReplaceAssetArgs {
+    id: number;
+    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, {}, {}>, "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, {}, {}>, "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, {}, {}>, "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, {}, {}>, "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, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", unknown, "adminApi">>;
 export {};

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

@@ -0,0 +1,34 @@
+import type { File } from '../../../../shared/contracts/files';
+/**
+ * Thrown when an upload is aborted via its `AbortSignal`.
+ * Distinct from {@link UploadFileError} so callers can tell cancellation apart
+ * from a genuine failure.
+ */
+export declare class UploadAbortedError extends Error {
+    constructor(message?: string);
+}
+/**
+ * Thrown when an upload fails (non-2xx response, network error, or unparseable body).
+ */
+export declare class UploadFileError extends Error {
+    status?: number;
+    constructor(message: string, status?: number);
+}
+export type UploadProgressCallback = (bytes: number, total: number) => void;
+/**
+ * Uploads a single file via `XMLHttpRequest`, exposing real byte-level upload
+ * progress through {@link XMLHttpRequest.upload}'s `progress` event.
+ *
+ * This is the only place raw XHR lives. `fetch()` is intentionally avoided here
+ * because it does not surface upload progress.
+ *
+ * @param url - The full endpoint URL to POST to.
+ * @param token - Admin auth token; the `Authorization` header is only set when present.
+ * @param formData - Prebuilt multipart body containing the single file and its `fileInfo`.
+ * @param signal - Aborts the in-flight request when triggered.
+ * @param onProgress - Called with `(loaded, total)` bytes as the upload progresses.
+ * @returns The parsed, signed `File` on a 2xx response.
+ * @throws {UploadAbortedError} When the signal aborts.
+ * @throws {UploadFileError} On a non-2xx response or network error.
+ */
+export declare const uploadFileViaXHR: (url: string, token: string | null | undefined, formData: FormData, signal: AbortSignal, onProgress?: UploadProgressCallback) => Promise<File>;

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

@@ -9,13 +9,13 @@ export interface FileProgress {
     index: number;
     status: FileProgressStatus;
     size: number;
+    uploadedBytes: number;
     file?: File;
     error?: string;
 }
 export interface UploadProgressState {
     isVisible: boolean;
     isMinimized: boolean;
-    progress: number;
     totalFiles: number;
     files: FileProgress[];
     errors: FileUploadError[];
@@ -24,6 +24,17 @@ export interface UploadProgressState {
 export interface RootState {
     uploadProgress: UploadProgressState;
 }
+/**
+ * Byte-weighted aggregate progress across the whole batch: `sum(uploadedBytes) / sum(size)`.
+ *
+ * Falls back to count-based progress (settled files / total files) when all sizes are
+ * zero — e.g. URL-flow rows where the file size is unknown up front.
+ */
+export declare const selectAggregateProgress: ((state: RootState) => number) & import("reselect").OutputSelectorFields<(args_0: FileProgress[]) => number, {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
 export declare const openUploadProgress: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
     totalFiles: number;
     fileNames: string[];
@@ -31,16 +42,18 @@ export declare const openUploadProgress: import("@reduxjs/toolkit").ActionCreato
 }, "uploadProgress/openUploadProgress">, setFileUploading: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
     name: string;
     index: number;
-    total: number;
     size: number;
-}, "uploadProgress/setFileUploading">, setFileComplete: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+}, "uploadProgress/setFileUploading">, setFileProgress: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    index: number;
+    bytes: number;
+}, "uploadProgress/setFileProgress">, 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<{
+}, "uploadProgress/setFileError">, 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/createRafBatcher.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Coalesces high-frequency values into at most one flush per animation frame.
+ *
+ * `XHR.upload.onprogress` can fire many times per second on a fast connection.
+ * Dispatching each one to Redux would flood the store, so the orchestrator routes
+ * progress through a batcher: many `schedule(value)` calls within a single frame
+ * collapse into one `flush(latestValue)` callback.
+ *
+ * @param flush - Invoked once per frame with the most recent scheduled value.
+ */
+export declare const createRafBatcher: <T>(flush: (value: T) => void) => {
+    /**
+     * Records the latest value and ensures a flush is scheduled for the next frame.
+     * Repeated calls within the same frame overwrite the value without scheduling
+     * additional frames.
+     */
+    schedule(value: T): void;
+    /**
+     * Cancels any pending flush so a value scheduled this frame will not fire.
+     */
+    cancel(): void;
+};
+export type RafBatcher<T> = ReturnType<typeof createRafBatcher<T>>;

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

@@ -0,0 +1,6 @@
+/**
+ * Fetch a file at `url` and trigger a browser download with the given filename.
+ * Goes via a blob + temporary anchor so we honour the `download` attribute
+ * even when the file is served same-origin without `Content-Disposition`.
+ */
+export declare const downloadFile: (url: string, fileName: string) => Promise<void>;

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

@@ -23,6 +23,27 @@ var en = {
     "asset-details.update.success": "File updated",
     "asset-details.update.error": "Failed to update the file.",
     "asset-details.field.empty": "{label} is currently empty.",
+    "asset-details.location.root": "Media Library",
+    "asset-details.saveChanges": "Save changes",
+    "asset-details.delete.trigger": "Delete this file",
+    "asset-details.delete.title": "Delete this media file?",
+    "asset-details.delete.description": "This file cannot be recovered once deleted. If it is currently in use, linked content will break and image containers will be empty.",
+    "asset-details.delete.success": "1 element have been deleted from {folderName}",
+    "asset-details.delete.error": "Failed to delete the file.",
+    "asset-details.delete.loading": "Deleting the file…",
+    "asset-details.replace.trigger": "Replace this file",
+    "asset-details.replace.title": "Replace this media file?",
+    "asset-details.replace.description": "Current content will be permanently replaced.",
+    "asset-details.replace.description.ai": "AI will generate new metadata after upload.",
+    "asset-details.replace.continue": "Continue",
+    "asset-details.replace.success": "File replaced.",
+    "asset-details.replace.error": "Failed to replace the file.",
+    "asset-details.replace.loading": "Replacing the file…",
+    "asset-details.copy-link.trigger": "Copy link",
+    "asset-details.copy-link.success": "Link copied.",
+    "asset-details.copy-link.error": "Failed to copy the link.",
+    "asset-details.download.trigger": "Download",
+    "asset-details.download.error": "Failed to download the file.",
     "asset-details.noPreview": "No preview available",
     "upload.generic-error": "An error occurred while uploading the file.",
     "upload.progress": "Upload progress",

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

@@ -21,6 +21,27 @@ var en = {
     "asset-details.update.success": "File updated",
     "asset-details.update.error": "Failed to update the file.",
     "asset-details.field.empty": "{label} is currently empty.",
+    "asset-details.location.root": "Media Library",
+    "asset-details.saveChanges": "Save changes",
+    "asset-details.delete.trigger": "Delete this file",
+    "asset-details.delete.title": "Delete this media file?",
+    "asset-details.delete.description": "This file cannot be recovered once deleted. If it is currently in use, linked content will break and image containers will be empty.",
+    "asset-details.delete.success": "1 element have been deleted from {folderName}",
+    "asset-details.delete.error": "Failed to delete the file.",
+    "asset-details.delete.loading": "Deleting the file…",
+    "asset-details.replace.trigger": "Replace this file",
+    "asset-details.replace.title": "Replace this media file?",
+    "asset-details.replace.description": "Current content will be permanently replaced.",
+    "asset-details.replace.description.ai": "AI will generate new metadata after upload.",
+    "asset-details.replace.continue": "Continue",
+    "asset-details.replace.success": "File replaced.",
+    "asset-details.replace.error": "Failed to replace the file.",
+    "asset-details.replace.loading": "Replacing the file…",
+    "asset-details.copy-link.trigger": "Copy link",
+    "asset-details.copy-link.success": "Link copied.",
+    "asset-details.copy-link.error": "Failed to copy the link.",
+    "asset-details.download.trigger": "Download",
+    "asset-details.download.error": "Failed to download the file.",
     "asset-details.noPreview": "No preview available",
     "upload.generic-error": "An error occurred while uploading the file.",
     "upload.progress": "Upload progress",

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

@@ -21,7 +21,9 @@ var adminUpload = {
             const updated = await uploadService.updateFileInfo(id, fileInfo, {
                 user
             });
-            return pm.sanitizeOutput(updated, {
+            // Sign file urls for private providers
+            const signedFile = await index.getService('file').signFileUrls(updated);
+            return pm.sanitizeOutput(signedFile, {
                 action: constants.ACTIONS.read
             });
         });
@@ -38,7 +40,9 @@ var adminUpload = {
         const file = await uploadService.updateFileInfo(id, data.fileInfo, {
             user
         });
-        ctx.body = await pm.sanitizeOutput(file, {
+        // Sign file urls for private providers
+        const signedFile = await index.getService('file').signFileUrls(file);
+        ctx.body = await pm.sanitizeOutput(signedFile, {
             action: constants.ACTIONS.read
         });
     },
@@ -63,6 +67,25 @@ var adminUpload = {
         }, {
             user
         });
+        // Regenerate AI metadata for image replacements so the alt text / caption
+        // reflect the new file content. Mirrors the post-upload hook in
+        // `uploadFiles`; failure is logged and swallowed to keep the replace flow
+        // resilient when the AI provider is unavailable.
+        const aiMetadataService = index.getService('aiMetadata');
+        if (replacedFile?.mime?.startsWith('image/') && await aiMetadataService.isEnabled()) {
+            try {
+                const metadataResults = await aiMetadataService.processFiles([
+                    replacedFile
+                ]);
+                await aiMetadataService.updateFilesWithAIMetadata([
+                    replacedFile
+                ], metadataResults, user);
+            } catch (error) {
+                strapi.log.warn('AI metadata generation failed on replace, proceeding without it', {
+                    error: error instanceof Error ? error.message : String(error)
+                });
+            }
+        }
         // Sign file urls for private providers
         const signedFile = await index.getService('file').signFileUrls(replacedFile);
         ctx.body = await pm.sanitizeOutput(signedFile, {
@@ -126,15 +149,13 @@ var adminUpload = {
     },
     /**
    * @experimental
-   * Stream upload files with SSE streaming for per-file progress
+   * Upload a single file and return the created File.
    *
-   * 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) {
+   * Accepts one file per request (multipart `files` + `fileInfo`) and returns a
+   * single `File` object. Unlike `uploadFiles`, it does **not** run AI metadata
+   * generation inline — that responsibility is decoupled and will be handled by a
+   * background job. Auth and permission checks mirror `POST /upload`.
+   */ async unstable_uploadFile (ctx) {
         const { state: { userAbility, user }, request: { body, files: { files } = {} } } = ctx;
         const uploadService = index.getService('upload');
         const pm = strapi.service('admin::permission').createPermissionsManager({
@@ -148,124 +169,54 @@ var adminUpload = {
         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`);
+        // Accept a single file per request; ignore any extras defensively.
+        const file = Array.isArray(files) ? files[0] : files;
+        const fileName = file.originalFilename || 'unknown';
+        // Parse the single fileInfo object from the multipart body.
+        let fileInfo = {
+            name: fileName,
+            caption: null,
+            alternativeText: null,
+            folder: null
         };
-        // 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
-                ];
+            if (typeof raw === 'string') {
+                fileInfo = JSON.parse(raw);
+            } else if (Array.isArray(raw)) {
+                fileInfo = typeof raw[0] === 'string' ? JSON.parse(raw[0]) : raw[0];
             } else {
-                parsedFileInfo = [
-                    raw
-                ];
+                fileInfo = 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
-                });
-            }
+        // Validate this single file using security checks.
+        const { validFiles, errors: validationErrors } = await mimeValidation.prepareUploadRequest(file, {
+            fileInfo: JSON.stringify(fileInfo)
+        }, strapi);
+        if (validFiles.length === 0) {
+            throw new utils.errors.ValidationError(validationErrors[0]?.message || 'Validation failed');
         }
-        // Track image upload metric once if any images were uploaded
-        if (successfulFiles.some((file)=>file.mime?.startsWith('image/'))) {
+        const data = await upload.validateUploadBody({
+            fileInfo
+        }, false);
+        const [uploadedFile] = await uploadService.upload({
+            data,
+            files: [
+                validFiles[0]
+            ]
+        }, {
+            user
+        });
+        if (uploadedFile.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
+        // No inline AI metadata generation — intentionally decoupled for the async job.
+        // Sign file url for private providers.
+        const signedFile = await index.getService('file').signFileUrls(uploadedFile);
+        ctx.body = await pm.sanitizeOutput(signedFile, {
+            action: constants.ACTIONS.read
         });
-        res.end();
+        ctx.status = 201;
     },
     /**
    * @experimental