@strapi/upload 5.51.2 → 5.52.1

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

@@ -0,0 +1,44 @@
+import { useState, useCallback, useMemo, createElement, createContext, useContext } from 'react';
+
+const BusyAssetsContext = createContext(null);
+const BusyAssetsProvider = ({ children })=>{
+    const [busyById, setBusyById] = useState({});
+    const markBusy = useCallback((id, message)=>{
+        setBusyById((prev)=>({
+                ...prev,
+                [id]: message
+            }));
+        return ()=>setBusyById((prev)=>{
+                // Rebuild without the key rather than mutating — the value is compared
+                // by identity downstream.
+                const { [id]: _released, ...rest } = prev;
+                return rest;
+            });
+    }, []);
+    const isBusy = useCallback((id)=>busyById[id] !== undefined, [
+        busyById
+    ]);
+    const getBusyMessage = useCallback((id)=>busyById[id] ?? null, [
+        busyById
+    ]);
+    const value = useMemo(()=>({
+            isBusy,
+            getBusyMessage,
+            markBusy
+        }), [
+        isBusy,
+        getBusyMessage,
+        markBusy
+    ]);
+    return createElement(BusyAssetsContext.Provider, {
+        value
+    }, children);
+};
+/**
+ * Optional by design: `AssetActionsMenu`, `AssetRow` and `AssetCard` are also
+ * rendered in tests and in the asset picker, outside this provider. Without it
+ * the mutation still runs, it just shows no row-level feedback.
+ */ const useBusyAssetsOptional = ()=>useContext(BusyAssetsContext);
+
+export { BusyAssetsProvider, useBusyAssetsOptional };
+//# sourceMappingURL=useBusyAssets.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useBusyAssets.mjs","sources":["../../../../../../admin/src/future/pages/Assets/hooks/useBusyAssets.ts"],"sourcesContent":["import { createContext, createElement, useCallback, useContext, useMemo, useState } from 'react';\nimport type { ReactNode } from 'react';\n\n/**\n * Which assets have a long-running mutation in flight, so the list can show it\n * on the item itself.\n *\n * The mutation stays where it is triggered — the row's \"...\" menu — but the\n * feedback has to render on the row or card, which is an ancestor of it. The\n * menu sits in a leaf `<td>` (table) / footer `Flex` (grid), so an overlay\n * mounted there would cover the button and nothing else. Rather than hoist the\n * mutation up into both `AssetRow` and `AssetCard` (duplicating it, and moving\n * it away from the control that owns it), the busy flag travels up through\n * context and the ancestor renders the overlay.\n *\n * Scoped per asset id rather than a single boolean: a replace on one row must\n * not blank out every other row. Modelled on `isMovePending` in\n * `AssetsDndProvider`, which does the same thing for drag-moves — that one is\n * list-wide because a move genuinely blocks the whole list.\n */\nexport interface BusyAssets {\n  /** Whether this asset has a mutation in flight. */\n  isBusy: (id: number) => boolean;\n  /** The message to show while it is, or `null`. */\n  getBusyMessage: (id: number) => string | null;\n  /**\n   * Marks the asset busy and returns the release function. Pair it with\n   * `try`/`finally` so the flag clears on failure too.\n   */\n  markBusy: (id: number, message: string) => () => void;\n}\n\nconst BusyAssetsContext = createContext<BusyAssets | null>(null);\n\nexport const BusyAssetsProvider = ({ children }: { children: ReactNode }) => {\n  const [busyById, setBusyById] = useState<Record<number, string>>({});\n\n  const markBusy = useCallback((id: number, message: string) => {\n    setBusyById((prev) => ({ ...prev, [id]: message }));\n\n    return () =>\n      setBusyById((prev) => {\n        // Rebuild without the key rather than mutating — the value is compared\n        // by identity downstream.\n        const { [id]: _released, ...rest } = prev;\n        return rest;\n      });\n  }, []);\n\n  const isBusy = useCallback((id: number) => busyById[id] !== undefined, [busyById]);\n\n  const getBusyMessage = useCallback((id: number) => busyById[id] ?? null, [busyById]);\n\n  const value = useMemo<BusyAssets>(\n    () => ({ isBusy, getBusyMessage, markBusy }),\n    [isBusy, getBusyMessage, markBusy]\n  );\n\n  return createElement(BusyAssetsContext.Provider, { value }, children);\n};\n\n/**\n * Optional by design: `AssetActionsMenu`, `AssetRow` and `AssetCard` are also\n * rendered in tests and in the asset picker, outside this provider. Without it\n * the mutation still runs, it just shows no row-level feedback.\n */\nexport const useBusyAssetsOptional = () => useContext(BusyAssetsContext);\n"],"names":["BusyAssetsContext","createContext","BusyAssetsProvider","children","busyById","setBusyById","useState","markBusy","useCallback","id","message","prev","_released","rest","isBusy","undefined","getBusyMessage","value","useMemo","createElement","Provider","useBusyAssetsOptional","useContext"],"mappings":";;AAgCA,MAAMA,oBAAoBC,aAAAA,CAAiC,IAAA,CAAA;AAEpD,MAAMC,kBAAAA,GAAqB,CAAC,EAAEC,QAAQ,EAA2B,GAAA;AACtE,IAAA,MAAM,CAACC,QAAAA,EAAUC,WAAAA,CAAY,GAAGC,SAAiC,EAAC,CAAA;IAElE,MAAMC,QAAAA,GAAWC,WAAAA,CAAY,CAACC,EAAAA,EAAYC,OAAAA,GAAAA;QACxCL,WAAAA,CAAY,CAACM,QAAU;AAAE,gBAAA,GAAGA,IAAI;AAAE,gBAAA,CAACF,KAAKC;aAAQ,CAAA,CAAA;QAEhD,OAAO,IACLL,YAAY,CAACM,IAAAA,GAAAA;;;gBAGX,MAAM,EAAE,CAACF,EAAAA,GAAKG,SAAS,EAAE,GAAGC,MAAM,GAAGF,IAAAA;gBACrC,OAAOE,IAAAA;AACT,YAAA,CAAA,CAAA;AACJ,IAAA,CAAA,EAAG,EAAE,CAAA;IAEL,MAAMC,MAAAA,GAASN,YAAY,CAACC,EAAAA,GAAeL,QAAQ,CAACK,EAAAA,CAAG,KAAKM,SAAAA,EAAW;AAACX,QAAAA;AAAS,KAAA,CAAA;IAEjF,MAAMY,cAAAA,GAAiBR,YAAY,CAACC,EAAAA,GAAeL,QAAQ,CAACK,EAAAA,CAAG,IAAI,IAAA,EAAM;AAACL,QAAAA;AAAS,KAAA,CAAA;IAEnF,MAAMa,KAAAA,GAAQC,OAAAA,CACZ,KAAO;AAAEJ,YAAAA,MAAAA;AAAQE,YAAAA,cAAAA;AAAgBT,YAAAA;AAAS,SAAA,CAAA,EAC1C;AAACO,QAAAA,MAAAA;AAAQE,QAAAA,cAAAA;AAAgBT,QAAAA;AAAS,KAAA,CAAA;IAGpC,OAAOY,aAAAA,CAAcnB,iBAAAA,CAAkBoB,QAAQ,EAAE;AAAEH,QAAAA;KAAM,EAAGd,QAAAA,CAAAA;AAC9D;AAEA;;;;AAIC,IACM,MAAMkB,qBAAAA,GAAwB,IAAMC,WAAWtB,iBAAAA;;;;"}

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

