@scality/data-browser-library 1.0.0-preview.13 → 1.0.0-preview.16

package/dist/components/objects/ObjectLock/__tests__/ObjectLockSettings.test.js

@@ -1,22 +1,22 @@
 import { jsx } from "react/jsx-runtime";
 import { fireEvent, render, screen, waitFor } from "@testing-library/react";
 import user_event from "@testing-library/user-event";
-import { MemoryRouter, Route, Routes } from "react-router-dom";
+import { MemoryRouter, Route, Routes } from "react-router";
 import { createTestWrapper } from "../../../../test/testUtils.js";
 import { ObjectLockSettings } from "../ObjectLockSettings.js";
 import { useGetBucketObjectLockConfiguration, useSetBucketObjectLockConfiguration } from "../../../../hooks/index.js";
-jest.mock("../../../../hooks", ()=>({
+jest.mock('../../../../hooks', ()=>({
         useGetBucketObjectLockConfiguration: jest.fn(),
         useSetBucketObjectLockConfiguration: jest.fn()
     }));
 const mockUseGetBucketObjectLockConfiguration = jest.mocked(useGetBucketObjectLockConfiguration);
 const mockUseSetBucketObjectLockConfiguration = jest.mocked(useSetBucketObjectLockConfiguration);
 const mockNavigate = jest.fn();
-jest.mock("react-router-dom", ()=>({
-        ...jest.requireActual("react-router-dom"),
+jest.mock('react-router', ()=>({
+        ...jest.requireActual('react-router'),
         useNavigate: ()=>mockNavigate
     }));
-const renderObjectLockSettings = (bucketName = "test-bucket")=>{
+const renderObjectLockSettings = (bucketName = 'test-bucket')=>{
     const Wrapper = createTestWrapper();
     return render(/*#__PURE__*/ jsx(MemoryRouter, {
         initialEntries: [
@@ -32,74 +32,74 @@ const renderObjectLockSettings = (bucketName = "test-bucket")=>{
         })
     }));
 };
-describe("ObjectLockSettings", ()=>{
+describe('ObjectLockSettings', ()=>{
     const mockMutate = jest.fn();
     beforeEach(()=>{
         jest.clearAllMocks();
         mockNavigate.mockClear();
         mockUseGetBucketObjectLockConfiguration.mockReturnValue({
             data: void 0,
-            status: "success"
+            status: 'success'
         });
         mockUseSetBucketObjectLockConfiguration.mockReturnValue({
             mutate: mockMutate,
             isPending: false
         });
     });
-    it("displays loading state while fetching bucket configuration", ()=>{
+    it('displays loading state while fetching bucket configuration', ()=>{
         mockUseGetBucketObjectLockConfiguration.mockReturnValue({
             data: void 0,
-            status: "pending"
+            status: 'pending'
         });
         renderObjectLockSettings();
-        expect(screen.getByText("Loading retention settings...")).toBeInTheDocument();
+        expect(screen.getByText('Loading retention settings...')).toBeInTheDocument();
     });
-    it("renders form with Object Lock checkbox", async ()=>{
+    it('renders form with Object Lock checkbox', async ()=>{
         renderObjectLockSettings();
         await waitFor(()=>{
-            expect(screen.getByText("Object-lock settings")).toBeInTheDocument();
+            expect(screen.getByText('Object-lock settings')).toBeInTheDocument();
         });
         expect(screen.getByLabelText(/object-lock/i)).toBeInTheDocument();
     });
-    it("disables save button when Object Lock is not enabled", async ()=>{
+    it('disables save button when Object Lock is not enabled', async ()=>{
         renderObjectLockSettings();
         await waitFor(()=>{
-            const saveButton = screen.getByRole("button", {
+            const saveButton = screen.getByRole('button', {
                 name: /save/i
             });
             expect(saveButton).toBeDisabled();
         });
     });
-    it("shows Default Retention fields when Object Lock is enabled", async ()=>{
+    it('shows Default Retention fields when Object Lock is enabled', async ()=>{
         mockUseGetBucketObjectLockConfiguration.mockReturnValue({
             data: {
                 ObjectLockConfiguration: {
-                    ObjectLockEnabled: "Enabled"
+                    ObjectLockEnabled: 'Enabled'
                 }
             },
-            status: "success"
+            status: 'success'
         });
         renderObjectLockSettings();
         await waitFor(()=>{
-            expect(screen.getByText("Default Retention")).toBeInTheDocument();
-            expect(screen.getByText("Retention mode")).toBeInTheDocument();
-            expect(screen.getByText("Retention period")).toBeInTheDocument();
+            expect(screen.getByText('Default Retention')).toBeInTheDocument();
+            expect(screen.getByText('Retention mode')).toBeInTheDocument();
+            expect(screen.getByText('Retention period')).toBeInTheDocument();
         }, {
             timeout: 3000
         });
     });
-    it("enables save button when Object Lock is enabled", async ()=>{
+    it('enables save button when Object Lock is enabled', async ()=>{
         mockUseGetBucketObjectLockConfiguration.mockReturnValue({
             data: {
                 ObjectLockConfiguration: {
-                    ObjectLockEnabled: "Enabled"
+                    ObjectLockEnabled: 'Enabled'
                 }
             },
-            status: "success"
+            status: 'success'
         });
         renderObjectLockSettings();
         await waitFor(()=>{
-            const saveButton = screen.getByRole("button", {
+            const saveButton = screen.getByRole('button', {
                 name: /save/i
             });
             expect(saveButton).toBeEnabled();
@@ -107,18 +107,18 @@ describe("ObjectLockSettings", ()=>{
             timeout: 3000
         });
     });
-    it("enables retention fields when Default Retention is checked", async ()=>{
+    it('enables retention fields when Default Retention is checked', async ()=>{
         mockUseGetBucketObjectLockConfiguration.mockReturnValue({
             data: {
                 ObjectLockConfiguration: {
-                    ObjectLockEnabled: "Enabled"
+                    ObjectLockEnabled: 'Enabled'
                 }
             },
-            status: "success"
+            status: 'success'
         });
         renderObjectLockSettings();
         await waitFor(()=>{
-            expect(screen.getByText("Default Retention")).toBeInTheDocument();
+            expect(screen.getByText('Default Retention')).toBeInTheDocument();
         });
         const defaultRetentionCheckbox = screen.getByLabelText(/default retention/i);
         expect(defaultRetentionCheckbox).not.toBeChecked();
@@ -130,20 +130,20 @@ describe("ObjectLockSettings", ()=>{
             timeout: 3000
         });
     });
-    it("disables retention fields when Default Retention is unchecked", async ()=>{
+    it('disables retention fields when Default Retention is unchecked', async ()=>{
         mockUseGetBucketObjectLockConfiguration.mockReturnValue({
             data: {
                 ObjectLockConfiguration: {
-                    ObjectLockEnabled: "Enabled",
+                    ObjectLockEnabled: 'Enabled',
                     Rule: {
                         DefaultRetention: {
-                            Mode: "GOVERNANCE",
+                            Mode: 'GOVERNANCE',
                             Days: 30
                         }
                     }
                 }
             },
-            status: "success"
+            status: 'success'
         });
         renderObjectLockSettings();
         await waitFor(()=>{
@@ -155,18 +155,18 @@ describe("ObjectLockSettings", ()=>{
             expect(governanceRadio).toBeDisabled();
         });
     });
-    it("shows validation error when retention period is invalid", async ()=>{
+    it('shows validation error when retention period is invalid', async ()=>{
         mockUseGetBucketObjectLockConfiguration.mockReturnValue({
             data: {
                 ObjectLockConfiguration: {
-                    ObjectLockEnabled: "Enabled"
+                    ObjectLockEnabled: 'Enabled'
                 }
             },
-            status: "success"
+            status: 'success'
         });
         renderObjectLockSettings();
         await waitFor(()=>{
-            expect(screen.getByText("Default Retention")).toBeInTheDocument();
+            expect(screen.getByText('Default Retention')).toBeInTheDocument();
         });
         const defaultRetentionCheckbox = screen.getByLabelText(/default retention/i);
         fireEvent.click(defaultRetentionCheckbox);
@@ -176,9 +176,9 @@ describe("ObjectLockSettings", ()=>{
         });
         const retentionPeriodInput = screen.getByLabelText(/retention period/i);
         await user_event.clear(retentionPeriodInput);
-        await user_event.type(retentionPeriodInput, "0");
+        await user_event.type(retentionPeriodInput, '0');
         await waitFor(()=>{
-            const saveButton = screen.getByRole("button", {
+            const saveButton = screen.getByRole('button', {
                 name: /save/i
             });
             expect(saveButton).toBeDisabled();
@@ -186,18 +186,18 @@ describe("ObjectLockSettings", ()=>{
             timeout: 3000
         });
     });
-    it("saves Object Lock configuration with Default Retention and navigates on success", async ()=>{
+    it('saves Object Lock configuration with Default Retention and navigates on success', async ()=>{
         mockUseGetBucketObjectLockConfiguration.mockReturnValue({
             data: {
                 ObjectLockConfiguration: {
-                    ObjectLockEnabled: "Enabled"
+                    ObjectLockEnabled: 'Enabled'
                 }
             },
-            status: "success"
+            status: 'success'
         });
         renderObjectLockSettings();
         await waitFor(()=>{
-            expect(screen.getByText("Default Retention")).toBeInTheDocument();
+            expect(screen.getByText('Default Retention')).toBeInTheDocument();
         });
         const defaultRetentionCheckbox = screen.getByLabelText(/default retention/i);
         fireEvent.click(defaultRetentionCheckbox);
@@ -207,13 +207,13 @@ describe("ObjectLockSettings", ()=>{
         });
         const retentionPeriodInput = screen.getByLabelText(/retention period/i);
         await user_event.clear(retentionPeriodInput);
-        await user_event.type(retentionPeriodInput, "30");
+        await user_event.type(retentionPeriodInput, '30');
         const governanceRadio = screen.getByLabelText(/governance/i);
         fireEvent.click(governanceRadio);
         mockMutate.mockImplementation((_, options)=>{
             options?.onSuccess?.();
         });
-        const saveButton = screen.getByRole("button", {
+        const saveButton = screen.getByRole('button', {
             name: /save/i
         });
         await waitFor(()=>expect(saveButton).toBeEnabled(), {
@@ -223,25 +223,25 @@ describe("ObjectLockSettings", ()=>{
         await waitFor(()=>{
             expect(mockMutate).toHaveBeenCalled();
             const callArgs = mockMutate.mock.calls[0][0];
-            expect(callArgs.Bucket).toBe("test-bucket");
-            expect(callArgs.ObjectLockConfiguration.ObjectLockEnabled).toBe("Enabled");
-            expect(callArgs.ObjectLockConfiguration.Rule.DefaultRetention.Mode).toBe("GOVERNANCE");
+            expect(callArgs.Bucket).toBe('test-bucket');
+            expect(callArgs.ObjectLockConfiguration.ObjectLockEnabled).toBe('Enabled');
+            expect(callArgs.ObjectLockConfiguration.Rule.DefaultRetention.Mode).toBe('GOVERNANCE');
             expect(callArgs.ObjectLockConfiguration.Rule.DefaultRetention.Days || callArgs.ObjectLockConfiguration.Rule.DefaultRetention.Years).toBe(30);
-            expect(mockNavigate).toHaveBeenCalledWith("/buckets/test-bucket");
+            expect(mockNavigate).toHaveBeenCalledWith('/buckets/test-bucket');
         });
     });
-    it("saves Object Lock configuration with Years frequency", async ()=>{
+    it('saves Object Lock configuration with Years frequency', async ()=>{
         mockUseGetBucketObjectLockConfiguration.mockReturnValue({
             data: {
                 ObjectLockConfiguration: {
-                    ObjectLockEnabled: "Enabled"
+                    ObjectLockEnabled: 'Enabled'
                 }
             },
-            status: "success"
+            status: 'success'
         });
         renderObjectLockSettings();
         await waitFor(()=>{
-            expect(screen.getByText("Default Retention")).toBeInTheDocument();
+            expect(screen.getByText('Default Retention')).toBeInTheDocument();
         });
         const defaultRetentionCheckbox = screen.getByLabelText(/default retention/i);
         fireEvent.click(defaultRetentionCheckbox);
@@ -251,11 +251,11 @@ describe("ObjectLockSettings", ()=>{
         });
         const retentionPeriodInput = screen.getByLabelText(/retention period/i);
         await user_event.clear(retentionPeriodInput);
-        await user_event.type(retentionPeriodInput, "2");
+        await user_event.type(retentionPeriodInput, '2');
         mockMutate.mockImplementation((_, options)=>{
             options?.onSuccess?.();
         });
-        const saveButton = screen.getByRole("button", {
+        const saveButton = screen.getByRole('button', {
             name: /save/i
         });
         await waitFor(()=>expect(saveButton).toBeEnabled(), {
@@ -265,24 +265,24 @@ describe("ObjectLockSettings", ()=>{
         await waitFor(()=>{
             expect(mockMutate).toHaveBeenCalled();
             const callArgs = mockMutate.mock.calls[0][0];
-            expect(callArgs.Bucket).toBe("test-bucket");
-            expect(callArgs.ObjectLockConfiguration.ObjectLockEnabled).toBe("Enabled");
-            expect(callArgs.ObjectLockConfiguration.Rule.DefaultRetention.Mode).toBe("GOVERNANCE");
+            expect(callArgs.Bucket).toBe('test-bucket');
+            expect(callArgs.ObjectLockConfiguration.ObjectLockEnabled).toBe('Enabled');
+            expect(callArgs.ObjectLockConfiguration.Rule.DefaultRetention.Mode).toBe('GOVERNANCE');
             expect(callArgs.ObjectLockConfiguration.Rule.DefaultRetention.Days || callArgs.ObjectLockConfiguration.Rule.DefaultRetention.Years).toBe(2);
         });
     });
-    it("saves Object Lock configuration without Default Retention", async ()=>{
+    it('saves Object Lock configuration without Default Retention', async ()=>{
         mockUseGetBucketObjectLockConfiguration.mockReturnValue({
             data: {
                 ObjectLockConfiguration: {
-                    ObjectLockEnabled: "Enabled"
+                    ObjectLockEnabled: 'Enabled'
                 }
             },
-            status: "success"
+            status: 'success'
         });
         renderObjectLockSettings();
         await waitFor(()=>{
-            const saveButton = screen.getByRole("button", {
+            const saveButton = screen.getByRole('button', {
                 name: /save/i
             });
             expect(saveButton).toBeEnabled();
@@ -292,41 +292,41 @@ describe("ObjectLockSettings", ()=>{
         mockMutate.mockImplementation((_, options)=>{
             options?.onSuccess?.();
         });
-        const saveButton = screen.getByRole("button", {
+        const saveButton = screen.getByRole('button', {
             name: /save/i
         });
         fireEvent.click(saveButton);
         await waitFor(()=>{
             expect(mockMutate).toHaveBeenCalled();
             const callArgs = mockMutate.mock.calls[0][0];
-            expect(callArgs.Bucket).toBe("test-bucket");
-            expect(callArgs.ObjectLockConfiguration.ObjectLockEnabled).toBe("Enabled");
+            expect(callArgs.Bucket).toBe('test-bucket');
+            expect(callArgs.ObjectLockConfiguration.ObjectLockEnabled).toBe('Enabled');
             expect(callArgs.ObjectLockConfiguration.Rule).toBeUndefined();
         });
     });
-    it("displays error toast when save fails", async ()=>{
+    it('displays error toast when save fails', async ()=>{
         mockUseGetBucketObjectLockConfiguration.mockReturnValue({
             data: {
                 ObjectLockConfiguration: {
-                    ObjectLockEnabled: "Enabled"
+                    ObjectLockEnabled: 'Enabled'
                 }
             },
-            status: "success"
+            status: 'success'
         });
         renderObjectLockSettings();
         await waitFor(()=>{
-            const saveButton = screen.getByRole("button", {
+            const saveButton = screen.getByRole('button', {
                 name: /save/i
             });
             expect(saveButton).toBeEnabled();
         }, {
             timeout: 3000
         });
-        const error = new Error("Access Denied");
+        const error = new Error('Access Denied');
         mockMutate.mockImplementation((_, options)=>{
             options?.onError?.(error);
         });
-        const saveButton = screen.getByRole("button", {
+        const saveButton = screen.getByRole('button', {
             name: /save/i
         });
         fireEvent.click(saveButton);
@@ -334,30 +334,30 @@ describe("ObjectLockSettings", ()=>{
             expect(mockNavigate).not.toHaveBeenCalled();
         });
     });
-    it("navigates back when cancel button is clicked", async ()=>{
+    it('navigates back when cancel button is clicked', async ()=>{
         renderObjectLockSettings();
         await waitFor(()=>{
-            const cancelButton = screen.getByRole("button", {
+            const cancelButton = screen.getByRole('button', {
                 name: /cancel/i
             });
             fireEvent.click(cancelButton);
         });
-        expect(mockNavigate).toHaveBeenCalledWith("/buckets/test-bucket");
+        expect(mockNavigate).toHaveBeenCalledWith('/buckets/test-bucket');
     });
-    it("populates form with existing bucket configuration", async ()=>{
+    it('populates form with existing bucket configuration', async ()=>{
         mockUseGetBucketObjectLockConfiguration.mockReturnValue({
             data: {
                 ObjectLockConfiguration: {
-                    ObjectLockEnabled: "Enabled",
+                    ObjectLockEnabled: 'Enabled',
                     Rule: {
                         DefaultRetention: {
-                            Mode: "COMPLIANCE",
+                            Mode: 'COMPLIANCE',
                             Days: 60
                         }
                     }
                 }
             },
-            status: "success"
+            status: 'success'
         });
         renderObjectLockSettings();
         await waitFor(()=>{

package/dist/components/objects/ObjectPage.js

@@ -1,18 +1,19 @@
 import { jsx } from "react/jsx-runtime";
-import { useNavigate, useParams, useSearchParams } from "react-router-dom";
+import { useParams, useSearchParams } from "react-router";
 import { useCallback, useState } from "react";
 import { ObjectList } from "./ObjectList.js";
 import { ObjectDetails } from "./ObjectDetails/index.js";
 import { BrowserPageLayout } from "../layouts/BrowserPageLayout.js";
+import { useDataBrowserNavigate } from "../../hooks/useDataBrowserNavigate.js";
 const ObjectPage = ()=>{
     const { bucketName } = useParams();
-    const navigate = useNavigate();
+    const navigate = useDataBrowserNavigate();
     const [searchParams] = useSearchParams();
     const [item, setItem] = useState(null);
-    const prefix = searchParams.get("prefix") || "";
+    const prefix = searchParams.get('prefix') || '';
     const handlePrefixChange = useCallback((newPrefix)=>{
         const newSearchParams = new URLSearchParams(searchParams);
-        newSearchParams.set("prefix", newPrefix);
+        newSearchParams.set('prefix', newPrefix);
         setItem(null);
         navigate(`?${newSearchParams.toString()}`, {
             replace: true

package/dist/components/objects/UploadButton.d.ts

@@ -1,5 +1,5 @@
-import React from "react";
-import type { PutObjectCommandInput } from "@aws-sdk/client-s3";
+import React from 'react';
+import type { PutObjectCommandInput } from '@aws-sdk/client-s3';
 interface UploadButtonProps {
     /**
      * The S3 bucket name where files will be uploaded
@@ -16,7 +16,7 @@ interface UploadButtonProps {
     /**
      * Button variant
      */
-    variant?: "primary" | "secondary" | "outline";
+    variant?: 'primary' | 'secondary' | 'outline';
     /**
      * Upload options to configure metadata, encryption, etc.
      */

package/dist/components/objects/UploadButton.js

@@ -51,7 +51,7 @@ const RemoveButton = styled_components.button`
   }
 `;
 const maybePluralize = (count, word)=>1 === count ? `1 ${word}` : `${count} ${word}s`;
-const getTitle = (fileCount)=>0 === fileCount ? "Upload Files" : `Upload ${maybePluralize(fileCount, "file")}`;
+const getTitle = (fileCount)=>0 === fileCount ? 'Upload Files' : `Upload ${maybePluralize(fileCount, 'file')}`;
 const FileList = ({ acceptedFiles, open, removeFile })=>/*#__PURE__*/ jsxs("div", {
         children: [
             /*#__PURE__*/ jsx(Button, {
@@ -111,7 +111,7 @@ const NoFile = ({ open })=>/*#__PURE__*/ jsxs(EmptyFile, {
             })
         ]
     });
-const UploadButton_UploadButton = ({ bucket, prefix = "", uploadOptions = {}, onUploadSuccess, onUploadError })=>{
+const UploadButton_UploadButton = ({ bucket, prefix = '', uploadOptions = {}, onUploadSuccess, onUploadError })=>{
     const [isModalOpen, setIsModalOpen] = useState(false);
     const [acceptedFiles, setAcceptedFiles] = useState([]);
     const uploadMutation = useUploadObjects();
@@ -177,8 +177,8 @@ const UploadButton_UploadButton = ({ bucket, prefix = "", uploadOptions = {}, on
                 icon: /*#__PURE__*/ jsx(Icon, {
                     name: "Simple-upload"
                 }),
-                label: "Upload",
-                variant: "secondary",
+                label: 'Upload',
+                variant: 'secondary',
                 onClick: openModal
             }),
             isModalOpen && /*#__PURE__*/ jsx(Modal, {
@@ -198,7 +198,7 @@ const UploadButton_UploadButton = ({ bucket, prefix = "", uploadOptions = {}, on
                                     disabled: 0 === acceptedFiles.length || uploadMutation.isPending,
                                     variant: "primary",
                                     onClick: handleUpload,
-                                    label: uploadMutation.isPending ? "Uploading..." : "Upload"
+                                    label: uploadMutation.isPending ? 'Uploading...' : 'Upload'
                                 })
                             ]
                         })

package/dist/components/providers/DataBrowserProvider.d.ts

@@ -1,20 +1,31 @@
-import React from "react";
-import { QueryClient } from "@tanstack/react-query";
-import { GetConfigFunction } from "../../types";
-import { CoreUITheme } from "@scality/core-ui/dist/style/theme";
+import React from 'react';
+import { QueryClient, InvalidateQueryFilters, QueryKey } from '@tanstack/react-query';
+import { GetConfigFunction } from '../../types';
+import { CoreUITheme } from '@scality/core-ui/dist/next';
 export interface DataBrowserContextValue {
-    getS3Config: GetConfigFunction;
-    theme: CoreUITheme;
+    getS3Config: GetConfigFunction | null;
+    s3ConfigIdentifier: string;
 }
-export declare const DataBrowserContext: React.Context<DataBrowserContextValue | null>;
+export declare const DataBrowserContext: React.Context<DataBrowserContextValue>;
 export declare const useDataBrowserContext: () => DataBrowserContextValue;
-export declare const useDataBrowserTheme: () => CoreUITheme;
-interface DataBrowserProviderProps {
+export interface DataBrowserProviderProps {
     children: React.ReactNode;
-    queryClient?: QueryClient;
-    enableDevtools?: boolean;
     getS3Config?: GetConfigFunction;
+    queryClient?: QueryClient;
     theme?: CoreUITheme;
+    enableDevtools?: boolean;
 }
 export declare const DataBrowserProvider: React.FC<DataBrowserProviderProps>;
-export {};
+export declare const useDataBrowserConfig: () => import("../../types").S3BrowserConfig & {
+    credentials: import("../../types").S3Credentials;
+};
+/**
+ * Hook to invalidate queries with automatic S3 config identifier prefixing.
+ *
+ * @example
+ * const invalidateQueries = useInvalidateQueries();
+ * await invalidateQueries({ queryKey: ['ListObjects', { Bucket: 'my-bucket' }] });
+ */
+export declare const useInvalidateQueries: () => (filters: Omit<InvalidateQueryFilters, "queryKey"> & {
+    queryKey: QueryKey;
+}) => Promise<void>;

package/dist/components/providers/DataBrowserProvider.js

@@ -1,42 +1,64 @@
-import { jsx, jsxs } from "react/jsx-runtime";
-import { createContext, useContext } from "react";
-import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
-import { ReactQueryDevtools } from "@tanstack/react-query-devtools";
-const DataBrowserContext = /*#__PURE__*/ createContext(null);
-const useDataBrowserContext = ()=>{
-    const context = useContext(DataBrowserContext);
-    if (!context) throw new Error("useDataBrowserContext must be used within a DataBrowserProvider component");
-    return context;
+import { jsx } from "react/jsx-runtime";
+import { createContext, useCallback, useContext, useMemo } from "react";
+import { useQueryClient } from "@tanstack/react-query";
+import { ANONYMOUS_S3_CONFIG_IDENTIFIER, computeS3ConfigIdentifier } from "../../utils/s3ConfigIdentifier.js";
+import { QueryProvider } from "./QueryProvider.js";
+import { CoreUiThemeProvider } from "@scality/core-ui/dist/next";
+import { coreUIAvailableThemes } from "@scality/core-ui/dist/style/theme";
+const DEFAULT_CONTEXT_VALUE = {
+    getS3Config: null,
+    s3ConfigIdentifier: ANONYMOUS_S3_CONFIG_IDENTIFIER
 };
-const useDataBrowserTheme = ()=>{
-    const { theme } = useDataBrowserContext();
-    return theme;
-};
-const defaultQueryClient = new QueryClient({
-    defaultOptions: {
-        queries: {
-            staleTime: 300000,
-            retry: 2
-        }
-    }
-});
-const DataBrowserProvider = ({ children, queryClient = defaultQueryClient, enableDevtools = "development" === process.env.NODE_ENV, getS3Config, theme })=>{
-    const content = /*#__PURE__*/ jsxs(QueryClientProvider, {
-        client: queryClient,
-        children: [
-            children,
-            enableDevtools && /*#__PURE__*/ jsx(ReactQueryDevtools, {
-                initialIsOpen: false
+const DataBrowserContext = /*#__PURE__*/ createContext(DEFAULT_CONTEXT_VALUE);
+const useDataBrowserContext = ()=>useContext(DataBrowserContext);
+const DataBrowserProvider = ({ children, queryClient, theme, enableDevtools, getS3Config })=>{
+    const currentConfig = getS3Config?.();
+    const s3ConfigIdentifier = useMemo(()=>currentConfig ? computeS3ConfigIdentifier(currentConfig) : ANONYMOUS_S3_CONFIG_IDENTIFIER, [
+        currentConfig?.credentials?.accessKeyId,
+        currentConfig?.credentials?.roleArn,
+        currentConfig?.credentials?.sessionToken,
+        currentConfig?.region,
+        currentConfig?.endpoint
+    ]);
+    const contextValue = useMemo(()=>({
+            getS3Config: getS3Config ?? null,
+            s3ConfigIdentifier
+        }), [
+        getS3Config,
+        s3ConfigIdentifier
+    ]);
+    return /*#__PURE__*/ jsx(CoreUiThemeProvider, {
+        theme: theme ?? coreUIAvailableThemes.darkRebrand,
+        children: /*#__PURE__*/ jsx(QueryProvider, {
+            queryClient: queryClient,
+            enableDevtools: enableDevtools,
+            children: /*#__PURE__*/ jsx(DataBrowserContext.Provider, {
+                value: contextValue,
+                children: children
             })
-        ]
-    });
-    if (getS3Config && theme) return /*#__PURE__*/ jsx(DataBrowserContext.Provider, {
-        value: {
-            getS3Config,
-            theme
-        },
-        children: content
+        })
     });
-    return content;
 };
-export { DataBrowserContext, DataBrowserProvider, useDataBrowserContext, useDataBrowserTheme };
+const useDataBrowserConfig = ()=>{
+    const { getS3Config } = useDataBrowserContext();
+    if (!getS3Config) throw new Error("useDataBrowserConfig: S3 config not available. Ensure DataBrowserProvider has getS3Config prop set.");
+    return getS3Config();
+};
+const useInvalidateQueries = ()=>{
+    const { s3ConfigIdentifier } = useDataBrowserContext();
+    const queryClient = useQueryClient();
+    return useCallback((filters)=>{
+        const { queryKey, ...rest } = filters;
+        return queryClient.invalidateQueries({
+            ...rest,
+            queryKey: [
+                s3ConfigIdentifier,
+                ...queryKey
+            ]
+        });
+    }, [
+        queryClient,
+        s3ConfigIdentifier
+    ]);
+};
+export { DataBrowserContext, DataBrowserProvider, useDataBrowserConfig, useDataBrowserContext, useInvalidateQueries };

package/dist/components/providers/QueryProvider.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { QueryClient } from '@tanstack/react-query';
+export interface QueryProviderProps {
+    children: React.ReactNode;
+    queryClient?: QueryClient;
+    enableDevtools?: boolean;
+}
+export declare const defaultQueryClient: QueryClient;
+export declare const QueryProvider: React.FC<QueryProviderProps>;