@strapi/upload 5.36.0 → 5.37.0

package/dist/admin/future/pages/Assets/hooks/useFolderNavigation.mjs

@@ -0,0 +1,18 @@
+import { useQueryParams } from '@strapi/admin/strapi-admin';
+
+const useFolderNavigation = ()=>{
+    const [{ query }, setQuery] = useQueryParams();
+    const currentFolderId = query?.folder ? Number(query.folder) : null;
+    const navigateToFolder = (folder)=>{
+        setQuery({
+            folder: String(folder.id)
+        });
+    };
+    return {
+        currentFolderId,
+        navigateToFolder
+    };
+};
+
+export { useFolderNavigation };
+//# sourceMappingURL=useFolderNavigation.mjs.map

package/dist/admin/future/pages/Assets/hooks/useFolderNavigation.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFolderNavigation.mjs","sources":["../../../../../../admin/src/future/pages/Assets/hooks/useFolderNavigation.ts"],"sourcesContent":["import { useQueryParams } from '@strapi/admin/strapi-admin';\n\nimport type { Folder } from '../../../../../../shared/contracts/folders';\n\nexport const useFolderNavigation = () => {\n  const [{ query }, setQuery] = useQueryParams<{ folder?: string }>();\n\n  const currentFolderId = query?.folder ? Number(query.folder) : null;\n\n  const navigateToFolder = (folder: Folder) => {\n    setQuery({ folder: String(folder.id) });\n  };\n\n  return {\n    currentFolderId,\n    navigateToFolder,\n  };\n};\n"],"names":["useFolderNavigation","query","setQuery","useQueryParams","currentFolderId","folder","Number","navigateToFolder","String","id"],"mappings":";;MAIaA,mBAAsB,GAAA,IAAA;AACjC,IAAA,MAAM,CAAC,EAAEC,KAAK,EAAE,EAAEC,SAAS,GAAGC,cAAAA,EAAAA;AAE9B,IAAA,MAAMC,kBAAkBH,KAAOI,EAAAA,MAAAA,GAASC,MAAOL,CAAAA,KAAAA,CAAMI,MAAM,CAAI,GAAA,IAAA;AAE/D,IAAA,MAAME,mBAAmB,CAACF,MAAAA,GAAAA;QACxBH,QAAS,CAAA;YAAEG,MAAQG,EAAAA,MAAAA,CAAOH,OAAOI,EAAE;AAAE,SAAA,CAAA;AACvC,KAAA;IAEA,OAAO;AACLL,QAAAA,eAAAA;AACAG,QAAAA;AACF,KAAA;AACF;;;;"}

package/dist/admin/future/pages/Assets/hooks/useInfiniteAssets.js

@@ -0,0 +1,77 @@
+'use strict';
+
+var React = require('react');
+var assets = require('../../../services/assets.js');
+
+const PAGE_SIZE = 20;
+const useInfiniteAssets = ({ folder = null, sort } = {})=>{
+    const [page, setPage] = React.useState(1);
+    const lastResultsRef = React.useRef([]);
+    const isMountRef = React.useRef(true);
+    const { currentData: data, isLoading, isFetching, error } = assets.useGetAssetsQuery({
+        folder,
+        page,
+        pageSize: PAGE_SIZE,
+        sort
+    });
+    const pagination = data?.pagination;
+    // Accumulate pages. When cache is invalidated the current page is refetched
+    // detect this and reset to avoid a gap in the results.
+    const assets$1 = React.useMemo(()=>{
+        if (!data) {
+            return lastResultsRef.current;
+        }
+        const currentPageResults = data.results;
+        if (page === 1) {
+            lastResultsRef.current = currentPageResults;
+        } else {
+            // If accumulated length doesn't match expectation, cache was cleared
+            const expectedPrior = (page - 1) * PAGE_SIZE;
+            if (lastResultsRef.current.length < expectedPrior - PAGE_SIZE) {
+                return lastResultsRef.current;
+            }
+            // Only append if these aren't already accumulated
+            if (lastResultsRef.current.length < page * PAGE_SIZE) {
+                lastResultsRef.current = [
+                    ...lastResultsRef.current,
+                    ...currentPageResults
+                ];
+            }
+        }
+        return lastResultsRef.current;
+    }, [
+        data,
+        page
+    ]);
+    // Reset on filter/sort change — skip the initial mount since the memo
+    // already handles page 1 correctly
+    React.useEffect(()=>{
+        if (isMountRef.current) {
+            isMountRef.current = false;
+            return;
+        }
+        setPage(1);
+        lastResultsRef.current = [];
+    }, [
+        folder,
+        sort
+    ]);
+    const hasNextPage = pagination ? page < pagination.pageCount : false;
+    const isFetchingMore = isFetching && page > 1;
+    const fetchNextPage = React.useCallback(()=>{
+        setPage((prev)=>prev + 1);
+    }, []);
+    return {
+        assets: assets$1,
+        pagination,
+        isLoading,
+        isFetchingMore,
+        hasNextPage,
+        fetchNextPage,
+        error
+    };
+};
+
+exports.PAGE_SIZE = PAGE_SIZE;
+exports.useInfiniteAssets = useInfiniteAssets;
+//# sourceMappingURL=useInfiniteAssets.js.map