@@ -1,92 +1,232 @@
 'use strict';
 
 var React = require('react');
+var reactRedux = require('react-redux');
+var api = require('../../../services/api.js');
 var assets = require('../../../services/assets.js');
 
 const PAGE_SIZE = 20;
-const useInfiniteAssets = ({ folder = null, sort, search, filters, filtersKey = '', enabled = true } = {})=>{
-    const [page, setPage] = React.useState(1);
-    const lastResultsRef = React.useRef([]);
-    const lastPaginationRef = React.useRef(undefined);
-    const isMountRef = React.useRef(true);
-    const isSearchMountRef = React.useRef(true);
-    const { currentData: data, isLoading, isFetching, error } = assets.useGetAssetsQuery({
-        folder,
+/**
+ * Concatenates the pages in ascending order, one entry per asset id.
+ *
+ * `Map.set` keeps the first insertion position but takes the latest value, so
+ * an asset that moved between pages after a mutation holds its place and shows
+ * fresh data instead of rendering twice under a duplicate key.
+ */ const flattenPages = (pages)=>{
+    const byId = new Map();
+    for (const page of Object.keys(pages).map(Number).sort((a, b)=>a - b)){
+        for (const asset of pages[page]){
+            byId.set(asset.id, asset);
+        }
+    }
+    return [
+        ...byId.values()
+    ];
+};
+/**
+ * Keeps one earlier page's `getAssets` query subscribed and reports its results
+ * back up whenever they change.
+ *
+ * The hook itself only subscribes the current (latest) page. Without these, a
+ * mutation invalidating `{Asset, LIST}` refetches that page alone and earlier
+ * pages stay frozen — a rename or delete on an earlier page never reaches the
+ * list until a folder/sort/search change. One subscriber per earlier
+ * page keeps them all subscribed so the invalidation refetches the whole list.
+ * Renders nothing; it exists only for the subscription + `onRefreshed` report.
+ */ const PageSubscriber = ({ queryArgs, page, onRefreshed })=>{
+    const { currentData } = assets.useGetAssetsQuery({
+        ...queryArgs,
+        page,
+        pageSize: PAGE_SIZE
+    });
+    const results = currentData?.results;
+    React.useEffect(()=>{
+        if (results) {
+            onRefreshed(page, results);
+        }
+    // `results` is a stable reference per cache entry, so this only re-reports
+    // when a refetch actually replaces the page's data. Reporting the same
+    // reference the accumulator already holds is a no-op (see `onRefreshed`).
+    }, [
+        results,
         page,
-        pageSize: PAGE_SIZE,
+        onRefreshed
+    ]);
+    return null;
+};
+/**
+ * Infinite scroll over `/upload/files`, keeping one accumulated slot per page.
+ *
+ * The caller MUST render the returned `subscribers` node — that is what keeps
+ * every loaded page subscribed, so `{Asset, LIST}` invalidations keep the whole
+ * list consistent rather than only the current page.
+ */ const useInfiniteAssets = ({ folder = null, sort, search, filters, enabled = true } = {})=>{
+    // Derived from the request args themselves, so a new filter can't reach the
+    // API without also invalidating what was accumulated under the old one.
+    const queryArgs = {
+        folder,
         sort,
         search,
         filters
+    };
+    const queryKey = JSON.stringify(queryArgs);
+    // Identifies the list being viewed, ignoring the search term. Folder, sort
+    // and filter changes are single committed actions, so one clean reset per
+    // change is honest. Search is committed per keystroke on a 300ms debounce,
+    // and blanking the list on each one would strobe as the user types.
+    // The cost: through the search window the previous rows stay rendered and
+    // `hasNextPage` is false, so the list reads as complete until page 1 lands.
+    const listKey = JSON.stringify({
+        folder,
+        sort,
+        filters
+    });
+    const [pageState, setPageState] = React.useState({
+        queryKey,
+        page: 1
+    });
+    const [accumulated, setAccumulated] = React.useState({
+        queryKey,
+        listKey,
+        pages: {}
+    });
+    // Derived rather than read straight from state: the render that discovers
+    // the key change still reaches the query below, and a list with no page 1
+    // must never be requested at page 2.
+    const page = pageState.queryKey === queryKey ? pageState.page : 1;
+    if (pageState.queryKey !== queryKey) {
+        setPageState({
+            queryKey,
+            page: 1
+        });
+    }
+    const { currentData, isLoading, isFetching, error } = assets.useGetAssetsQuery({
+        ...queryArgs,
+        page,
+        pageSize: PAGE_SIZE
     }, {
         skip: !enabled
     });
-    const pagination = data?.pagination;
-    if (pagination) {
-        lastPaginationRef.current = pagination;
+    const isSameQuery = accumulated.queryKey === queryKey;
+    // `currentData` is only ever the payload for the args just passed, so it
+    // belongs to this key at this page — nothing to infer. Its reference is
+    // stable per cache entry, so this settles after one extra render.
+    if (currentData && (!isSameQuery || accumulated.pages[page] !== currentData.results)) {
+        setAccumulated(isSameQuery ? {
+            ...accumulated,
+            pages: {
+                ...accumulated.pages,
+                [page]: currentData.results
+            },
+            pagination: currentData.pagination
+        } : {
+            queryKey,
+            listKey,
+            pages: {
+                [page]: currentData.results
+            },
+            pagination: currentData.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;
+    // Merges a refetched earlier page back into the accumulator. Ignores reports
+    // for a superseded query, and no-ops when the reference is unchanged so a
+    // subscriber re-reporting its already-stored page can't loop.
+    const handlePageRefreshed = React.useCallback((refreshedPage, results)=>{
+        setAccumulated((prev)=>{
+            if (prev.queryKey !== queryKey || prev.pages[refreshedPage] === results) {
+                return prev;
             }
-            // Only append if these aren't already accumulated
-            if (lastResultsRef.current.length < page * PAGE_SIZE) {
-                lastResultsRef.current = [
-                    ...lastResultsRef.current,
-                    ...currentPageResults
-                ];
-            }
-        }
-        return lastResultsRef.current;
+            return {
+                ...prev,
+                pages: {
+                    ...prev.pages,
+                    [refreshedPage]: results
+                }
+            };
+        });
     }, [
-        data,
-        page
+        queryKey
     ]);
-    // Reset on filter/sort change — skip the initial mount since the memo
-    // already handles page 1 correctly
+    // One subscriber per earlier page (the current page is already subscribed by
+    // the query above). Keyed by queryKey so a folder/sort/search change remounts
+    // them against the new args instead of reusing a stale cache entry.
+    // `createElement` rather than JSX so this stays a plain `.ts` hook file.
+    const subscribers = React.createElement(React.Fragment, null, Array.from({
+        length: Math.max(0, page - 1)
+    }, (_, index)=>index + 1).map((earlierPage)=>React.createElement(PageSubscriber, {
+            key: `${queryKey}:${earlierPage}`,
+            queryArgs,
+            page: earlierPage,
+            onRefreshed: handlePageRefreshed
+        })));
+    // Drop the left folder's cached `getAssets` pages when the folder changes.
+    //
+    // RTK Query 1.9.7 leaves a query's store subscription in place when its last
+    // subscriber unmounts while a refetch is still in flight — e.g. a delete
+    // invalidates `{Asset, LIST}`, every loaded page starts refetching, and the
+    // user navigates away before those settle. Those stale subscriptions make the
+    // next `{Asset, LIST}` invalidation (an upload in the new folder) refetch the
+    // *previous* folder's pages: one bogus `/upload/files` request per loaded
+    // page. There is no public per-entry unsubscribe, so evict the left folder's
+    // entries outright — returning reloads from page 1, which the accumulator
+    // already does on a list change.
+    const dispatch = reactRedux.useDispatch();
+    const store = reactRedux.useStore();
+    const prevFolderRef = React.useRef(folder);
     React.useEffect(()=>{
-        if (isMountRef.current) {
-            isMountRef.current = false;
+        const prevFolder = prevFolderRef.current;
+        prevFolderRef.current = folder;
+        if (prevFolder === folder) {
             return;
         }
-        setPage(1);
-        lastResultsRef.current = [];
+        const apiState = store.getState()[api.uploadApi.reducerPath];
+        const removeQueryResult = api.uploadApi.internalActions.removeQueryResult;
+        Object.keys(apiState?.queries ?? {}).forEach((cacheKey)=>{
+            if (!cacheKey.startsWith('getAssets(')) {
+                return;
+            }
+            let args;
+            try {
+                args = JSON.parse(cacheKey.slice('getAssets('.length, -1));
+            } catch  {
+                return;
+            }
+            if (args.folder === prevFolder) {
+                dispatch(removeQueryResult({
+                    queryCacheKey: cacheKey
+                }));
+            }
+        });
     }, [
         folder,
-        sort,
-        filtersKey
+        dispatch,
+        store
     ]);
-    // A search change resets pagination but keeps the previous results rendered
-    // until the new page 1 lands, which replaces them.
-    React.useEffect(()=>{
-        if (isSearchMountRef.current) {
-            isSearchMountRef.current = false;
-            return;
-        }
-        setPage(1);
-    }, [
-        search
+    // Until the new list's first page lands the accumulator still holds the
+    // previous folder. Reported as loading so the page shows a spinner instead
+    // of the outgoing folder's assets under the incoming folder's header.
+    const isChangingList = accumulated.listKey !== listKey;
+    const assets$1 = React.useMemo(()=>isChangingList ? [] : flattenPages(accumulated.pages), [
+        isChangingList,
+        accumulated.pages
     ]);
     // Deliberately the live value, not the stale-tolerant one below: paging must
     // never be driven by a total that belongs to the previous query.
-    const hasNextPage = pagination ? page < pagination.pageCount : false;
+    const hasNextPage = currentData ? page < currentData.pagination.pageCount : false;
     const isFetchingMore = isFetching && page > 1;
     const fetchNextPage = React.useCallback(()=>{
-        setPage((prev)=>prev + 1);
-    }, []);
+        setPageState((prev)=>({
+                queryKey,
+                page: (prev.queryKey === queryKey ? prev.page : 1) + 1
+            }));
+    }, [
+        queryKey
+    ]);
     if (!enabled) {
         return {
             assets: [],
+            // No list to keep fresh while disabled, so nothing to subscribe.
+            subscribers: null,
             pagination: undefined,
             isLoading: false,
             isFetchingMore: false,
@@ -97,10 +237,11 @@ const useInfiniteAssets = ({ folder = null, sort, search, filters, filtersKey =
     }
     return {
         assets: assets$1,
-        // Reported alongside the stale `assets` above so a consumer showing the total
-        // doesn't flash zero mid-transition.
-        pagination: pagination ?? lastPaginationRef.current,
-        isLoading,
+        subscribers,
+        // Falls back to the accumulated total so a consumer showing the count
+        // doesn't flash zero mid-transition, matching the possibly stale `assets`.
+        pagination: currentData?.pagination ?? accumulated.pagination,
+        isLoading: isLoading || isChangingList,
         isFetchingMore,
         hasNextPage,
         fetchNextPage,

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

@@ -1 +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, Pagination } from '../../../../../../shared/contracts/files';\n\nconst PAGE_SIZE = 20;\n\ninterface UseInfiniteAssetsOptions {\n  folder?: number | null;\n  sort?: string;\n  search?: string;\n  /** Extra `filters[$and]` entries for the files query. */\n  filters?: Record<string, unknown>[];\n  /**\n   * Stable fingerprint of `filters` — a change resets the accumulated pages\n   * (the array identity itself changes every render).\n   */\n  filtersKey?: string;\n  /** Structural switch: an `is [folder]`-only type badge means no file can match. */\n  enabled?: boolean;\n}\n\nconst useInfiniteAssets = ({\n  folder = null,\n  sort,\n  search,\n  filters,\n  filtersKey = '',\n  enabled = true,\n}: UseInfiniteAssetsOptions = {}) => {\n  const [page, setPage] = useState(1);\n  const lastResultsRef = useRef<File[]>([]);\n  const lastPaginationRef = useRef<Pagination | undefined>(undefined);\n  const isMountRef = useRef(true);\n  const isSearchMountRef = useRef(true);\n\n  const {\n    currentData: data,\n    isLoading,\n    isFetching,\n    error,\n  } = useGetAssetsQuery(\n    {\n      folder,\n      page,\n      pageSize: PAGE_SIZE,\n      sort,\n      search,\n      filters,\n    },\n    { skip: !enabled }\n  );\n\n  const pagination = data?.pagination;\n\n  if (pagination) {\n    lastPaginationRef.current = pagination;\n  }\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, filtersKey]);\n\n  // A search change resets pagination but keeps the previous results rendered\n  // until the new page 1 lands, which replaces them.\n  useEffect(() => {\n    if (isSearchMountRef.current) {\n      isSearchMountRef.current = false;\n\n      return;\n    }\n    setPage(1);\n  }, [search]);\n\n  // Deliberately the live value, not the stale-tolerant one below: paging must\n  // never be driven by a total that belongs to the previous query.\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  if (!enabled) {\n    return {\n      assets: [] as File[],\n      pagination: undefined,\n      isLoading: false,\n      isFetchingMore: false,\n      hasNextPage: false,\n      fetchNextPage,\n      error: undefined,\n    };\n  }\n\n  return {\n    assets,\n    // Reported alongside the stale `assets` above so a consumer showing the total\n    // doesn't flash zero mid-transition.\n    pagination: pagination ?? lastPaginationRef.current,\n    isLoading,\n    isFetchingMore,\n    hasNextPage,\n    fetchNextPage,\n    error,\n  };\n};\n\nexport { useInfiniteAssets };\nexport { PAGE_SIZE };\n"],"names":["PAGE_SIZE","useInfiniteAssets","folder","sort","search","filters","filtersKey","enabled","page","setPage","useState","lastResultsRef","useRef","lastPaginationRef","undefined","isMountRef","isSearchMountRef","currentData","data","isLoading","isFetching","error","useGetAssetsQuery","pageSize","skip","pagination","current","assets","useMemo","currentPageResults","results","expectedPrior","length","useEffect","hasNextPage","pageCount","isFetchingMore","fetchNextPage","useCallback","prev"],"mappings":"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"}
+{"version":3,"file":"useInfiniteAssets.js","sources":["../../../../../../admin/src/future/pages/Assets/hooks/useInfiniteAssets.ts"],"sourcesContent":["import { createElement, Fragment, useCallback, useEffect, useMemo, useRef, useState } from 'react';\n\nimport { useDispatch, useStore } from 'react-redux';\n\nimport { uploadApi } from '../../../services/api';\nimport { useGetAssetsQuery } from '../../../services/assets';\n\nimport type { File, Pagination } from '../../../../../../shared/contracts/files';\n\nconst PAGE_SIZE = 20;\n\ninterface UseInfiniteAssetsOptions {\n  folder?: number | null;\n  sort?: string;\n  search?: string;\n  /** Extra `filters[$and]` entries for the files query. */\n  filters?: Record<string, unknown>[];\n  /** Structural switch: an `is [folder]`-only type badge means no file can match. */\n  enabled?: boolean;\n}\n\ninterface QueryArgs {\n  folder: number | null;\n  sort?: string;\n  search?: string;\n  filters?: Record<string, unknown>[];\n}\n\n/**\n * Everything loaded for one query identity.\n *\n * `queryKey` lags the live key while a new query is in flight — that lag is\n * what keeps the previous results on screen across a search change.\n */\ninterface Accumulated {\n  queryKey: string;\n  listKey: string;\n  pages: Record<number, File[]>;\n  pagination?: Pagination;\n}\n\ninterface PageState {\n  queryKey: string;\n  page: number;\n}\n\ntype PageRefreshedHandler = (page: number, results: File[]) => void;\n\n/**\n * Concatenates the pages in ascending order, one entry per asset id.\n *\n * `Map.set` keeps the first insertion position but takes the latest value, so\n * an asset that moved between pages after a mutation holds its place and shows\n * fresh data instead of rendering twice under a duplicate key.\n */\nconst flattenPages = (pages: Record<number, File[]>): File[] => {\n  const byId = new Map<number, File>();\n\n  for (const page of Object.keys(pages)\n    .map(Number)\n    .sort((a, b) => a - b)) {\n    for (const asset of pages[page]) {\n      byId.set(asset.id, asset);\n    }\n  }\n\n  return [...byId.values()];\n};\n\n/**\n * Keeps one earlier page's `getAssets` query subscribed and reports its results\n * back up whenever they change.\n *\n * The hook itself only subscribes the current (latest) page. Without these, a\n * mutation invalidating `{Asset, LIST}` refetches that page alone and earlier\n * pages stay frozen — a rename or delete on an earlier page never reaches the\n * list until a folder/sort/search change. One subscriber per earlier\n * page keeps them all subscribed so the invalidation refetches the whole list.\n * Renders nothing; it exists only for the subscription + `onRefreshed` report.\n */\nconst PageSubscriber = ({\n  queryArgs,\n  page,\n  onRefreshed,\n}: {\n  queryArgs: QueryArgs;\n  page: number;\n  onRefreshed: PageRefreshedHandler;\n}) => {\n  const { currentData } = useGetAssetsQuery({ ...queryArgs, page, pageSize: PAGE_SIZE });\n  const results = currentData?.results;\n\n  useEffect(() => {\n    if (results) {\n      onRefreshed(page, results);\n    }\n    // `results` is a stable reference per cache entry, so this only re-reports\n    // when a refetch actually replaces the page's data. Reporting the same\n    // reference the accumulator already holds is a no-op (see `onRefreshed`).\n  }, [results, page, onRefreshed]);\n\n  return null;\n};\n\n/**\n * Infinite scroll over `/upload/files`, keeping one accumulated slot per page.\n *\n * The caller MUST render the returned `subscribers` node — that is what keeps\n * every loaded page subscribed, so `{Asset, LIST}` invalidations keep the whole\n * list consistent rather than only the current page.\n */\nconst useInfiniteAssets = ({\n  folder = null,\n  sort,\n  search,\n  filters,\n  enabled = true,\n}: UseInfiniteAssetsOptions = {}) => {\n  // Derived from the request args themselves, so a new filter can't reach the\n  // API without also invalidating what was accumulated under the old one.\n  const queryArgs: QueryArgs = { folder, sort, search, filters };\n  const queryKey = JSON.stringify(queryArgs);\n  // Identifies the list being viewed, ignoring the search term. Folder, sort\n  // and filter changes are single committed actions, so one clean reset per\n  // change is honest. Search is committed per keystroke on a 300ms debounce,\n  // and blanking the list on each one would strobe as the user types.\n  // The cost: through the search window the previous rows stay rendered and\n  // `hasNextPage` is false, so the list reads as complete until page 1 lands.\n  const listKey = JSON.stringify({ folder, sort, filters });\n\n  const [pageState, setPageState] = useState<PageState>({ queryKey, page: 1 });\n  const [accumulated, setAccumulated] = useState<Accumulated>({ queryKey, listKey, pages: {} });\n\n  // Derived rather than read straight from state: the render that discovers\n  // the key change still reaches the query below, and a list with no page 1\n  // must never be requested at page 2.\n  const page = pageState.queryKey === queryKey ? pageState.page : 1;\n\n  if (pageState.queryKey !== queryKey) {\n    setPageState({ queryKey, page: 1 });\n  }\n\n  const { currentData, isLoading, isFetching, error } = useGetAssetsQuery(\n    {\n      ...queryArgs,\n      page,\n      pageSize: PAGE_SIZE,\n    },\n    { skip: !enabled }\n  );\n\n  const isSameQuery = accumulated.queryKey === queryKey;\n\n  // `currentData` is only ever the payload for the args just passed, so it\n  // belongs to this key at this page — nothing to infer. Its reference is\n  // stable per cache entry, so this settles after one extra render.\n  if (currentData && (!isSameQuery || accumulated.pages[page] !== currentData.results)) {\n    setAccumulated(\n      isSameQuery\n        ? {\n            ...accumulated,\n            pages: { ...accumulated.pages, [page]: currentData.results },\n            pagination: currentData.pagination,\n          }\n        : {\n            queryKey,\n            listKey,\n            pages: { [page]: currentData.results },\n            pagination: currentData.pagination,\n          }\n    );\n  }\n\n  // Merges a refetched earlier page back into the accumulator. Ignores reports\n  // for a superseded query, and no-ops when the reference is unchanged so a\n  // subscriber re-reporting its already-stored page can't loop.\n  const handlePageRefreshed = useCallback<PageRefreshedHandler>(\n    (refreshedPage, results) => {\n      setAccumulated((prev) => {\n        if (prev.queryKey !== queryKey || prev.pages[refreshedPage] === results) {\n          return prev;\n        }\n\n        return { ...prev, pages: { ...prev.pages, [refreshedPage]: results } };\n      });\n    },\n    [queryKey]\n  );\n\n  // One subscriber per earlier page (the current page is already subscribed by\n  // the query above). Keyed by queryKey so a folder/sort/search change remounts\n  // them against the new args instead of reusing a stale cache entry.\n  // `createElement` rather than JSX so this stays a plain `.ts` hook file.\n  const subscribers = createElement(\n    Fragment,\n    null,\n    Array.from({ length: Math.max(0, page - 1) }, (_, index) => index + 1).map((earlierPage) =>\n      createElement(PageSubscriber, {\n        key: `${queryKey}:${earlierPage}`,\n        queryArgs,\n        page: earlierPage,\n        onRefreshed: handlePageRefreshed,\n      })\n    )\n  );\n\n  // Drop the left folder's cached `getAssets` pages when the folder changes.\n  //\n  // RTK Query 1.9.7 leaves a query's store subscription in place when its last\n  // subscriber unmounts while a refetch is still in flight — e.g. a delete\n  // invalidates `{Asset, LIST}`, every loaded page starts refetching, and the\n  // user navigates away before those settle. Those stale subscriptions make the\n  // next `{Asset, LIST}` invalidation (an upload in the new folder) refetch the\n  // *previous* folder's pages: one bogus `/upload/files` request per loaded\n  // page. There is no public per-entry unsubscribe, so evict the left folder's\n  // entries outright — returning reloads from page 1, which the accumulator\n  // already does on a list change.\n  const dispatch = useDispatch();\n  const store = useStore();\n  const prevFolderRef = useRef(folder);\n  useEffect(() => {\n    const prevFolder = prevFolderRef.current;\n    prevFolderRef.current = folder;\n    if (prevFolder === folder) {\n      return;\n    }\n\n    const apiState = (store.getState() as Record<string, { queries?: Record<string, unknown> }>)[\n      uploadApi.reducerPath\n    ];\n    const removeQueryResult = (\n      uploadApi as unknown as {\n        internalActions: {\n          removeQueryResult: (payload: { queryCacheKey: string }) => { type: string };\n        };\n      }\n    ).internalActions.removeQueryResult;\n\n    Object.keys(apiState?.queries ?? {}).forEach((cacheKey) => {\n      if (!cacheKey.startsWith('getAssets(')) {\n        return;\n      }\n      let args: { folder?: number | null };\n      try {\n        args = JSON.parse(cacheKey.slice('getAssets('.length, -1));\n      } catch {\n        return;\n      }\n      if (args.folder === prevFolder) {\n        dispatch(removeQueryResult({ queryCacheKey: cacheKey }));\n      }\n    });\n  }, [folder, dispatch, store]);\n\n  // Until the new list's first page lands the accumulator still holds the\n  // previous folder. Reported as loading so the page shows a spinner instead\n  // of the outgoing folder's assets under the incoming folder's header.\n  const isChangingList = accumulated.listKey !== listKey;\n\n  const assets = useMemo(\n    () => (isChangingList ? [] : flattenPages(accumulated.pages)),\n    [isChangingList, accumulated.pages]\n  );\n\n  // Deliberately the live value, not the stale-tolerant one below: paging must\n  // never be driven by a total that belongs to the previous query.\n  const hasNextPage = currentData ? page < currentData.pagination.pageCount : false;\n  const isFetchingMore = isFetching && page > 1;\n\n  const fetchNextPage = useCallback(() => {\n    setPageState((prev) => ({\n      queryKey,\n      page: (prev.queryKey === queryKey ? prev.page : 1) + 1,\n    }));\n  }, [queryKey]);\n\n  if (!enabled) {\n    return {\n      assets: [] as File[],\n      // No list to keep fresh while disabled, so nothing to subscribe.\n      subscribers: null,\n      pagination: undefined,\n      isLoading: false,\n      isFetchingMore: false,\n      hasNextPage: false,\n      fetchNextPage,\n      error: undefined,\n    };\n  }\n\n  return {\n    assets,\n    subscribers,\n    // Falls back to the accumulated total so a consumer showing the count\n    // doesn't flash zero mid-transition, matching the possibly stale `assets`.\n    pagination: currentData?.pagination ?? accumulated.pagination,\n    isLoading: isLoading || isChangingList,\n    isFetchingMore,\n    hasNextPage,\n    fetchNextPage,\n    error,\n  };\n};\n\nexport { useInfiniteAssets };\nexport { PAGE_SIZE };\n"],"names":["PAGE_SIZE","flattenPages","pages","byId","Map","page","Object","keys","map","Number","sort","a","b","asset","set","id","values","PageSubscriber","queryArgs","onRefreshed","currentData","useGetAssetsQuery","pageSize","results","useEffect","useInfiniteAssets","folder","search","filters","enabled","queryKey","JSON","stringify","listKey","pageState","setPageState","useState","accumulated","setAccumulated","isLoading","isFetching","error","skip","isSameQuery","pagination","handlePageRefreshed","useCallback","refreshedPage","prev","subscribers","createElement","Fragment","Array","from","length","Math","max","_","index","earlierPage","key","dispatch","useDispatch","store","useStore","prevFolderRef","useRef","prevFolder","current","apiState","getState","uploadApi","reducerPath","removeQueryResult","internalActions","queries","forEach","cacheKey","startsWith","args","parse","slice","queryCacheKey","isChangingList","assets","useMemo","hasNextPage","pageCount","isFetchingMore","fetchNextPage","undefined"],"mappings":"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"}