@strapi/upload 5.53.0 → 5.55.0

package/dist/admin/future/services/api.mjs

@@ -1,749 +0,0 @@
-import { adminApi } from '@strapi/admin/strapi-admin';
-import { openUploadProgress, setUploadFailed, retryCancelledFiles, isUploadInFlight, appendUploadFiles, setFileError, setFileComplete, setFileUploading, setFileMetadataGenerating, setFileMetadataResult, setFileProgress } 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: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