@strapi/admin 5.52.2 → 5.53.0

package/dist/admin/admin/src/hooks/useQueryParams.js

@@ -43,7 +43,12 @@ const useQueryParams = (initialParams)=>{
                 ...nextParams
             };
         }
-        navigate({
+        /**
+       * TODO V6: Encoding should be enabled in this step, via `{ encodeValuesOnly: true }`
+       * So the rest of the app doesn't have to worry about it,
+       * It's considered a breaking change because callers currently encode values themselves,
+       * including the user's custom code, and would end up double-encoding them.
+       */ navigate({
             search: qs.stringify(nextQuery, {
                 encode: false
             })
@@ -62,6 +67,35 @@ const useQueryParams = (initialParams)=>{
         setQuery
     ];
 };
+/**
+ * These functions are used to encode query values when writing them to the URL.
+ * As stated above, it should be handled by `useQueryParams` instead, but that would be a breaking change.
+ */ const deepEncodeQueryValues = (value)=>{
+    if (typeof value === 'string') {
+        return encodeURIComponent(value);
+    }
+    if (Array.isArray(value)) {
+        return value.map(deepEncodeQueryValues);
+    }
+    if (value !== null && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value).map(([key, entry])=>[
+                key,
+                deepEncodeQueryValues(entry)
+            ]));
+    }
+    return value;
+};
+const withEncodedUserParams = (query, nextParams)=>({
+        ...query.filters === undefined ? {} : {
+            filters: deepEncodeQueryValues(query.filters)
+        },
+        ...query._q === undefined ? {} : {
+            _q: deepEncodeQueryValues(query._q)
+        },
+        ...nextParams
+    });
 
+exports.deepEncodeQueryValues = deepEncodeQueryValues;
 exports.useQueryParams = useQueryParams;
+exports.withEncodedUserParams = withEncodedUserParams;
 //# sourceMappingURL=useQueryParams.js.map

package/dist/admin/admin/src/hooks/useQueryParams.js.map

@@ -1 +1 @@
-{"version":3,"file":"useQueryParams.js","sources":["../../../../../admin/src/hooks/useQueryParams.ts"],"sourcesContent":["import { useCallback, useMemo } from 'react';\n\nimport { parse, stringify } from 'qs';\nimport { useNavigate, useLocation } from 'react-router-dom';\n\ntype QueryParams = Record<string, unknown>;\n\nconst useSearch = () => {\n  const { search } = useLocation();\n\n  return useMemo(() => search, [search]);\n};\n\nconst useQueryParams = <TQuery extends object = QueryParams>(initialParams?: TQuery) => {\n  const search = useSearch();\n  const navigate = useNavigate();\n\n  const query = useMemo(() => {\n    // TODO: investigate why sometimes we're getting the search with a leading `?` and sometimes not.\n    const searchQuery = search.startsWith('?') ? search.slice(1) : search;\n    if (!search && initialParams) {\n      return initialParams;\n    }\n\n    return { ...initialParams, ...parse(searchQuery) } as TQuery;\n  }, [search, initialParams]);\n\n  const setQuery = useCallback(\n    (nextParams: TQuery, method: 'push' | 'remove' = 'push', replace = false) => {\n      let nextQuery: Partial<TQuery> = { ...query };\n\n      if (method === 'remove') {\n        Object.keys(nextParams).forEach((key) => {\n          if (Object.prototype.hasOwnProperty.call(nextQuery, key)) {\n            delete nextQuery[key as keyof TQuery];\n          }\n        });\n      } else {\n        nextQuery = { ...query, ...nextParams };\n      }\n\n      navigate({ search: stringify(nextQuery, { encode: false }) }, { replace });\n    },\n    [navigate, query]\n  );\n\n  return [{ query, rawQuery: search }, setQuery] as const;\n};\n\nexport { useQueryParams };\n"],"names":["useSearch","search","useLocation","useMemo","useQueryParams","initialParams","navigate","useNavigate","query","searchQuery","startsWith","slice","parse","setQuery","useCallback","nextParams","method","replace","nextQuery","Object","keys","forEach","key","prototype","hasOwnProperty","call","stringify","encode","rawQuery"],"mappings":";;;;;;AAOA,MAAMA,SAAAA,GAAY,IAAA;IAChB,MAAM,EAAEC,MAAM,EAAE,GAAGC,0BAAAA,EAAAA;IAEnB,OAAOC,aAAAA,CAAQ,IAAMF,MAAAA,EAAQ;AAACA,QAAAA;AAAO,KAAA,CAAA;AACvC,CAAA;AAEA,MAAMG,iBAAiB,CAAsCC,aAAAA,GAAAA;AAC3D,IAAA,MAAMJ,MAAAA,GAASD,SAAAA,EAAAA;AACf,IAAA,MAAMM,QAAAA,GAAWC,0BAAAA,EAAAA;AAEjB,IAAA,MAAMC,QAAQL,aAAAA,CAAQ,IAAA;;QAEpB,MAAMM,WAAAA,GAAcR,OAAOS,UAAU,CAAC,OAAOT,MAAAA,CAAOU,KAAK,CAAC,CAAA,CAAA,GAAKV,MAAAA;QAC/D,IAAI,CAACA,UAAUI,aAAAA,EAAe;YAC5B,OAAOA,aAAAA;AACT,QAAA;QAEA,OAAO;AAAE,YAAA,GAAGA,aAAa;AAAE,YAAA,GAAGO,SAAMH,WAAAA;AAAa,SAAA;IACnD,CAAA,EAAG;AAACR,QAAAA,MAAAA;AAAQI,QAAAA;AAAc,KAAA,CAAA;IAE1B,MAAMQ,QAAAA,GAAWC,kBACf,CAACC,UAAAA,EAAoBC,SAA4B,MAAM,EAAEC,UAAU,KAAK,GAAA;AACtE,QAAA,IAAIC,SAAAA,GAA6B;AAAE,YAAA,GAAGV;AAAM,SAAA;AAE5C,QAAA,IAAIQ,WAAW,QAAA,EAAU;AACvBG,YAAAA,MAAAA,CAAOC,IAAI,CAACL,UAAAA,CAAAA,CAAYM,OAAO,CAAC,CAACC,GAAAA,GAAAA;gBAC/B,IAAIH,MAAAA,CAAOI,SAAS,CAACC,cAAc,CAACC,IAAI,CAACP,WAAWI,GAAAA,CAAAA,EAAM;oBACxD,OAAOJ,SAAS,CAACI,GAAAA,CAAoB;AACvC,gBAAA;AACF,YAAA,CAAA,CAAA;QACF,CAAA,MAAO;YACLJ,SAAAA,GAAY;AAAE,gBAAA,GAAGV,KAAK;AAAE,gBAAA,GAAGO;AAAW,aAAA;AACxC,QAAA;QAEAT,QAAAA,CAAS;AAAEL,YAAAA,MAAAA,EAAQyB,aAAUR,SAAAA,EAAW;gBAAES,MAAAA,EAAQ;AAAM,aAAA;SAAG,EAAG;AAAEV,YAAAA;AAAQ,SAAA,CAAA;IAC1E,CAAA,EACA;AAACX,QAAAA,QAAAA;AAAUE,QAAAA;AAAM,KAAA,CAAA;IAGnB,OAAO;AAAC,QAAA;AAAEA,YAAAA,KAAAA;YAAOoB,QAAAA,EAAU3B;AAAO,SAAA;AAAGY,QAAAA;AAAS,KAAA;AAChD;;;;"}
+{"version":3,"file":"useQueryParams.js","sources":["../../../../../admin/src/hooks/useQueryParams.ts"],"sourcesContent":["import { useCallback, useMemo } from 'react';\n\nimport { parse, stringify } from 'qs';\nimport { useNavigate, useLocation } from 'react-router-dom';\n\ntype QueryParams = Record<string, unknown>;\n\nconst useSearch = () => {\n  const { search } = useLocation();\n\n  return useMemo(() => search, [search]);\n};\n\nconst useQueryParams = <TQuery extends object = QueryParams>(initialParams?: TQuery) => {\n  const search = useSearch();\n  const navigate = useNavigate();\n\n  const query = useMemo(() => {\n    // TODO: investigate why sometimes we're getting the search with a leading `?` and sometimes not.\n    const searchQuery = search.startsWith('?') ? search.slice(1) : search;\n    if (!search && initialParams) {\n      return initialParams;\n    }\n\n    return { ...initialParams, ...parse(searchQuery) } as TQuery;\n  }, [search, initialParams]);\n\n  const setQuery = useCallback(\n    (nextParams: TQuery, method: 'push' | 'remove' = 'push', replace = false) => {\n      let nextQuery: Partial<TQuery> = { ...query };\n\n      if (method === 'remove') {\n        Object.keys(nextParams).forEach((key) => {\n          if (Object.prototype.hasOwnProperty.call(nextQuery, key)) {\n            delete nextQuery[key as keyof TQuery];\n          }\n        });\n      } else {\n        nextQuery = { ...query, ...nextParams };\n      }\n\n      /**\n       * TODO V6: Encoding should be enabled in this step, via `{ encodeValuesOnly: true }`\n       * So the rest of the app doesn't have to worry about it,\n       * It's considered a breaking change because callers currently encode values themselves,\n       * including the user's custom code, and would end up double-encoding them.\n       */\n      navigate({ search: stringify(nextQuery, { encode: false }) }, { replace });\n    },\n    [navigate, query]\n  );\n\n  return [{ query, rawQuery: search }, setQuery] as const;\n};\n\n/**\n * These functions are used to encode query values when writing them to the URL.\n * As stated above, it should be handled by `useQueryParams` instead, but that would be a breaking change.\n */\n\nconst deepEncodeQueryValues = <T>(value: T): T => {\n  if (typeof value === 'string') {\n    return encodeURIComponent(value) as T;\n  }\n\n  if (Array.isArray(value)) {\n    return value.map(deepEncodeQueryValues) as T;\n  }\n\n  if (value !== null && typeof value === 'object') {\n    return Object.fromEntries(\n      Object.entries(value).map(([key, entry]) => [key, deepEncodeQueryValues(entry)])\n    ) as T;\n  }\n\n  return value;\n};\n\nconst withEncodedUserParams = <\n  T extends object,\n  TQuery extends { filters?: unknown; _q?: unknown },\n>(\n  query: TQuery,\n  nextParams: T\n): T & { filters?: TQuery['filters']; _q?: TQuery['_q'] } => ({\n  ...(query.filters === undefined ? {} : { filters: deepEncodeQueryValues(query.filters) }),\n  ...(query._q === undefined ? {} : { _q: deepEncodeQueryValues(query._q) }),\n  ...nextParams,\n});\n\nexport { useQueryParams, deepEncodeQueryValues, withEncodedUserParams };\n"],"names":["useSearch","search","useLocation","useMemo","useQueryParams","initialParams","navigate","useNavigate","query","searchQuery","startsWith","slice","parse","setQuery","useCallback","nextParams","method","replace","nextQuery","Object","keys","forEach","key","prototype","hasOwnProperty","call","stringify","encode","rawQuery","deepEncodeQueryValues","value","encodeURIComponent","Array","isArray","map","fromEntries","entries","entry","withEncodedUserParams","filters","undefined","_q"],"mappings":";;;;;;AAOA,MAAMA,SAAAA,GAAY,IAAA;IAChB,MAAM,EAAEC,MAAM,EAAE,GAAGC,0BAAAA,EAAAA;IAEnB,OAAOC,aAAAA,CAAQ,IAAMF,MAAAA,EAAQ;AAACA,QAAAA;AAAO,KAAA,CAAA;AACvC,CAAA;AAEA,MAAMG,iBAAiB,CAAsCC,aAAAA,GAAAA;AAC3D,IAAA,MAAMJ,MAAAA,GAASD,SAAAA,EAAAA;AACf,IAAA,MAAMM,QAAAA,GAAWC,0BAAAA,EAAAA;AAEjB,IAAA,MAAMC,QAAQL,aAAAA,CAAQ,IAAA;;QAEpB,MAAMM,WAAAA,GAAcR,OAAOS,UAAU,CAAC,OAAOT,MAAAA,CAAOU,KAAK,CAAC,CAAA,CAAA,GAAKV,MAAAA;QAC/D,IAAI,CAACA,UAAUI,aAAAA,EAAe;YAC5B,OAAOA,aAAAA;AACT,QAAA;QAEA,OAAO;AAAE,YAAA,GAAGA,aAAa;AAAE,YAAA,GAAGO,SAAMH,WAAAA;AAAa,SAAA;IACnD,CAAA,EAAG;AAACR,QAAAA,MAAAA;AAAQI,QAAAA;AAAc,KAAA,CAAA;IAE1B,MAAMQ,QAAAA,GAAWC,kBACf,CAACC,UAAAA,EAAoBC,SAA4B,MAAM,EAAEC,UAAU,KAAK,GAAA;AACtE,QAAA,IAAIC,SAAAA,GAA6B;AAAE,YAAA,GAAGV;AAAM,SAAA;AAE5C,QAAA,IAAIQ,WAAW,QAAA,EAAU;AACvBG,YAAAA,MAAAA,CAAOC,IAAI,CAACL,UAAAA,CAAAA,CAAYM,OAAO,CAAC,CAACC,GAAAA,GAAAA;gBAC/B,IAAIH,MAAAA,CAAOI,SAAS,CAACC,cAAc,CAACC,IAAI,CAACP,WAAWI,GAAAA,CAAAA,EAAM;oBACxD,OAAOJ,SAAS,CAACI,GAAAA,CAAoB;AACvC,gBAAA;AACF,YAAA,CAAA,CAAA;QACF,CAAA,MAAO;YACLJ,SAAAA,GAAY;AAAE,gBAAA,GAAGV,KAAK;AAAE,gBAAA,GAAGO;AAAW,aAAA;AACxC,QAAA;AAEA;;;;;AAKC,UACDT,QAAAA,CAAS;AAAEL,YAAAA,MAAAA,EAAQyB,aAAUR,SAAAA,EAAW;gBAAES,MAAAA,EAAQ;AAAM,aAAA;SAAG,EAAG;AAAEV,YAAAA;AAAQ,SAAA,CAAA;IAC1E,CAAA,EACA;AAACX,QAAAA,QAAAA;AAAUE,QAAAA;AAAM,KAAA,CAAA;IAGnB,OAAO;AAAC,QAAA;AAAEA,YAAAA,KAAAA;YAAOoB,QAAAA,EAAU3B;AAAO,SAAA;AAAGY,QAAAA;AAAS,KAAA;AAChD;AAEA;;;IAKA,MAAMgB,wBAAwB,CAAIC,KAAAA,GAAAA;IAChC,IAAI,OAAOA,UAAU,QAAA,EAAU;AAC7B,QAAA,OAAOC,kBAAAA,CAAmBD,KAAAA,CAAAA;AAC5B,IAAA;IAEA,IAAIE,KAAAA,CAAMC,OAAO,CAACH,KAAAA,CAAAA,EAAQ;QACxB,OAAOA,KAAAA,CAAMI,GAAG,CAACL,qBAAAA,CAAAA;AACnB,IAAA;AAEA,IAAA,IAAIC,KAAAA,KAAU,IAAA,IAAQ,OAAOA,KAAAA,KAAU,QAAA,EAAU;AAC/C,QAAA,OAAOX,MAAAA,CAAOgB,WAAW,CACvBhB,MAAAA,CAAOiB,OAAO,CAACN,KAAAA,CAAAA,CAAOI,GAAG,CAAC,CAAC,CAACZ,GAAAA,EAAKe,MAAM,GAAK;AAACf,gBAAAA,GAAAA;gBAAKO,qBAAAA,CAAsBQ,KAAAA;AAAO,aAAA,CAAA,CAAA;AAEnF,IAAA;IAEA,OAAOP,KAAAA;AACT;AAEA,MAAMQ,qBAAAA,GAAwB,CAI5B9B,KAAAA,EACAO,UAAAA,IAC4D;AAC5D,QAAA,GAAIP,KAAAA,CAAM+B,OAAO,KAAKC,SAAAA,GAAY,EAAC,GAAI;YAAED,OAAAA,EAASV,qBAAAA,CAAsBrB,MAAM+B,OAAO;SAAG;AACxF,QAAA,GAAI/B,KAAAA,CAAMiC,EAAE,KAAKD,SAAAA,GAAY,EAAC,GAAI;YAAEC,EAAAA,EAAIZ,qBAAAA,CAAsBrB,MAAMiC,EAAE;SAAG;AACzE,QAAA,GAAG1B;KACL;;;;;;"}

package/dist/admin/admin/src/hooks/useQueryParams.mjs

@@ -41,7 +41,12 @@ const useQueryParams = (initialParams)=>{
                 ...nextParams
             };
         }
