@strapi/upload 5.53.0 → 5.55.0

package/dist/admin/services/api.mjs

@@ -0,0 +1,766 @@
+import { adminApi } from '@strapi/admin/strapi-admin';
+import { openUploadProgress, setUploadFailed, retryCancelledFiles, isUploadInFlight, appendUploadFiles, setFileError, setFileComplete, setFileUploading, setFileProgress, setFileMetadataGenerating, setFileMetadataResult } from '../store/uploadProgress.mjs';
+import { createRafBatcher } from '../utils/createRafBatcher.mjs';
+import { getFilenameFromUrl } from '../utils/files.mjs';
+import { uploadFileViaXHR, UploadFileError, UploadAbortedError } from './uploadFileViaXHR.mjs';
+
+/**
+ * Stores the original upload batch (keyed by uploadId) to enable retry.
+ */ const uploadRegistry = new Map();
+const registerUploadEntries = (uploadId, entries, generateAiMetadata, concurrency)=>{
+    uploadRegistry.set(uploadId, {
+        entries,
+        generateAiMetadata,
+        concurrency
+    });
+};
+const getUploadEntries = (uploadId)=>{
+    return uploadRegistry.get(uploadId);
+};
+/**
+ * Manages abort controllers for in-flight uploads.
+ *
+ * Design decision: Uses a Map to track uploads by their unique uploadId.
+ * Redux state cannot store function references (abort controllers), RTK Query's
+ * signal is only accessible within the queryFn, and the upload is triggered in
+ * AssetsPage but cancelled from UploadProgressDialog.
+ */ const abortControllers = new Map();
+const registerAbortController = (uploadId, controller)=>{
+    abortControllers.set(uploadId, controller);
+};
+const unregisterAbortController = (uploadId)=>{
+    abortControllers.delete(uploadId);
+};
+/**
+ * Aborts an upload by its uploadId.
+ * Called from the UploadProgressDialog when the user clicks cancel or close.
+ */ const abortUpload = (uploadId)=>{
+    const controller = abortControllers.get(uploadId);
+    if (controller) {
+        controller.abort();
+        unregisterAbortController(uploadId);
+    }
+};
+/**
+ * Runs are chained per batch rather than started in parallel: a second pool
+ * alongside the first would double the files in flight and make `concurrency`
+ * stop meaning anything.
+ */ const poolTails = new Map();
+const trackPoolRun = (uploadId, run)=>{
+    // Not swallowed: the caller still gets the real result from `run`.
+    const tail = run.catch(()=>undefined);
+    poolTails.set(uploadId, tail);
+    tail.then(()=>{
+        // Leave the entry alone if another run has queued behind us in the meantime.
+        if (poolTails.get(uploadId) === tail) {
+            poolTails.delete(uploadId);
+        }
+    });
+};
+/** Maps a server per-file outcome onto the row's terminal metadata status. */ const METADATA_STATUS_BY_RESULT = {
+    success: 'generated',
+    skipped: 'skipped',
+    error: 'failed'
+};
+/**
+ * Re-attaches the folder an upload targeted.
+ *
+ * The create response is built from `db.query().create()` with no populate, so
+ * it comes back without the folder relation it was just given. The list needs
+ * it to tell whether a freshly uploaded asset belongs to the folder on screen.
+ */ const withTargetFolder = (file, folder)=>file.folder != null ? file : {
+        ...file,
+        folder: folder ?? null
+    };
+/**
+ * Kicks off AI metadata generation for a freshly uploaded file.
+ *
+ * Deliberately fire-and-forget — the caller must NOT await it:
+ *  - generation for file N overlaps the upload of file N+1;
+ *  - a generation failure can never affect the upload result (the upload already
+ *    succeeded), which is why the promise is fully swallowed here.
+ *
+ * Every uploaded file is sent, including non-images: the server already classifies
+ * them (`ai-metadata.generateForFiles` returns `skipped` for anything whose mime
+ * isn't `image/*`) and duplicating that rule here would let the two drift apart.
+ * The upshot is that a non-image now reports "Metadata generation skipped" rather
+ * than silently showing no metadata state at all.
+ */ const maybeGenerateMetadata = ({ file, index, uploadId, enabled, dispatch })=>{
+    if (!enabled || typeof file.id !== 'number') {
+        return;
+    }
+    dispatch(setFileMetadataGenerating({
+        index,
+        uploadId
+    }));
+    // `uploadApi` is declared below but only read at call time, long after the module
+    // has finished evaluating.
+    const promise = dispatch(uploadApi.endpoints.generateAiMetadata.initiate({
+        fileIds: [
+            file.id
+        ]
+    }));
+    promise.unwrap().then((results)=>{
+        const result = results?.find((r)=>r.id === file.id) ?? results?.[0];
+        dispatch(setFileMetadataResult({
+            index,
+            uploadId,
+            status: result ? METADATA_STATUS_BY_RESULT[result.status] : 'failed'
+        }));
+    }).catch(()=>{
+        dispatch(setFileMetadataResult({
+            index,
+            uploadId,
+            status: 'failed'
+        }));
+    });
+};
+/**
+ * Uploads the given entry indices one at a time through the single-file endpoint.
+ *
+ * For each file: dispatches "uploading", wires `XHR.upload.onprogress` through a
+ * per-frame batcher to `setFileProgress`, awaits the XHR, then dispatches
+ * "complete" or "error". Each file is wrapped in its own try/catch so one failure
+ * does not stop the batch. An abort stops the loop without starting further files.
+ */ const runUploadPool = async ({ entries, indices, token, uploadId, abortController, dispatch, concurrency = 1, generateAiMetadata })=>{
+    const url = `${window.strapi.backendURL}/upload/files`;
+    const uploaded = [];
+    // Shared queue: each worker shifts the next index when it frees up, so N
+    // files are in flight at any moment (not N-sized waves). With concurrency 1
+    // this degenerates to the original strictly sequential loop.
+    const queue = [
+        ...indices
+    ];
+    const uploadOne = async (index)=>{
+        const entry = entries[index];
+        if (!entry) {
+            return;
+        }
+        const fileName = entry.fileInfo?.name ?? entry.file.name;
+        dispatch(setFileUploading({
+            name: fileName,
+            index,
+            size: entry.file.size,
+            uploadId
+        }));
+        const formData = new FormData();
+        formData.append('files', entry.file);
+        formData.append('fileInfo', JSON.stringify(entry.fileInfo));
+        // Coalesce high-frequency progress events into one dispatch per frame.
+        const batcher = createRafBatcher((bytes)=>{
+            dispatch(setFileProgress({
+                index,
+                bytes,
+                uploadId
+            }));
+        });
+        try {
+            const file = await uploadFileViaXHR(url, token, formData, abortController.signal, (bytes)=>batcher.schedule(bytes));
+            batcher.cancel();
+            uploaded.push(file);
+            dispatch(setFileComplete({
+                index,
+                file: withTargetFolder(file, entry.fileInfo?.folder),
+                uploadId,
+                completedAt: Date.now()
+            }));
+            // Not awaited: overlaps with the next file's upload and can't fail the batch.
+            maybeGenerateMetadata({
+                file,
+                index,
+                uploadId,
+                enabled: generateAiMetadata,
+                dispatch
+            });
+        } catch (err) {
+            batcher.cancel();
+            if (err instanceof UploadAbortedError) {
+                // Batch was cancelled — the worker loop checks the signal and stops.
+                // cancelUpload (dispatched from the dialog) marks the remaining rows.
+                return;
+            }
+            const message = err instanceof Error ? err.message : 'Upload failed';
+            dispatch(setFileError({
+                index,
+                name: fileName,
+                message,
+                uploadId
+            }));
+        }
+    };
+    // Guard non-finite/invalid values (NaN, Infinity, <1): `Math.floor(NaN)`
+    // would propagate through Math.max to `Array.from({ length: NaN })` = zero
+    // workers, silently uploading nothing. Anything invalid falls back to 1.
+    const requested = Number.isFinite(concurrency) ? Math.floor(concurrency) : 1;
+    const workerCount = Math.min(Math.max(1, requested), queue.length);
+    const worker = async ()=>{
+        while(queue.length > 0){
+            if (abortController.signal.aborted) {
+                break;
+            }
+            const index = queue.shift();
+            if (index === undefined) {
+                break;
+            }
+            // eslint-disable-next-line no-await-in-loop
+            await uploadOne(index);
+        }
+    };
+    await Promise.all(Array.from({
+        length: workerCount
+    }, ()=>worker()));
+    unregisterAbortController(uploadId);
+    return {
+        data: uploaded
+    };
+};
+/**
+ * Reuses the batch's AbortController so one Cancel stops both drops.
+ * `runUploadPool` unregisters it on finish, hence the re-register below.
+ *
+ * Resolves with the whole batch's files, not just this leg's: the mutation
+ * models one drop, and after a merge the drop is the batch. The earlier leg's
+ * files come from the tail this run queued behind.
+ */ const runMergedUploadPool = async ({ entries, indices, token, uploadId, dispatch, concurrency, generateAiMetadata })=>{
+    const abortController = abortControllers.get(uploadId) ?? new AbortController();
+    const run = (poolTails.get(uploadId) ?? Promise.resolve(undefined)).then((previous)=>{
+        // A failed earlier leg contributes no files; its error already reached the
+        // store, and this leg still has files of its own to upload.
+        const earlier = previous?.data ?? [];
+        if (abortController.signal.aborted) {
+            return {
+                data: earlier
+            };
+        }
+        registerAbortController(uploadId, abortController);
+        return runUploadPool({
+            entries,
+            indices,
+            token,
+            uploadId,
+            abortController,
+            dispatch,
+            concurrency,
+            generateAiMetadata
+        }).then((result)=>result.error ? result : {
+                data: [
+                    ...earlier,
+                    ...result.data ?? []
+                ]
+            });
+    });
+    trackPoolRun(uploadId, run);
+    return run;
+};
+/* -------------------------------------------------------------------------------------------------
+ * URL upload flow (SSE) — kept as-is for this iteration
+ * -----------------------------------------------------------------------------------------------*/ /**
+ * Parses a raw SSE text chunk into event/data pairs.
+ *
+ * SSE format:
+ *   event: <eventName>\n
+ *   data: <json>\n
+ *   \n
+ */ const parseSSEEvents = (chunk)=>{
+    const events = [];
+    const blocks = chunk.split('\n\n').filter(Boolean);
+    for (const block of blocks){
+        let event = '';
+        let data = '';
+        for (const line of block.split('\n')){
+            if (line.startsWith('event: ')) {
+                event = line.slice(7);
+            } else if (line.startsWith('data: ')) {
+                data = line.slice(6);
+            }
+        }
+        if (event && data) {
+            events.push({
+                event,
+                data
+            });
+        }
+    }
+    return events;
+};
+/**
+ * Makes a streaming upload-from-URLs request to the server.
+ * Sends URLs as JSON body instead of FormData.
+ */ const fetchUrlUploadStream = async ({ token, urls, folderId, signal })=>{
+    const backendURL = window.strapi.backendURL;
+    const headers = {
+        'Content-Type': 'application/json'
+    };
+    if (token) {
+        headers.Authorization = `Bearer ${token}`;
+    }
+    return fetch(`${backendURL}/upload/actions/upload-from-urls`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({
+            urls,
+            folderId
+        }),
+        signal
+    });
+};
+/**
+ * Processes an SSE stream from the URL upload endpoint.
+ * Dispatches Redux actions for each file event and returns the final result.
+ */ const processSSEStream = async ({ response, dispatch, uploadId, generateAiMetadata, folderId })=>{
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let streamResult = null;
+    let buffer = '';
+    while(true){
+        const { done, value } = await reader.read();
+        if (done) {
+            break;
+        }
+        buffer += decoder.decode(value, {
+            stream: true
+        });
+        // Process complete SSE events from the buffer
+        const lastDoubleNewline = buffer.lastIndexOf('\n\n');
+        if (lastDoubleNewline === -1) {
+            continue;
+        }
+        const completePart = buffer.slice(0, lastDoubleNewline + 2);
+        buffer = buffer.slice(lastDoubleNewline + 2);
+        const events = parseSSEEvents(completePart);
+        for (const { event, data } of events){
+            const parsed = JSON.parse(data);
+            const index = parsed.index;
+            switch(event){
+                case 'file:fetching':
+                    {
+                        // URL is being fetched server-side - mark as uploading (processing)
+                        dispatch(setFileUploading({
+                            name: parsed.url,
+                            index,
+                            size: 0,
+                            uploadId
+                        }));
+                        break;
+                    }
+                case 'file:progress':
+                    {
+                        const payload = parsed;
+                        // No usable Content-Length on the remote: leave the row indeterminate
+                        if (payload.totalBytes === null) {
+                            break;
+                        }
+                        // Already throttled server-side (~5 frames a second per file), so no batching
+                        // here. `size` rides along because the row is still at 0 — see `setFileProgress`.
+                        dispatch(setFileProgress({
+                            index,
+                            bytes: payload.loadedBytes,
+                            size: payload.totalBytes,
+                            uploadId
+                        }));
+                        break;
+                    }
+                case 'file:uploading':
+                    {
+                        const payload = parsed;
+                        dispatch(setFileUploading({
+                            name: payload.name,
+                            index,
+                            size: payload.size,
+                            uploadId
+                        }));
+                        break;
+                    }
+                case 'file:complete':
+                    {
+                        const payload = parsed;
+                        dispatch(setFileComplete({
+                            index,
+                            file: withTargetFolder(payload.file, folderId),
+                            uploadId,
+                            completedAt: Date.now()
+                        }));
+                        // Same fire-and-forget semantics as the file flow.
+                        maybeGenerateMetadata({
+                            file: payload.file,
+                            index,
+                            uploadId,
+                            enabled: generateAiMetadata,
+                            dispatch
+                        });
+                        break;
+                    }
+                case 'file:error':
+                    {
+                        const payload = parsed;
+                        dispatch(setFileError({
+                            index,
+                            name: payload.name,
+                            message: payload.message,
+                            uploadId
+                        }));
+                        break;
+                    }
+                case 'stream:complete':
+                    {
+                        const payload = parsed;
+                        streamResult = {
+                            data: payload.data,
+                            errors: payload.errors
+                        };
+                        break;
+                    }
+                default:
+                    console.error(`[SSE Upload] unknown event: ${event}`, parsed);
+            }
+        }
+    }
+    return streamResult;
+};
+const uploadApi = adminApi.enhanceEndpoints({
+    addTagTypes: [
+        'Asset',
+        'Folder'
+    ]
+}).injectEndpoints({
+    endpoints: (builder)=>({
+            /**
+       * Upload files to `/upload/files`, one request per file, through a worker
+       * pool of `concurrency` parallel requests (default 1 = sequential). Real
+       * per-file byte progress comes from `XHR.upload.onprogress`.
+       */ uploadFiles: builder.mutation({
+                queryFn: async ({ formData, totalFiles, concurrency = 1, generateAiMetadata }, { dispatch, getState })=>{
+                    const token = getState().admin_app?.token;
+                    // Extract the original files and their per-file fileInfo from the combined FormData.
+                    const files = formData.getAll('files');
+                    const fileInfoJson = formData.get('fileInfo');
+                    const fileInfoArray = JSON.parse(fileInfoJson);
+                    const entries = files.map((file, index)=>({
+                            file,
+                            fileInfo: fileInfoArray[index] ?? {
+                                name: file.name,
+                                caption: null,
+                                alternativeText: null,
+                                folder: null
+                            }
+                        }));
+                    const fileNames = entries.map((entry)=>entry.fileInfo.name ?? entry.file.name);
+                    const fileSizes = entries.map((entry)=>entry.file.size);
+                    // `uploadFromUrls` also leaves rows `pending`, but registers no batch —
+                    // so an unregistered batch is not ours to merge into, and appending would
+                    // land on top of its rows.
+                    const progress = getState().uploadProgress;
+                    const batch = getUploadEntries(progress.uploadId);
+                    const isMerge = batch !== undefined && isUploadInFlight(progress.files);
+                    if (isMerge) {
+                        const { uploadId } = progress;
+                        const offset = batch.entries.length;
+                        // No `totalFiles`: the reducer derives it from the rows it appends.
+                        dispatch(appendUploadFiles({
+                            uploadId,
+                            fileNames,
+                            fileSizes
+                        }));
+                        const mergedEntries = [
+                            ...batch.entries,
+                            ...entries
+                        ];
+                        // Merged files adopt the batch's flags: a new concurrency would raise
+                        // the ceiling it exists to impose.
+                        registerUploadEntries(uploadId, mergedEntries, batch.generateAiMetadata, batch.concurrency);
+                        return runMergedUploadPool({
+                            entries: mergedEntries,
+                            indices: entries.map((_, index)=>offset + index),
+                            token,
+                            uploadId,
+                            dispatch,
+                            concurrency: batch.concurrency,
+                            generateAiMetadata: batch.generateAiMetadata
+                        });
+                    }
+                    // Open the progress dialog
+                    dispatch(openUploadProgress({
+                        totalFiles,
+                        fileNames,
+                        fileSizes
+                    }));
+                    // Get the uploadId from state after dispatching
+                    const uploadId = getState().uploadProgress.uploadId;
+                    // Store original entries for retry functionality
+                    registerUploadEntries(uploadId, entries, generateAiMetadata, concurrency);
+                    // One AbortController per batch
+                    const abortController = new AbortController();
+                    registerAbortController(uploadId, abortController);
+                    const run = runUploadPool({
+                        entries,
+                        indices: entries.map((_, index)=>index),
+                        token,
+                        uploadId,
+                        abortController,
+                        dispatch,
+                        concurrency,
+                        generateAiMetadata
+                    });
+                    trackPoolRun(uploadId, run);
+                    return run;
+                },
+                // `Folder, LIST` refreshes the folder header count, which changes when
+                // files are added to it.
+                invalidatesTags: [
+                    {
+                        type: 'Asset',
+                        id: 'LIST'
+                    },
+                    {
+                        type: 'Folder',
+                        id: 'LIST'
+                    }
+                ]
+            }),
+            /**
+       * Upload a single, already-prepared file WITHOUT opening the global
+       * upload-progress dialog. For flows that create one asset programmatically
+       * (e.g. crop → "Save as copy"), where the bulk-upload progress UI is
+       * inappropriate. Same endpoint as `uploadFiles`, minus the progress/retry
+       * machinery.
+       */ uploadFileSilently: builder.mutation({
+                queryFn: async ({ file, fileInfo }, { getState })=>{
+                    const token = getState().admin_app?.token;
+                    const url = `${window.strapi.backendURL}/upload/files`;
+                    const formData = new FormData();
+                    formData.append('files', file);
+                    formData.append('fileInfo', JSON.stringify(fileInfo));
+                    try {
+                        const uploaded = await uploadFileViaXHR(url, token, formData, new AbortController().signal, ()=>{});
+                        return {
+                            data: uploaded
+                        };
+                    } catch (err) {
+                        // Only pass on text the server actually sent. The XHR layer's own
+                        // fallbacks are hardcoded English, and callers here (crop → "Save
+                        // as copy") have a localized message of their own; an empty string
+                        // reads as "nothing usable" and lets theirs win.
+                        const message = err instanceof UploadFileError && err.isServerMessage ? err.message : '';
+                        return {
+                            error: {
+                                name: 'UnknownError',
+                                message
+                            }
+                        };
+                    }
+                },
+                // `Folder, LIST` refreshes the folder header count, which changes when
+                // files are added to it.
+                invalidatesTags: [
+                    {
+                        type: 'Asset',
+                        id: 'LIST'
+                    },
+                    {
+                        type: 'Folder',
+                        id: 'LIST'
+                    }
+                ]
+            }),
+            /**
+       * Retry uploading cancelled files.
+       * Maps cancelled rows back to their original entries and re-runs only those
+       * through the same upload pool with a fresh AbortController.
+       */ retryCancelledFiles: builder.mutation({
+                queryFn: async (_arg, { dispatch, getState })=>{
+                    const { uploadId, files: stateFiles } = getState().uploadProgress;
+                    const token = getState().admin_app?.token;
+                    const cancelledIndices = stateFiles.filter((f)=>f.status === 'cancelled').map((f)=>f.index);
+                    if (cancelledIndices.length === 0) {
+                        return {
+                            error: {
+                                name: 'UnknownError',
+                                message: 'No cancelled files to retry'
+                            }
+                        };
+                    }
+                    const batch = getUploadEntries(uploadId);
+                    if (!batch) {
+                        return {
+                            error: {
+                                name: 'UnknownError',
+                                message: 'Original files not found'
+                            }
+                        };
+                    }
+                    // Reset cancelled files back to pending
+                    dispatch(retryCancelledFiles());
+                    // Fresh AbortController for the retry run
+                    const abortController = new AbortController();
+                    registerAbortController(uploadId, abortController);
+                    const run = runUploadPool({
+                        entries: batch.entries,
+                        indices: cancelledIndices,
+                        token,
+                        uploadId,
+                        abortController,
+                        dispatch,
+                        // Replay the retried rows with the flags the batch was started with.
+                        concurrency: batch.concurrency,
+                        generateAiMetadata: batch.generateAiMetadata
+                    });
+                    // Retried rows are `pending` again, so a drop lands on the merge branch.
+                    // Untracked, that merge would find no tail to queue behind and run its
+                    // pool beside this one — two pools of `concurrency` each.
+                    trackPoolRun(uploadId, run);
+                    return run;
+                },
+                // `Folder, LIST` refreshes the folder header count, which changes when
+                // files are added to it.
+                invalidatesTags: [
+                    {
+                        type: 'Asset',
+                        id: 'LIST'
+                    },
+                    {
+                        type: 'Folder',
+                        id: 'LIST'
+                    }
+                ]
+            }),
+            /**
+       * Upload files from URLs.
+       * Sends URLs to the server which fetches and uploads them (SSE flow, unchanged).
+       */ uploadFromUrls: builder.mutation({
+                queryFn: async ({ urls, folderId, generateAiMetadata }, { dispatch, getState })=>{
+                    const token = getState().admin_app?.token;
+                    // Extract filenames from URLs for the progress dialog
+                    const fileNames = urls.map((url)=>getFilenameFromUrl(url));
+                    // Open progress dialog with all URLs as pending files
+                    dispatch(openUploadProgress({
+                        totalFiles: urls.length,
+                        fileNames
+                    }));
+                    // Get the uploadId from state after dispatching
+                    const uploadId = getState().uploadProgress.uploadId;
+                    // Create abort controller for this upload
+                    const abortController = new AbortController();
+                    registerAbortController(uploadId, abortController);
+                    try {
+                        // Send URLs to server for fetching and uploading
+                        const response = await fetchUrlUploadStream({
+                            token,
+                            urls,
+                            folderId,
+                            signal: abortController.signal
+                        });
+                        if (!response.ok || !response.body) {
+                            unregisterAbortController(uploadId);
+                            let errorMessage = 'Upload request failed';
+                            try {
+                                const errorData = await response.json();
+                                if (errorData.error?.message) {
+                                    errorMessage = errorData.error.message;
+                                } else if (errorData.message) {
+                                    errorMessage = errorData.message;
+                                }
+                            } catch  {
+                                errorMessage = `Upload failed with status ${response.status}`;
+                            }
+                            dispatch(setUploadFailed({
+                                message: errorMessage
+                            }));
+                            return {
+                                error: {
+                                    name: 'UnknownError',
+                                    message: errorMessage,
+                                    status: response.status
+                                }
+                            };
+                        }
+                        // Process SSE stream from server
+                        const streamResult = await processSSEStream({
+                            response,
+                            dispatch,
+                            uploadId,
+                            generateAiMetadata,
+                            folderId
+                        });
+                        unregisterAbortController(uploadId);
+                        if (streamResult && streamResult.data.length > 0) {
+                            return {
+                                data: streamResult
+                            };
+                        }
+                        return {
+                            data: {
+                                data: [],
+                                errors: []
+                            }
+                        };
+                    } catch (err) {
+                        unregisterAbortController(uploadId);
+                        if (err instanceof DOMException && err.name === 'AbortError') {
+                            return {
+                                error: {
+                                    name: 'UnknownError',
+                                    message: 'Upload cancelled'
+                                }
+                            };
+                        }
+                        const errorMessage = err instanceof Error ? err.message : 'Network error occurred';
+                        dispatch(setUploadFailed({
+                            message: errorMessage
+                        }));
+                        return {
+                            error: {
+                                name: 'UnknownError',
+                                message: errorMessage
+                            }
+                        };
+                    }
+                },
+                // `Folder, LIST` refreshes the folder header count, which changes when
+                // files are added to it.
+                invalidatesTags: [
+                    {
+                        type: 'Asset',
+                        id: 'LIST'
+                    },
+                    {
+                        type: 'Folder',
+                        id: 'LIST'
+                    }
+                ]
+            }),
+            /**
+       * Generate AI metadata (alt text + caption) for the given assets.
+       * Synchronous: resolves once every file has been processed and reports the
+       * outcome per file, so non-images and individual failures don't fail the
+       * whole batch. Existing alt text and captions are never overwritten.
+       *
+       * Lives here rather than in `assets.ts` because the upload flows dispatch it
+       * directly via `initiate()` after each file completes, and `assets.ts` already
+       * imports from this module — defining it there would be a circular import.
+       * Re-exported from `assets.ts` for the components that consume the hook.
+       */ generateAiMetadata: builder.mutation({
+                query: ({ fileIds })=>({
+                        url: '/upload/actions/generate-ai-metadata',
+                        method: 'POST',
+                        data: {
+                            fileIds
+                        }
+                    }),
+                transformResponse: (response)=>response.data,
+                invalidatesTags: (_result, _error, { fileIds })=>[
+                        ...fileIds.map((id)=>({
+                                type: 'Asset',
+                                id
+                            })),
+                        {
+                            type: 'Asset',
+                            id: 'LIST'
+                        }
+                    ]
+            })
+        })
+});
+const { useUploadFilesMutation, useUploadFileSilentlyMutation, useRetryCancelledFilesMutation, useUploadFromUrlsMutation, useGenerateAiMetadataMutation } = uploadApi;
+
+export { abortUpload, maybeGenerateMetadata, uploadApi, useGenerateAiMetadataMutation, useRetryCancelledFilesMutation, useUploadFileSilentlyMutation, useUploadFilesMutation, useUploadFromUrlsMutation };
+//# sourceMappingURL=api.mjs.map