package/dist/admin/future/pages/Assets/hooks/useInfiniteAssets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useInfiniteAssets.js","sources":["../../../../../../admin/src/future/pages/Assets/hooks/useInfiniteAssets.ts"],"sourcesContent":["import { useState, useCallback, useMemo, useEffect, useRef } from 'react';\n\nimport { useGetAssetsQuery } from '../../../services/assets';\n\nimport type { File } from '../../../../../../shared/contracts/files';\n\nconst PAGE_SIZE = 20;\n\ninterface UseInfiniteAssetsOptions {\n  folder?: number | null;\n  sort?: string;\n}\n\nconst useInfiniteAssets = ({ folder = null, sort }: UseInfiniteAssetsOptions = {}) => {\n  const [page, setPage] = useState(1);\n  const lastResultsRef = useRef<File[]>([]);\n  const isMountRef = useRef(true);\n\n  const {\n    currentData: data,\n    isLoading,\n    isFetching,\n    error,\n  } = useGetAssetsQuery({\n    folder,\n    page,\n    pageSize: PAGE_SIZE,\n    sort,\n  });\n\n  const pagination = data?.pagination;\n\n  // Accumulate pages. When cache is invalidated the current page is refetched\n  // detect this and reset to avoid a gap in the results.\n  const assets = useMemo(() => {\n    if (!data) {\n      return lastResultsRef.current;\n    }\n\n    const currentPageResults = data.results;\n\n    if (page === 1) {\n      lastResultsRef.current = currentPageResults;\n    } else {\n      // If accumulated length doesn't match expectation, cache was cleared\n      const expectedPrior = (page - 1) * PAGE_SIZE;\n      if (lastResultsRef.current.length < expectedPrior - PAGE_SIZE) {\n        return lastResultsRef.current;\n      }\n\n      // Only append if these aren't already accumulated\n      if (lastResultsRef.current.length < page * PAGE_SIZE) {\n        lastResultsRef.current = [...lastResultsRef.current, ...currentPageResults];\n      }\n    }\n\n    return lastResultsRef.current;\n  }, [data, page]);\n\n  // Reset on filter/sort change — skip the initial mount since the memo\n  // already handles page 1 correctly\n  useEffect(() => {\n    if (isMountRef.current) {\n      isMountRef.current = false;\n\n      return;\n    }\n    setPage(1);\n    lastResultsRef.current = [];\n  }, [folder, sort]);\n\n  const hasNextPage = pagination ? page < pagination.pageCount : false;\n  const isFetchingMore = isFetching && page > 1;\n\n  const fetchNextPage = useCallback(() => {\n    setPage((prev) => prev + 1);\n  }, []);\n\n  return { assets, pagination, isLoading, isFetchingMore, hasNextPage, fetchNextPage, error };\n};\n\nexport { useInfiniteAssets };\nexport { PAGE_SIZE };\n"],"names":["PAGE_SIZE","useInfiniteAssets","folder","sort","page","setPage","useState","lastResultsRef","useRef","isMountRef","currentData","data","isLoading","isFetching","error","useGetAssetsQuery","pageSize","pagination","assets","useMemo","current","currentPageResults","results","expectedPrior","length","useEffect","hasNextPage","pageCount","isFetchingMore","fetchNextPage","useCallback","prev"],"mappings":";;;;;AAMA,MAAMA,SAAY,GAAA;AAOZC,MAAAA,iBAAAA,GAAoB,CAAC,EAAEC,MAAS,GAAA,IAAI,EAAEC,IAAI,EAA4B,GAAG,EAAE,GAAA;AAC/E,IAAA,MAAM,CAACC,IAAAA,EAAMC,OAAQ,CAAA,GAAGC,cAAS,CAAA,CAAA,CAAA;IACjC,MAAMC,cAAAA,GAAiBC,aAAe,EAAE,CAAA;AACxC,IAAA,MAAMC,aAAaD,YAAO,CAAA,IAAA,CAAA;IAE1B,MAAM,EACJE,WAAaC,EAAAA,IAAI,EACjBC,SAAS,EACTC,UAAU,EACVC,KAAK,EACN,GAAGC,wBAAkB,CAAA;AACpBb,QAAAA,MAAAA;AACAE,QAAAA,IAAAA;QACAY,QAAUhB,EAAAA,SAAAA;AACVG,QAAAA;AACF,KAAA,CAAA;AAEA,IAAA,MAAMc,aAAaN,IAAMM,EAAAA,UAAAA;;;AAIzB,IAAA,MAAMC,WAASC,aAAQ,CAAA,IAAA;AACrB,QAAA,IAAI,CAACR,IAAM,EAAA;AACT,YAAA,OAAOJ,eAAea,OAAO;AAC/B;QAEA,MAAMC,kBAAAA,GAAqBV,KAAKW,OAAO;AAEvC,QAAA,IAAIlB,SAAS,CAAG,EAAA;AACdG,YAAAA,cAAAA,CAAea,OAAO,GAAGC,kBAAAA;SACpB,MAAA;;AAEL,YAAA,MAAME,aAAgB,GAACnB,CAAAA,IAAAA,GAAO,CAAA,IAAKJ,SAAAA;AACnC,YAAA,IAAIO,eAAea,OAAO,CAACI,MAAM,GAAGD,gBAAgBvB,SAAW,EAAA;AAC7D,gBAAA,OAAOO,eAAea,OAAO;AAC/B;;AAGA,YAAA,IAAIb,eAAea,OAAO,CAACI,MAAM,GAAGpB,OAAOJ,SAAW,EAAA;AACpDO,gBAAAA,cAAAA,CAAea,OAAO,GAAG;AAAIb,oBAAAA,GAAAA,cAAAA,CAAea,OAAO;AAAKC,oBAAAA,GAAAA;AAAmB,iBAAA;AAC7E;AACF;AAEA,QAAA,OAAOd,eAAea,OAAO;KAC5B,EAAA;AAACT,QAAAA,IAAAA;AAAMP,QAAAA;AAAK,KAAA,CAAA;;;IAIfqB,eAAU,CAAA,IAAA;QACR,IAAIhB,UAAAA,CAAWW,OAAO,EAAE;AACtBX,YAAAA,UAAAA,CAAWW,OAAO,GAAG,KAAA;AAErB,YAAA;AACF;QACAf,OAAQ,CAAA,CAAA,CAAA;QACRE,cAAea,CAAAA,OAAO,GAAG,EAAE;KAC1B,EAAA;AAAClB,QAAAA,MAAAA;AAAQC,QAAAA;AAAK,KAAA,CAAA;AAEjB,IAAA,MAAMuB,WAAcT,GAAAA,UAAAA,GAAab,IAAOa,GAAAA,UAAAA,CAAWU,SAAS,GAAG,KAAA;IAC/D,MAAMC,cAAAA,GAAiBf,cAAcT,IAAO,GAAA,CAAA;AAE5C,IAAA,MAAMyB,gBAAgBC,iBAAY,CAAA,IAAA;QAChCzB,OAAQ,CAAA,CAAC0B,OAASA,IAAO,GAAA,CAAA,CAAA;AAC3B,KAAA,EAAG,EAAE,CAAA;IAEL,OAAO;AAAEb,gBAAAA,QAAAA;AAAQD,QAAAA,UAAAA;AAAYL,QAAAA,SAAAA;AAAWgB,QAAAA,cAAAA;AAAgBF,QAAAA,WAAAA;AAAaG,QAAAA,aAAAA;AAAef,QAAAA;AAAM,KAAA;AAC5F;;;;;"}

package/dist/admin/future/pages/Assets/hooks/useInfiniteAssets.mjs

@@ -0,0 +1,74 @@
+import { useState, useRef, useMemo, useEffect, useCallback } from 'react';
+import { useGetAssetsQuery } from '../../../services/assets.mjs';
+
+const PAGE_SIZE = 20;
+const useInfiniteAssets = ({ folder = null, sort } = {})=>{
+    const [page, setPage] = useState(1);
+    const lastResultsRef = useRef([]);
+    const isMountRef = useRef(true);
+    const { currentData: data, isLoading, isFetching, error } = useGetAssetsQuery({
+        folder,
+        page,
+        pageSize: PAGE_SIZE,
+        sort
+    });
+    const pagination = data?.pagination;
+    // Accumulate pages. When cache is invalidated the current page is refetched
+    // detect this and reset to avoid a gap in the results.
+    const assets = useMemo(()=>{
+        if (!data) {
+            return lastResultsRef.current;
+        }
+        const currentPageResults = data.results;
+        if (page === 1) {
+            lastResultsRef.current = currentPageResults;
+        } else {
+            // If accumulated length doesn't match expectation, cache was cleared
+            const expectedPrior = (page - 1) * PAGE_SIZE;
+            if (lastResultsRef.current.length < expectedPrior - PAGE_SIZE) {
+                return lastResultsRef.current;
+            }
+            // Only append if these aren't already accumulated
+            if (lastResultsRef.current.length < page * PAGE_SIZE) {
+                lastResultsRef.current = [
+                    ...lastResultsRef.current,
+                    ...currentPageResults
+                ];
+            }
+        }
+        return lastResultsRef.current;
+    }, [
+        data,
+        page
+    ]);
+    // Reset on filter/sort change — skip the initial mount since the memo
+    // already handles page 1 correctly
+    useEffect(()=>{
+        if (isMountRef.current) {
+            isMountRef.current = false;
+            return;
+        }
+        setPage(1);
+        lastResultsRef.current = [];
+    }, [
+        folder,
+        sort
+    ]);
+    const hasNextPage = pagination ? page < pagination.pageCount : false;
+    const isFetchingMore = isFetching && page > 1;
+    const fetchNextPage = useCallback(()=>{
+        setPage((prev)=>prev + 1);
+    }, []);
+    return {
+        assets,
+        pagination,
+        isLoading,
+        isFetchingMore,
+        hasNextPage,
+        fetchNextPage,
+        error
+    };
+};
+
+export { PAGE_SIZE, useInfiniteAssets };
+//# sourceMappingURL=useInfiniteAssets.mjs.map

package/dist/admin/future/pages/Assets/hooks/useInfiniteAssets.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useInfiniteAssets.mjs","sources":["../../../../../../admin/src/future/pages/Assets/hooks/useInfiniteAssets.ts"],"sourcesContent":["import { useState, useCallback, useMemo, useEffect, useRef } from 'react';\n\nimport { useGetAssetsQuery } from '../../../services/assets';\n\nimport type { File } from '../../../../../../shared/contracts/files';\n\nconst PAGE_SIZE = 20;\n\ninterface UseInfiniteAssetsOptions {\n  folder?: number | null;\n  sort?: string;\n}\n\nconst useInfiniteAssets = ({ folder = null, sort }: UseInfiniteAssetsOptions = {}) => {\n  const [page, setPage] = useState(1);\n  const lastResultsRef = useRef<File[]>([]);\n  const isMountRef = useRef(true);\n\n  const {\n    currentData: data,\n    isLoading,\n    isFetching,\n    error,\n  } = useGetAssetsQuery({\n    folder,\n    page,\n    pageSize: PAGE_SIZE,\n    sort,\n  });\n\n  const pagination = data?.pagination;\n\n  // Accumulate pages. When cache is invalidated the current page is refetched\n  // detect this and reset to avoid a gap in the results.\n  const assets = useMemo(() => {\n    if (!data) {\n      return lastResultsRef.current;\n    }\n\n    const currentPageResults = data.results;\n\n    if (page === 1) {\n      lastResultsRef.current = currentPageResults;\n    } else {\n      // If accumulated length doesn't match expectation, cache was cleared\n      const expectedPrior = (page - 1) * PAGE_SIZE;\n      if (lastResultsRef.current.length < expectedPrior - PAGE_SIZE) {\n        return lastResultsRef.current;\n      }\n\n      // Only append if these aren't already accumulated\n      if (lastResultsRef.current.length < page * PAGE_SIZE) {\n        lastResultsRef.current = [...lastResultsRef.current, ...currentPageResults];\n      }\n    }\n\n    return lastResultsRef.current;\n  }, [data, page]);\n\n  // Reset on filter/sort change — skip the initial mount since the memo\n  // already handles page 1 correctly\n  useEffect(() => {\n    if (isMountRef.current) {\n      isMountRef.current = false;\n\n      return;\n    }\n    setPage(1);\n    lastResultsRef.current = [];\n  }, [folder, sort]);\n\n  const hasNextPage = pagination ? page < pagination.pageCount : false;\n  const isFetchingMore = isFetching && page > 1;\n\n  const fetchNextPage = useCallback(() => {\n    setPage((prev) => prev + 1);\n  }, []);\n\n  return { assets, pagination, isLoading, isFetchingMore, hasNextPage, fetchNextPage, error };\n};\n\nexport { useInfiniteAssets };\nexport { PAGE_SIZE };\n"],"names":["PAGE_SIZE","useInfiniteAssets","folder","sort","page","setPage","useState","lastResultsRef","useRef","isMountRef","currentData","data","isLoading","isFetching","error","useGetAssetsQuery","pageSize","pagination","assets","useMemo","current","currentPageResults","results","expectedPrior","length","useEffect","hasNextPage","pageCount","isFetchingMore","fetchNextPage","useCallback","prev"],"mappings":";;;AAMA,MAAMA,SAAY,GAAA;AAOZC,MAAAA,iBAAAA,GAAoB,CAAC,EAAEC,MAAS,GAAA,IAAI,EAAEC,IAAI,EAA4B,GAAG,EAAE,GAAA;AAC/E,IAAA,MAAM,CAACC,IAAAA,EAAMC,OAAQ,CAAA,GAAGC,QAAS,CAAA,CAAA,CAAA;IACjC,MAAMC,cAAAA,GAAiBC,OAAe,EAAE,CAAA;AACxC,IAAA,MAAMC,aAAaD,MAAO,CAAA,IAAA,CAAA;IAE1B,MAAM,EACJE,WAAaC,EAAAA,IAAI,EACjBC,SAAS,EACTC,UAAU,EACVC,KAAK,EACN,GAAGC,iBAAkB,CAAA;AACpBb,QAAAA,MAAAA;AACAE,QAAAA,IAAAA;QACAY,QAAUhB,EAAAA,SAAAA;AACVG,QAAAA;AACF,KAAA,CAAA;AAEA,IAAA,MAAMc,aAAaN,IAAMM,EAAAA,UAAAA;;;AAIzB,IAAA,MAAMC,SAASC,OAAQ,CAAA,IAAA;AACrB,QAAA,IAAI,CAACR,IAAM,EAAA;AACT,YAAA,OAAOJ,eAAea,OAAO;AAC/B;QAEA,MAAMC,kBAAAA,GAAqBV,KAAKW,OAAO;AAEvC,QAAA,IAAIlB,SAAS,CAAG,EAAA;AACdG,YAAAA,cAAAA,CAAea,OAAO,GAAGC,kBAAAA;SACpB,MAAA;;AAEL,YAAA,MAAME,aAAgB,GAACnB,CAAAA,IAAAA,GAAO,CAAA,IAAKJ,SAAAA;AACnC,YAAA,IAAIO,eAAea,OAAO,CAACI,MAAM,GAAGD,gBAAgBvB,SAAW,EAAA;AAC7D,gBAAA,OAAOO,eAAea,OAAO;AAC/B;;AAGA,YAAA,IAAIb,eAAea,OAAO,CAACI,MAAM,GAAGpB,OAAOJ,SAAW,EAAA;AACpDO,gBAAAA,cAAAA,CAAea,OAAO,GAAG;AAAIb,oBAAAA,GAAAA,cAAAA,CAAea,OAAO;AAAKC,oBAAAA,GAAAA;AAAmB,iBAAA;AAC7E;AACF;AAEA,QAAA,OAAOd,eAAea,OAAO;KAC5B,EAAA;AAACT,QAAAA,IAAAA;AAAMP,QAAAA;AAAK,KAAA,CAAA;;;IAIfqB,SAAU,CAAA,IAAA;QACR,IAAIhB,UAAAA,CAAWW,OAAO,EAAE;AACtBX,YAAAA,UAAAA,CAAWW,OAAO,GAAG,KAAA;AAErB,YAAA;AACF;QACAf,OAAQ,CAAA,CAAA,CAAA;QACRE,cAAea,CAAAA,OAAO,GAAG,EAAE;KAC1B,EAAA;AAAClB,QAAAA,MAAAA;AAAQC,QAAAA;AAAK,KAAA,CAAA;AAEjB,IAAA,MAAMuB,WAAcT,GAAAA,UAAAA,GAAab,IAAOa,GAAAA,UAAAA,CAAWU,SAAS,GAAG,KAAA;IAC/D,MAAMC,cAAAA,GAAiBf,cAAcT,IAAO,GAAA,CAAA;AAE5C,IAAA,MAAMyB,gBAAgBC,WAAY,CAAA,IAAA;QAChCzB,OAAQ,CAAA,CAAC0B,OAASA,IAAO,GAAA,CAAA,CAAA;AAC3B,KAAA,EAAG,EAAE,CAAA;IAEL,OAAO;AAAEb,QAAAA,MAAAA;AAAQD,QAAAA,UAAAA;AAAYL,QAAAA,SAAAA;AAAWgB,QAAAA,cAAAA;AAAgBF,QAAAA,WAAAA;AAAaG,QAAAA,aAAAA;AAAef,QAAAA;AAAM,KAAA;AAC5F;;;;"}

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

@@ -1,7 +1,189 @@
 'use strict';
 
 var strapiAdmin = require('@strapi/admin/strapi-admin');
+var uploadProgress = require('../store/uploadProgress.js');
 
+/**
+ * Stores original File objects for retry functionality.
+ *
+ * Similar to abortControllers, File objects cannot be stored in Redux state
+ * (they are not serializable). This Map allows us to retry cancelled uploads
+ * by retrieving the original files using the uploadId.
+ */ const uploadedFiles = new Map();
+/**
+ * Registers files for a specific upload to enable retry.
+ */ const registerUploadedFiles = (uploadId, files)=>{
+    uploadedFiles.set(uploadId, files);
+};
+/**
+ * Retrieves stored files for an upload.
+ */ const getUploadedFiles = (uploadId)=>{
+    return uploadedFiles.get(uploadId);
+};
+/**
+ * Manages abort controllers for in-flight uploads.
+ *
+ * Design decision: Uses a Map to track uploads by their unique uploadId.
+ * This approach is necessary because:
+ * 1. Redux state cannot store function references (abort controllers)
+ * 2. RTK Query's signal is only accessible within the queryFn
+ * 3. The upload is triggered in AssetsPage but cancelled from UploadProgressDialog
+ *
+ * The uploadId ensures we abort the correct upload even if multiple uploads
+ * are queued, though the current UI prevents simultaneous uploads.
+ */ const abortControllers = new Map();
+/**
+ * Registers an abort controller for a specific upload.
+ * Called internally when an upload starts.
+ */ const registerAbortController = (uploadId, controller)=>{
+    abortControllers.set(uploadId, controller);
+};
+/**
+ * Removes an abort controller when an upload completes or is aborted.
+ */ 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);
+    }
+};
+/**
+ * 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 request to the server.
+ *
+ * We use fetch directly instead of RTK Query's fetchBaseQuery because:
+ * 1. We need access to the raw Response to read the body as a stream
+ * 2. RTK Query's baseQuery awaits the full response and parses it as JSON,
+ *    which doesn't work for Server-Sent Events (SSE) streaming
+ * 3. The stream must be read incrementally via response.body.getReader()
+ *    to dispatch progress updates as files upload
+ */ const fetchUploadStream = async ({ token, formData, signal })=>{
+    const backendURL = window.strapi.backendURL;
+    const headers = {};
+    if (token) {
+        headers.Authorization = `Bearer ${token}`;
+    }
+    return fetch(`${backendURL}/upload/unstable/stream`, {
+        method: 'POST',
+        headers,
+        body: formData,
+        signal
+    });
+};
+/**
+ * Processes an SSE stream from the upload endpoint.
+ * Dispatches Redux actions for each file event and returns the final result.
+ *
+ * @param options.response - The fetch Response object with SSE body
+ * @param options.dispatch - Redux dispatch function
+ * @param options.indexMapper - Optional function to map server indices to state indices (for retry)
+ * @param options.logPrefix - Optional prefix for console logs
+ * @returns The stream result or null if no files completed
+ */ const processSSEStream = async ({ response, dispatch, indexMapper = (i)=>i })=>{
+    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 mappedIndex = indexMapper(parsed.index);
+            switch(event){
+                case 'file:uploading':
+                    {
+                        const payload = parsed;
+                        dispatch(uploadProgress.setFileUploading({
+                            name: payload.name,
+                            index: mappedIndex,
+                            total: payload.total,
+                            size: payload.size
+                        }));
+                        break;
+                    }
+                case 'file:complete':
+                    {
+                        const payload = parsed;
+                        dispatch(uploadProgress.setFileComplete({
+                            index: mappedIndex,
+                            file: payload.file
+                        }));
+                        break;
+                    }
+                case 'file:error':
+                    {
+                        const payload = parsed;
+                        dispatch(uploadProgress.setFileError({
+                            index: mappedIndex,
+                            name: payload.name,
+                            message: payload.message
+                        }));
+                        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 = strapiAdmin.adminApi.enhanceEndpoints({
     addTagTypes: [
         'Asset',
@@ -9,20 +191,248 @@ const uploadApi = strapiAdmin.adminApi.enhanceEndpoints({
     ]
 }).injectEndpoints({
     endpoints: (builder)=>({
-            uploadFiles: builder.mutation({
-                query: (formData)=>({
-                        url: '/upload',
-                        method: 'POST',
-                        data: formData
-                    }),
+            /**
+       * Stream upload files to the /upload/unstable/stream endpoint.
+       * Reads SSE stream for per-file progress updates.
+       */ uploadFilesStream: builder.mutation({
+                queryFn: async ({ formData, totalFiles }, { dispatch, getState })=>{
+                    const token = getState().admin_app?.token;
+                    // Extract file names and sizes from FormData
+                    const files = formData.getAll('files');
+                    const fileInfoJson = formData.get('fileInfo');
+                    const fileInfo = JSON.parse(fileInfoJson);
+                    const fileNames = fileInfo.map((info)=>info.name);
+                    const fileSizes = files.map((file)=>file.size);
+                    // Open the progress dialog and get the uploadId
+                    dispatch(uploadProgress.openUploadProgress({
+                        totalFiles,
+                        fileNames,
+                        fileSizes
+                    }));
+                    dispatch(uploadProgress.updateProgress(0));
+                    // Get the uploadId from state after dispatching
+                    const uploadId = getState().uploadProgress.uploadId;
+                    // Store original files for retry functionality
+                    registerUploadedFiles(uploadId, files);
+                    // Create abort controller for this upload
+                    const abortController = new AbortController();
+                    registerAbortController(uploadId, abortController);
+                    try {
+                        const response = await fetchUploadStream({
+                            token,
+                            formData,
+                            signal: abortController.signal
+                        });
+                        if (!response.ok || !response.body) {
+                            unregisterAbortController(uploadId);
+                            // Try to parse error message from response
+                            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  {
+                                // If we can't parse the error, use a generic message with status code
+                                errorMessage = `Upload failed with status ${response.status}`;
+                            }
+                            // Mark all files as failed in the UI
+                            dispatch(uploadProgress.setUploadFailed({
+                                message: errorMessage
+                            }));
+                            return {
+                                error: {
+                                    name: 'UnknownError',
+                                    message: errorMessage,
+                                    status: response.status
+                                }
+                            };
+                        }
+                        const streamResult = await processSSEStream({
+                            response,
+                            dispatch
+                        });
+                        unregisterAbortController(uploadId);
+                        if (streamResult && streamResult.data.length > 0) {
+                            return {
+                                data: streamResult
+                            };
+                        }
+                        // If stream ended without completing any files, mark all as failed
+                        const errorMessage = 'No files were uploaded successfully';
+                        dispatch(uploadProgress.setUploadFailed({
+                            message: errorMessage
+                        }));
+                        return {
+                            error: {
+                                name: 'UnknownError',
+                                message: errorMessage
+                            }
+                        };
+                    } catch (err) {
+                        unregisterAbortController(uploadId);
+                        if (err instanceof DOMException && err.name === 'AbortError') {
+                            // Don't mark as failed for user-initiated cancellations
+                            return {
+                                error: {
+                                    name: 'UnknownError',
+                                    message: 'Upload cancelled'
+                                }
+                            };
+                        }
+                        // For network errors or other exceptions, mark all files as failed
+                        const errorMessage = err instanceof Error ? err.message : 'Network error occurred';
+                        dispatch(uploadProgress.setUploadFailed({
+                            message: errorMessage
+                        }));
+                        return {
+                            error: {
+                                name: 'UnknownError',
+                                message: errorMessage
+                            }
+                        };
+                    }
+                },
                 invalidatesTags: [
-                    'Asset'
+                    {
+                        type: 'Asset',
+                        id: 'LIST'
+                    }
+                ]
+            }),
+            /**
+       * Retry uploading cancelled files.
+       * Retrieves original File objects and re-uploads only the cancelled ones.
+       */ retryCancelledFilesStream: builder.mutation({
+                queryFn: async (_, { dispatch, getState })=>{
+                    const token = getState().admin_app?.token;
+                    const { uploadId, files: stateFiles } = getState().uploadProgress;
+                    // Get cancelled files with their original indices
+                    const cancelledFiles = stateFiles.filter((f)=>f.status === 'cancelled');
+                    if (cancelledFiles.length === 0) {
+                        return {
+                            error: {
+                                name: 'UnknownError',
+                                message: 'No cancelled files to retry'
+                            }
+                        };
+                    }
+                    // Get the original File objects
+                    const originalFiles = getUploadedFiles(uploadId);
+                    if (!originalFiles) {
+                        return {
+                            error: {
+                                name: 'UnknownError',
+                                message: 'Original files not found'
+                            }
+                        };
+                    }
+                    // Build mapping from new index to original index
+                    const indexMapping = cancelledFiles.map((f)=>f.index);
+                    const filesToRetry = cancelledFiles.map((f)=>originalFiles[f.index]);
+                    // Reset cancelled files to pending
+                    dispatch(uploadProgress.retryCancelledFiles());
+                    // Build FormData for retry
+                    const formData = new FormData();
+                    const fileInfoArray = filesToRetry.map((file)=>({
+                            name: file.name,
+                            caption: null,
+                            alternativeText: null,
+                            folder: null
+                        }));
+                    filesToRetry.forEach((file)=>{
+                        formData.append('files', file);
+                    });
+                    formData.append('fileInfo', JSON.stringify(fileInfoArray));
+                    // Create abort controller for this retry
+                    const abortController = new AbortController();
+                    registerAbortController(uploadId, abortController);
+                    try {
+                        const response = await fetchUploadStream({
+                            token,
+                            formData,
+                            signal: abortController.signal
+                        });
+                        if (!response.ok || !response.body) {
+                            unregisterAbortController(uploadId);
+                            let errorMessage = 'Retry 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 = `Retry failed with status ${response.status}`;
+                            }
+                            // Mark retried files as failed
+                            for (const originalIndex of indexMapping){
+                                dispatch(uploadProgress.setFileError({
+                                    index: originalIndex,
+                                    name: stateFiles[originalIndex].name,
+                                    message: errorMessage
+                                }));
+                            }
+                            return {
+                                error: {
+                                    name: 'UnknownError',
+                                    message: errorMessage,
+                                    status: response.status
+                                }
+                            };
+                        }
+                        const streamResult = await processSSEStream({
+                            response,
+                            dispatch,
+                            indexMapper: (serverIndex)=>indexMapping[serverIndex]
+                        });
+                        unregisterAbortController(uploadId);
+                        if (streamResult && streamResult.data.length > 0) {
+                            return {
+                                data: streamResult
+                            };
+                        }
+                        return {
+                            error: {
+                                name: 'UnknownError',
+                                message: 'No files were uploaded successfully'
+                            }
+                        };
+                    } catch (err) {
+                        unregisterAbortController(uploadId);
+                        if (err instanceof DOMException && err.name === 'AbortError') {
+                            return {
+                                error: {
+                                    name: 'UnknownError',
+                                    message: 'Retry cancelled'
+                                }
+                            };
+                        }
+                        const errorMessage = err instanceof Error ? err.message : 'Network error occurred';
+                        return {
+                            error: {
+                                name: 'UnknownError',
+                                message: errorMessage
+                            }
+                        };
+                    }
+                },
+                invalidatesTags: [
+                    {
+                        type: 'Asset',
+                        id: 'LIST'
+                    }
                 ]
             })
         })
 });
-const { useUploadFilesMutation } = uploadApi;
+const { useUploadFilesStreamMutation, useRetryCancelledFilesStreamMutation } = uploadApi;
 
+exports.abortUpload = abortUpload;
 exports.uploadApi = uploadApi;
-exports.useUploadFilesMutation = useUploadFilesMutation;
+exports.useRetryCancelledFilesStreamMutation = useRetryCancelledFilesStreamMutation;
+exports.useUploadFilesStreamMutation = useUploadFilesStreamMutation;
 //# sourceMappingURL=api.js.map