-        navigate({
+        /**
+       * TODO V6: Encoding should be enabled in this step, via `{ encodeValuesOnly: true }`
+       * So the rest of the app doesn't have to worry about it,
+       * It's considered a breaking change because callers currently encode values themselves,
+       * including the user's custom code, and would end up double-encoding them.
+       */ navigate({
             search: stringify(nextQuery, {
                 encode: false
             })
@@ -60,6 +65,33 @@ const useQueryParams = (initialParams)=>{
         setQuery
     ];
 };
+/**
+ * These functions are used to encode query values when writing them to the URL.
+ * As stated above, it should be handled by `useQueryParams` instead, but that would be a breaking change.
+ */ const deepEncodeQueryValues = (value)=>{
+    if (typeof value === 'string') {
+        return encodeURIComponent(value);
+    }
+    if (Array.isArray(value)) {
+        return value.map(deepEncodeQueryValues);
+    }
+    if (value !== null && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value).map(([key, entry])=>[
+                key,
+                deepEncodeQueryValues(entry)
+            ]));
+    }
+    return value;
+};
+const withEncodedUserParams = (query, nextParams)=>({
+        ...query.filters === undefined ? {} : {
+            filters: deepEncodeQueryValues(query.filters)
+        },
+        ...query._q === undefined ? {} : {
+            _q: deepEncodeQueryValues(query._q)
+        },
+        ...nextParams
+    });
 
-export { useQueryParams };
+export { deepEncodeQueryValues, useQueryParams, withEncodedUserParams };
 //# sourceMappingURL=useQueryParams.mjs.map

package/dist/admin/admin/src/hooks/useQueryParams.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"useQueryParams.mjs","sources":["../../../../../admin/src/hooks/useQueryParams.ts"],"sourcesContent":["import { useCallback, useMemo } from 'react';\n\nimport { parse, stringify } from 'qs';\nimport { useNavigate, useLocation } from 'react-router-dom';\n\ntype QueryParams = Record<string, unknown>;\n\nconst useSearch = () => {\n  const { search } = useLocation();\n\n  return useMemo(() => search, [search]);\n};\n\nconst useQueryParams = <TQuery extends object = QueryParams>(initialParams?: TQuery) => {\n  const search = useSearch();\n  const navigate = useNavigate();\n\n  const query = useMemo(() => {\n    // TODO: investigate why sometimes we're getting the search with a leading `?` and sometimes not.\n    const searchQuery = search.startsWith('?') ? search.slice(1) : search;\n    if (!search && initialParams) {\n      return initialParams;\n    }\n\n    return { ...initialParams, ...parse(searchQuery) } as TQuery;\n  }, [search, initialParams]);\n\n  const setQuery = useCallback(\n    (nextParams: TQuery, method: 'push' | 'remove' = 'push', replace = false) => {\n      let nextQuery: Partial<TQuery> = { ...query };\n\n      if (method === 'remove') {\n        Object.keys(nextParams).forEach((key) => {\n          if (Object.prototype.hasOwnProperty.call(nextQuery, key)) {\n            delete nextQuery[key as keyof TQuery];\n          }\n        });\n      } else {\n        nextQuery = { ...query, ...nextParams };\n      }\n\n      navigate({ search: stringify(nextQuery, { encode: false }) }, { replace });\n    },\n    [navigate, query]\n  );\n\n  return [{ query, rawQuery: search }, setQuery] as const;\n};\n\nexport { useQueryParams };\n"],"names":["useSearch","search","useLocation","useMemo","useQueryParams","initialParams","navigate","useNavigate","query","searchQuery","startsWith","slice","parse","setQuery","useCallback","nextParams","method","replace","nextQuery","Object","keys","forEach","key","prototype","hasOwnProperty","call","stringify","encode","rawQuery"],"mappings":";;;;AAOA,MAAMA,SAAAA,GAAY,IAAA;IAChB,MAAM,EAAEC,MAAM,EAAE,GAAGC,WAAAA,EAAAA;IAEnB,OAAOC,OAAAA,CAAQ,IAAMF,MAAAA,EAAQ;AAACA,QAAAA;AAAO,KAAA,CAAA;AACvC,CAAA;AAEA,MAAMG,iBAAiB,CAAsCC,aAAAA,GAAAA;AAC3D,IAAA,MAAMJ,MAAAA,GAASD,SAAAA,EAAAA;AACf,IAAA,MAAMM,QAAAA,GAAWC,WAAAA,EAAAA;AAEjB,IAAA,MAAMC,QAAQL,OAAAA,CAAQ,IAAA;;QAEpB,MAAMM,WAAAA,GAAcR,OAAOS,UAAU,CAAC,OAAOT,MAAAA,CAAOU,KAAK,CAAC,CAAA,CAAA,GAAKV,MAAAA;QAC/D,IAAI,CAACA,UAAUI,aAAAA,EAAe;YAC5B,OAAOA,aAAAA;AACT,QAAA;QAEA,OAAO;AAAE,YAAA,GAAGA,aAAa;AAAE,YAAA,GAAGO,MAAMH,WAAAA;AAAa,SAAA;IACnD,CAAA,EAAG;AAACR,QAAAA,MAAAA;AAAQI,QAAAA;AAAc,KAAA,CAAA;IAE1B,MAAMQ,QAAAA,GAAWC,YACf,CAACC,UAAAA,EAAoBC,SAA4B,MAAM,EAAEC,UAAU,KAAK,GAAA;AACtE,QAAA,IAAIC,SAAAA,GAA6B;AAAE,YAAA,GAAGV;AAAM,SAAA;AAE5C,QAAA,IAAIQ,WAAW,QAAA,EAAU;AACvBG,YAAAA,MAAAA,CAAOC,IAAI,CAACL,UAAAA,CAAAA,CAAYM,OAAO,CAAC,CAACC,GAAAA,GAAAA;gBAC/B,IAAIH,MAAAA,CAAOI,SAAS,CAACC,cAAc,CAACC,IAAI,CAACP,WAAWI,GAAAA,CAAAA,EAAM;oBACxD,OAAOJ,SAAS,CAACI,GAAAA,CAAoB;AACvC,gBAAA;AACF,YAAA,CAAA,CAAA;QACF,CAAA,MAAO;YACLJ,SAAAA,GAAY;AAAE,gBAAA,GAAGV,KAAK;AAAE,gBAAA,GAAGO;AAAW,aAAA;AACxC,QAAA;QAEAT,QAAAA,CAAS;AAAEL,YAAAA,MAAAA,EAAQyB,UAAUR,SAAAA,EAAW;gBAAES,MAAAA,EAAQ;AAAM,aAAA;SAAG,EAAG;AAAEV,YAAAA;AAAQ,SAAA,CAAA;IAC1E,CAAA,EACA;AAACX,QAAAA,QAAAA;AAAUE,QAAAA;AAAM,KAAA,CAAA;IAGnB,OAAO;AAAC,QAAA;AAAEA,YAAAA,KAAAA;YAAOoB,QAAAA,EAAU3B;AAAO,SAAA;AAAGY,QAAAA;AAAS,KAAA;AAChD;;;;"}
+{"version":3,"file":"useQueryParams.mjs","sources":["../../../../../admin/src/hooks/useQueryParams.ts"],"sourcesContent":["import { useCallback, useMemo } from 'react';\n\nimport { parse, stringify } from 'qs';\nimport { useNavigate, useLocation } from 'react-router-dom';\n\ntype QueryParams = Record<string, unknown>;\n\nconst useSearch = () => {\n  const { search } = useLocation();\n\n  return useMemo(() => search, [search]);\n};\n\nconst useQueryParams = <TQuery extends object = QueryParams>(initialParams?: TQuery) => {\n  const search = useSearch();\n  const navigate = useNavigate();\n\n  const query = useMemo(() => {\n    // TODO: investigate why sometimes we're getting the search with a leading `?` and sometimes not.\n    const searchQuery = search.startsWith('?') ? search.slice(1) : search;\n    if (!search && initialParams) {\n      return initialParams;\n    }\n\n    return { ...initialParams, ...parse(searchQuery) } as TQuery;\n  }, [search, initialParams]);\n\n  const setQuery = useCallback(\n    (nextParams: TQuery, method: 'push' | 'remove' = 'push', replace = false) => {\n      let nextQuery: Partial<TQuery> = { ...query };\n\n      if (method === 'remove') {\n        Object.keys(nextParams).forEach((key) => {\n          if (Object.prototype.hasOwnProperty.call(nextQuery, key)) {\n            delete nextQuery[key as keyof TQuery];\n          }\n        });\n      } else {\n        nextQuery = { ...query, ...nextParams };\n      }\n\n      /**\n       * TODO V6: Encoding should be enabled in this step, via `{ encodeValuesOnly: true }`\n       * So the rest of the app doesn't have to worry about it,\n       * It's considered a breaking change because callers currently encode values themselves,\n       * including the user's custom code, and would end up double-encoding them.\n       */\n      navigate({ search: stringify(nextQuery, { encode: false }) }, { replace });\n    },\n    [navigate, query]\n  );\n\n  return [{ query, rawQuery: search }, setQuery] as const;\n};\n\n/**\n * These functions are used to encode query values when writing them to the URL.\n * As stated above, it should be handled by `useQueryParams` instead, but that would be a breaking change.\n */\n\nconst deepEncodeQueryValues = <T>(value: T): T => {\n  if (typeof value === 'string') {\n    return encodeURIComponent(value) as T;\n  }\n\n  if (Array.isArray(value)) {\n    return value.map(deepEncodeQueryValues) as T;\n  }\n\n  if (value !== null && typeof value === 'object') {\n    return Object.fromEntries(\n      Object.entries(value).map(([key, entry]) => [key, deepEncodeQueryValues(entry)])\n    ) as T;\n  }\n\n  return value;\n};\n\nconst withEncodedUserParams = <\n  T extends object,\n  TQuery extends { filters?: unknown; _q?: unknown },\n>(\n  query: TQuery,\n  nextParams: T\n): T & { filters?: TQuery['filters']; _q?: TQuery['_q'] } => ({\n  ...(query.filters === undefined ? {} : { filters: deepEncodeQueryValues(query.filters) }),\n  ...(query._q === undefined ? {} : { _q: deepEncodeQueryValues(query._q) }),\n  ...nextParams,\n});\n\nexport { useQueryParams, deepEncodeQueryValues, withEncodedUserParams };\n"],"names":["useSearch","search","useLocation","useMemo","useQueryParams","initialParams","navigate","useNavigate","query","searchQuery","startsWith","slice","parse","setQuery","useCallback","nextParams","method","replace","nextQuery","Object","keys","forEach","key","prototype","hasOwnProperty","call","stringify","encode","rawQuery","deepEncodeQueryValues","value","encodeURIComponent","Array","isArray","map","fromEntries","entries","entry","withEncodedUserParams","filters","undefined","_q"],"mappings":"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"}

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

@@ -184,6 +184,7 @@ var en = {
     "Settings.permissions.auditLogs.action": "Action",
     "Settings.permissions.auditLogs.admin.auth.success": "Admin login",
     "Settings.permissions.auditLogs.admin.logout": "Admin logout",
+    "Settings.permissions.auditLogs.audit-log.export": "Export audit logs",
     "Settings.permissions.auditLogs.component.create": "Create component",
     "Settings.permissions.auditLogs.component.delete": "Delete component",
     "Settings.permissions.auditLogs.component.update": "Update component",
@@ -198,6 +199,15 @@ var en = {
     "Settings.permissions.auditLogs.entry.unpublish": "Unpublish entry{model, select, undefined {} other { ({model})}}",
     "Settings.permissions.auditLogs.entry.update": "Update entry{model, select, undefined {} other { ({model})}}",
     "Settings.permissions.auditLogs.filters.combobox.aria-label": "Search and select an option to filter",
+    "Settings.permissions.auditLogs.listview.export": "Export as CSV",
+    "Settings.permissions.auditLogs.listview.export.error": "The export failed. Please try again.",
+    "Settings.permissions.auditLogs.listview.export.error.forbidden": "You don't have the permissions to export audit logs.",
+    "Settings.permissions.auditLogs.listview.export.error.tooLarge": "Table too large to export. Please add filters and try again.",
+    "Settings.permissions.auditLogs.listview.export.leave": "Are you sure you want to leave? Your ongoing export will be canceled.",
+    "Settings.permissions.auditLogs.listview.export.progress.caption": "Preparing your export - {fetched, number} out of {total, plural, one {# event} other {# events}}",
+    "Settings.permissions.auditLogs.listview.export.progress.title": "Exporting audit logs",
+    "Settings.permissions.auditLogs.listview.export.ready.download": "Download CSV",
+    "Settings.permissions.auditLogs.listview.export.ready.title": "Export ready",
     "Settings.permissions.auditLogs.listview.header.subtitle": "Logs of all the activities that happened in your environment",
     "Settings.permissions.auditLogs.not-available": "Audit Logs is only available as part of a paid plan. Upgrade to get a searchable and filterable display of all activities.",
     "Settings.permissions.auditLogs.media.create": "Create media",
@@ -206,6 +216,14 @@ var en = {
     "Settings.permissions.auditLogs.payload": "Payload",
     "Settings.permissions.auditLogs.permission.create": "Create permission",
     "Settings.permissions.auditLogs.permission.delete": "Delete permission",
+    "Settings.permissions.auditLogs.release.create": "Create release",
+    "Settings.permissions.auditLogs.release.update": "Update release",
+    "Settings.permissions.auditLogs.release.delete": "Delete release",
+    "Settings.permissions.auditLogs.release.trigger": "Trigger release",
+    "Settings.permissions.auditLogs.release.entry.add": "Add entry to release",
+    "Settings.permissions.auditLogs.release.entry.update": "Change entry on release",
+    "Settings.permissions.auditLogs.release.entry.remove": "Remove entry from release",
+    "Settings.permissions.auditLogs.release.settings.update": "Update release settings",
     "Settings.permissions.auditLogs.permission.update": "Update permission",
     "Settings.permissions.auditLogs.role.create": "Create role",
     "Settings.permissions.auditLogs.role.delete": "Delete role",

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

@@ -1 +1 @@
-{"version":3,"file":"en.json.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"en.json.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/admin/admin/src/translations/en.json.mjs

@@ -180,6 +180,7 @@ var en = {
     "Settings.permissions.auditLogs.action": "Action",
     "Settings.permissions.auditLogs.admin.auth.success": "Admin login",
     "Settings.permissions.auditLogs.admin.logout": "Admin logout",
+    "Settings.permissions.auditLogs.audit-log.export": "Export audit logs",
     "Settings.permissions.auditLogs.component.create": "Create component",
     "Settings.permissions.auditLogs.component.delete": "Delete component",
     "Settings.permissions.auditLogs.component.update": "Update component",
@@ -194,6 +195,15 @@ var en = {
     "Settings.permissions.auditLogs.entry.unpublish": "Unpublish entry{model, select, undefined {} other { ({model})}}",
     "Settings.permissions.auditLogs.entry.update": "Update entry{model, select, undefined {} other { ({model})}}",
     "Settings.permissions.auditLogs.filters.combobox.aria-label": "Search and select an option to filter",
+    "Settings.permissions.auditLogs.listview.export": "Export as CSV",
+    "Settings.permissions.auditLogs.listview.export.error": "The export failed. Please try again.",
+    "Settings.permissions.auditLogs.listview.export.error.forbidden": "You don't have the permissions to export audit logs.",
+    "Settings.permissions.auditLogs.listview.export.error.tooLarge": "Table too large to export. Please add filters and try again.",
+    "Settings.permissions.auditLogs.listview.export.leave": "Are you sure you want to leave? Your ongoing export will be canceled.",
+    "Settings.permissions.auditLogs.listview.export.progress.caption": "Preparing your export - {fetched, number} out of {total, plural, one {# event} other {# events}}",
+    "Settings.permissions.auditLogs.listview.export.progress.title": "Exporting audit logs",
+    "Settings.permissions.auditLogs.listview.export.ready.download": "Download CSV",
+    "Settings.permissions.auditLogs.listview.export.ready.title": "Export ready",
     "Settings.permissions.auditLogs.listview.header.subtitle": "Logs of all the activities that happened in your environment",
     "Settings.permissions.auditLogs.not-available": "Audit Logs is only available as part of a paid plan. Upgrade to get a searchable and filterable display of all activities.",
     "Settings.permissions.auditLogs.media.create": "Create media",
@@ -202,6 +212,14 @@ var en = {
     "Settings.permissions.auditLogs.payload": "Payload",
     "Settings.permissions.auditLogs.permission.create": "Create permission",
     "Settings.permissions.auditLogs.permission.delete": "Delete permission",
+    "Settings.permissions.auditLogs.release.create": "Create release",
+    "Settings.permissions.auditLogs.release.update": "Update release",
+    "Settings.permissions.auditLogs.release.delete": "Delete release",
+    "Settings.permissions.auditLogs.release.trigger": "Trigger release",
+    "Settings.permissions.auditLogs.release.entry.add": "Add entry to release",
+    "Settings.permissions.auditLogs.release.entry.update": "Change entry on release",
+    "Settings.permissions.auditLogs.release.entry.remove": "Remove entry from release",
+    "Settings.permissions.auditLogs.release.settings.update": "Update release settings",
     "Settings.permissions.auditLogs.permission.update": "Update permission",
     "Settings.permissions.auditLogs.role.create": "Create role",
     "Settings.permissions.auditLogs.role.delete": "Delete role",

package/dist/admin/admin/src/translations/en.json.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"en.json.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"en.json.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/admin/admin/src/utils/getFetchClient.js

@@ -3,6 +3,7 @@
 var pipe = require('lodash/fp/pipe');
 var qs = require('qs');
 var cookies = require('./cookies.js');
+var jwt = require('./jwt.js');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -80,33 +81,105 @@ const STORAGE_KEYS = {
         onTokenUpdate(token);
     }
 };
+const getToken = ()=>{
+    const fromLocalStorage = localStorage.getItem(STORAGE_KEYS.TOKEN);
+    if (fromLocalStorage) {
+        return JSON.parse(fromLocalStorage);
+    }
+    const fromCookie = cookies.getCookieValue(cookies.AUTH_COOKIE_NAME);
+    return fromCookie ?? null;
+};
+const ADMIN_REFRESH_LOCK = 'strapi-admin-access-token';
+const FALLBACK_ADOPT_TIMEOUT_MS = 250;
+const FALLBACK_ADOPT_POLL_MS = 25;
+const postAccessToken = (backendURL)=>fetch(`${backendURL}/admin/access-token`, {
+        method: 'POST',
+        credentials: 'include',
+        headers: {
+            Accept: 'application/json',
+            'Content-Type': 'application/json'
+        }
+    });
+const adoptSharedAccessToken = (token)=>{
+    if (onTokenUpdate) {
+        onTokenUpdate(token);
+    }
+    return token;
+};
+/**
+ * Another tab may have refreshed already and written a newer access token to the
+ * shared localStorage/cookie. Per-tab Redux is not visible here — only shared
+ * storage counts.
+ */ const readValidAccessTokenFromSharedStorage = (staleToken)=>{
+    const stored = getToken();
+    if (!stored || stored === staleToken) {
+        return null;
+    }
+    const expiry = jwt.decodeAccessTokenExpiry(stored);
+    if (expiry === null || expiry <= Date.now()) {
+        return null;
+    }
+    return stored;
+};
+const waitForSharedAccessToken = async (staleToken)=>{
+    const timeoutAt = Date.now() + FALLBACK_ADOPT_TIMEOUT_MS;
+    while(Date.now() < timeoutAt){
+        await new Promise((resolve)=>{
+            setTimeout(resolve, FALLBACK_ADOPT_POLL_MS);
+        });
+        const adopted = readValidAccessTokenFromSharedStorage(staleToken);
+        if (adopted) {
+            return adoptSharedAccessToken(adopted);
+        }
+    }
+    return null;
+};
+const executeRefreshAccessToken = async (backendURL, tokenBeforeRefresh, { allowHttpRetry })=>{
+    const adopted = readValidAccessTokenFromSharedStorage(tokenBeforeRefresh);
+    if (adopted) {
+        return adoptSharedAccessToken(adopted);
+    }
+    let response = await postAccessToken(backendURL);
+    if (response.status === 401 && allowHttpRetry) {
+        const adoptedAfterFail = readValidAccessTokenFromSharedStorage(tokenBeforeRefresh);
+        if (adoptedAfterFail) {
+            return adoptSharedAccessToken(adoptedAfterFail);
+        }
+        const adoptedAfterWait = await waitForSharedAccessToken(tokenBeforeRefresh);
+        if (adoptedAfterWait) {
+            return adoptedAfterWait;
+        }
+        response = await postAccessToken(backendURL);
+    }
+    if (!response.ok) {
+        console.warn('[Auth] Token refresh failed with status:', response.status);
+        return null;
+    }
+    const result = await response.json();
+    const token = result?.data?.token;
+    if (!token) {
+        console.warn('[Auth] Token refresh response missing token');
+        return null;
+    }
+    storeToken(token);
+    return token;
+};
 /**
  * Refresh the access token by calling the /admin/access-token endpoint.
  * This uses a low-level fetch to avoid recursion through the interceptor.
  * Returns the new token on success, or null on failure.
- */ const refreshAccessToken = async ()=>{
+ */ const refreshAccessToken = async (tokenUsedByFailedRequest)=>{
     const backendURL = window.strapi.backendURL;
+    const tokenBeforeRefresh = tokenUsedByFailedRequest ?? getToken();
     try {
-        const response = await fetch(`${backendURL}/admin/access-token`, {
-            method: 'POST',
-            credentials: 'include',
-            headers: {
-                Accept: 'application/json',
-                'Content-Type': 'application/json'
-            }
-        });
-        if (!response.ok) {
-            console.warn('[Auth] Token refresh failed with status:', response.status);
-            return null;
-        }
-        const result = await response.json();
-        const token = result?.data?.token;
-        if (!token) {
-            console.warn('[Auth] Token refresh response missing token');
-            return null;
+        if (typeof navigator !== 'undefined' && navigator.locks?.request) {
+            return await navigator.locks.request(ADMIN_REFRESH_LOCK, ()=>executeRefreshAccessToken(backendURL, tokenBeforeRefresh, {
+                    allowHttpRetry: false
+                }));
         }
-        storeToken(token);
-        return token;
+        return await executeRefreshAccessToken(backendURL, tokenBeforeRefresh, {
+            allowHttpRetry: true
+        });
     } catch (error) {
         console.error('[Auth] Token refresh error:', error);
         return null;
@@ -119,9 +192,9 @@ const STORAGE_KEYS = {
  * @returns The new authentication token
  * @throws {Error} If the token refresh fails (e.g., refresh token expired)
  * @internal Exported for testing purposes
- */ const attemptTokenRefresh = async ()=>{
+ */ const attemptTokenRefresh = async (tokenUsedByFailedRequest)=>{
     if (!refreshPromise) {
-        refreshPromise = refreshAccessToken().finally(()=>{
+        refreshPromise = refreshAccessToken(tokenUsedByFailedRequest).finally(()=>{
             refreshPromise = null;
         });
     }
@@ -150,14 +223,6 @@ class FetchError extends Error {
 const isFetchError = (error)=>{
     return error instanceof FetchError;
 };
-const getToken = ()=>{
-    const fromLocalStorage = localStorage.getItem(STORAGE_KEYS.TOKEN);
-    if (fromLocalStorage) {
-        return JSON.parse(fromLocalStorage);
-    }
-    const fromCookie = cookies.getCookieValue(cookies.AUTH_COOKIE_NAME);
-    return fromCookie ?? null;
-};
 /**
  * @public
  * @param {FetchConfig} [defaultOptions={}] - Fetch Configs.
@@ -182,10 +247,10 @@ const getToken = ()=>{
     /**
    * Create default headers with the current token.
    * This is a function so we can get a fresh token after refresh.
-   */ const getDefaultHeaders = ()=>({
+   */ const getDefaultHeaders = (token = getToken())=>({
             Accept: 'application/json',
             'Content-Type': 'application/json',
-            Authorization: `Bearer ${getToken()}`
+            Authorization: `Bearer ${token}`
         });
     const isFormDataRequest = (body)=>body instanceof FormData;
     const addPrependingSlash = (url)=>url.charAt(0) !== '/' ? `/${url}` : url;
@@ -260,14 +325,14 @@ const getToken = ()=>{
    * Execute a fetch request with automatic token refresh on 401 errors.
    * @param url - The request URL (used to check if it's an auth path)
    * @param executeRequest - Function that performs the fetch (called again on retry with fresh headers)
-   */ const withTokenRefresh = async (url, executeRequest)=>{
+   */ const withTokenRefresh = async (url, executeRequest, getRequestToken)=>{
         try {
             return await executeRequest();
         } catch (error) {
             // Only attempt refresh for 401 errors on non-auth paths
             if (isFetchError(error) && error.status === 401 && !isAuthPath(url)) {
                 try {
-                    await attemptTokenRefresh();
+                    await attemptTokenRefresh(getRequestToken());
                     // Retry - executeRequest will call getDefaultHeaders() again, picking up the new token
                     return await executeRequest();
                 } catch  {
@@ -308,10 +373,12 @@ const getToken = ()=>{
         get: async (url, options)=>{
             const createRequestUrl = makeCreateRequestUrl(options);
             const responseType = options?.responseType ?? 'json';
+            let requestToken = null;
             const executeRequest = async ()=>{
-                const { Authorization } = getDefaultHeaders();
+                requestToken = getToken();
+                const { Authorization } = getDefaultHeaders(requestToken);
                 // For non-JSON response types, omit content negotiation headers that imply JSON
-                const defaultHeaders = responseType === 'json' ? getDefaultHeaders() : {
+                const defaultHeaders = responseType === 'json' ? getDefaultHeaders(requestToken) : {
                     Authorization
                 };
                 const headers = new Headers({
@@ -326,13 +393,15 @@ const getToken = ()=>{
                 });
                 return responseInterceptor(response, options?.validateStatus, responseType);
             };
-            return withTokenRefresh(url, executeRequest);
+            return withTokenRefresh(url, executeRequest, ()=>requestToken);
         },
         post: async (url, data, options)=>{
             const createRequestUrl = makeCreateRequestUrl(options);
+            let requestToken = null;
             const executeRequest = async ()=>{
+                requestToken = getToken();
                 const headers = new Headers({
-                    ...getDefaultHeaders(),
+                    ...getDefaultHeaders(requestToken),
                     ...options?.headers
                 });
                 /**
@@ -350,13 +419,15 @@ const getToken = ()=>{
                 });
                 return responseInterceptor(response, options?.validateStatus);
             };
-            return withTokenRefresh(url, executeRequest);
+            return withTokenRefresh(url, executeRequest, ()=>requestToken);
         },
         put: async (url, data, options)=>{
             const createRequestUrl = makeCreateRequestUrl(options);
+            let requestToken = null;
             const executeRequest = async ()=>{
+                requestToken = getToken();
                 const headers = new Headers({
-                    ...getDefaultHeaders(),
+                    ...getDefaultHeaders(requestToken),
                     ...options?.headers
                 });
                 /**
@@ -374,13 +445,15 @@ const getToken = ()=>{
                 });
                 return responseInterceptor(response, options?.validateStatus);
             };
-            return withTokenRefresh(url, executeRequest);
+            return withTokenRefresh(url, executeRequest, ()=>requestToken);
         },
         del: async (url, options)=>{
             const createRequestUrl = makeCreateRequestUrl(options);
+            let requestToken = null;
             const executeRequest = async ()=>{
+                requestToken = getToken();
                 const headers = new Headers({
-                    ...getDefaultHeaders(),
+                    ...getDefaultHeaders(requestToken),
                     ...options?.headers
                 });
                 const response = await fetch(createRequestUrl(url), {
@@ -391,16 +464,18 @@ const getToken = ()=>{
                 });
                 return responseInterceptor(response, options?.validateStatus);
             };
-            return withTokenRefresh(url, executeRequest);
+            return withTokenRefresh(url, executeRequest, ()=>requestToken);
         }
     };
     return fetchClient;
 };
 
+exports.ADMIN_REFRESH_LOCK = ADMIN_REFRESH_LOCK;
 exports.FetchError = FetchError;
 exports.attemptTokenRefresh = attemptTokenRefresh;
 exports.getFetchClient = getFetchClient;
 exports.isFetchError = isFetchError;
+exports.refreshAccessToken = refreshAccessToken;
 exports.setOnSessionExpired = setOnSessionExpired;
 exports.setOnTokenUpdate = setOnTokenUpdate;
 exports.storeToken = storeToken;