@scality/data-browser-library 1.0.0-preview.9 → 1.0.1

package/dist/components/objects/__tests__/GetPresignedUrlButton.test.js

@@ -0,0 +1,531 @@
+import { jsx } from "react/jsx-runtime";
+import { useToast } from "@scality/core-ui";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { cleanup, render, screen, waitFor } from "@testing-library/react";
+import user_event from "@testing-library/user-event";
+import { useGetPresignedDownload } from "../../../hooks/index.js";
+import { GetPresignedUrlButton } from "../GetPresignedUrlButton.js";
+jest.mock('../../../hooks');
+jest.mock('@scality/core-ui', ()=>{
+    const actual = jest.requireActual('@scality/core-ui');
+    return {
+        ...actual,
+        useToast: jest.fn()
+    };
+});
+const mockUseGetPresignedDownload = jest.mocked(useGetPresignedDownload);
+const mockUseToast = jest.mocked(useToast);
+const defaultProps = {
+    bucketName: 'test-bucket',
+    objectKey: 'folder/test-object.txt',
+    versionId: 'test-version-id'
+};
+const mockPresignedResult = {
+    Url: 'https://s3.example.com/test-bucket/folder/test-object.txt?signature=abc123',
+    ExpiresAt: new Date('2024-01-08T00:00:00Z'),
+    Bucket: 'test-bucket',
+    Key: 'folder/test-object.txt'
+};
+const setupMockDefaults = ()=>{
+    mockUseGetPresignedDownload.mockReturnValue({
+        mutateAsync: jest.fn().mockResolvedValue(mockPresignedResult),
+        isPending: false
+    });
+    mockUseToast.mockReturnValue({
+        showToast: jest.fn()
+    });
+};
+const renderWithProviders = (ui)=>{
+    const queryClient = new QueryClient({
+        defaultOptions: {
+            queries: {
+                retry: false
+            },
+            mutations: {
+                retry: false
+            }
+        }
+    });
+    return render(/*#__PURE__*/ jsx(QueryClientProvider, {
+        client: queryClient,
+        children: ui
+    }));
+};
+describe('GetPresignedUrlButton', ()=>{
+    beforeEach(()=>{
+        jest.clearAllMocks();
+        setupMockDefaults();
+    });
+    afterEach(()=>{
+        cleanup();
+    });
+    describe('Modal Behavior', ()=>{
+        it('should render the button', ()=>{
+            renderWithProviders(/*#__PURE__*/ jsx(GetPresignedUrlButton, {
+                ...defaultProps
+            }));
+            expect(screen.getByRole('button', {
+                name: /get pre-signed url/i
+            })).toBeInTheDocument();
+        });
+        it('should open modal when button is clicked', async ()=>{
+            const user = user_event.setup();
+            renderWithProviders(/*#__PURE__*/ jsx(GetPresignedUrlButton, {
+                ...defaultProps
+            }));
+            await user.click(screen.getByRole('button', {
+                name: /get pre-signed url/i
+            }));
+            expect(screen.getByText('Get a pre-signed url')).toBeInTheDocument();
+            expect(screen.getByText('test-object.txt')).toBeInTheDocument();
+        });
+        it('should close modal when Close button is clicked', async ()=>{
+            const user = user_event.setup();
+            renderWithProviders(/*#__PURE__*/ jsx(GetPresignedUrlButton, {
+                ...defaultProps
+            }));
+            await user.click(screen.getByRole('button', {
+                name: /get pre-signed url/i
+            }));
+            expect(screen.getByText('Get a pre-signed url')).toBeInTheDocument();
+            await user.click(screen.getByRole('button', {
+                name: /close/i
+            }));
+            await waitFor(()=>{
+                expect(screen.queryByText('Get a pre-signed url')).not.toBeInTheDocument();
+            });
+        });
+        it('should reset state when modal closes', async ()=>{
+            const user = user_event.setup();
+            renderWithProviders(/*#__PURE__*/ jsx(GetPresignedUrlButton, {
+                ...defaultProps
+            }));
+            await user.click(screen.getByRole('button', {
+                name: /get pre-signed url/i
+            }));
+            const daysInput = screen.getByLabelText('Days');
+            await user.clear(daysInput);
+            await user.type(daysInput, '3');
+            await user.click(screen.getByRole('button', {
+                name: /generate a pre-signed url/i
+            }));
+            await waitFor(()=>{
+                expect(screen.getByLabelText('Generated pre-signed URL')).toBeInTheDocument();
+            });
+            await user.click(screen.getByRole('button', {
+                name: /close/i
+            }));
+            await user.click(screen.getByRole('button', {
+                name: /get pre-signed url/i
+            }));
+            expect(screen.getByLabelText('Days')).toHaveValue(7);
+            expect(screen.getByLabelText('Hours')).toHaveValue(0);
+            expect(screen.getByLabelText('Minutes')).toHaveValue(0);
+            expect(screen.queryByLabelText('Generated pre-signed URL')).not.toBeInTheDocument();
+        });
+        it('should display object name from key path', async ()=>{
+            const user = user_event.setup();
+            renderWithProviders(/*#__PURE__*/ jsx(GetPresignedUrlButton, {
+                ...defaultProps,
+                objectKey: "deep/nested/folder/myfile.pdf"
+            }));
+            await user.click(screen.getByRole('button', {
+                name: /get pre-signed url/i
+            }));
+            expect(screen.getByText('myfile.pdf')).toBeInTheDocument();
+        });
+        it('should handle object key without slashes', async ()=>{
+            const user = user_event.setup();
+            renderWithProviders(/*#__PURE__*/ jsx(GetPresignedUrlButton, {
+                ...defaultProps,
+                objectKey: "simple-file.txt"
+            }));
+            await user.click(screen.getByRole('button', {
+                name: /get pre-signed url/i
+            }));
+            expect(screen.getByText('simple-file.txt')).toBeInTheDocument();
+        });
+    });
+    describe('Expiration Time Input', ()=>{
+        it('should initialize with 7 days, 0 hours, 0 minutes', async ()=>{
+            const user = user_event.setup();
+            renderWithProviders(/*#__PURE__*/ jsx(GetPresignedUrlButton, {
+                ...defaultProps
+            }));
+            await user.click(screen.getByRole('button', {
+                name: /get pre-signed url/i
+            }));
+            expect(screen.getByLabelText('Days')).toHaveValue(7);
+            expect(screen.getByLabelText('Hours')).toHaveValue(0);
+            expect(screen.getByLabelText('Minutes')).toHaveValue(0);
+        });
+        it('should clamp days input to max 7', async ()=>{
+            const user = user_event.setup();
+            renderWithProviders(/*#__PURE__*/ jsx(GetPresignedUrlButton, {
+                ...defaultProps
+            }));
+            await user.click(screen.getByRole('button', {
+                name: /get pre-signed url/i
+            }));
+            const daysInput = screen.getByLabelText('Days');
+            await user.clear(daysInput);
+            await user.type(daysInput, '10');
+            expect(daysInput).toHaveValue(7);
+        });
+        it('should treat empty/invalid input as 0', async ()=>{
+            const user = user_event.setup();
+            renderWithProviders(/*#__PURE__*/ jsx(GetPresignedUrlButton, {
+                ...defaultProps
+            }));
+            await user.click(screen.getByRole('button', {
+                name: /get pre-signed url/i
+            }));
+            const daysInput = screen.getByLabelText('Days');
+            await user.clear(daysInput);
+            expect(daysInput).toHaveValue(0);
+        });
+        it('should disable hours and minutes when days equals 7', async ()=>{
+            const user = user_event.setup();
+            renderWithProviders(/*#__PURE__*/ jsx(GetPresignedUrlButton, {
+                ...defaultProps
+            }));
+            await user.click(screen.getByRole('button', {
+                name: /get pre-signed url/i
+            }));
+            expect(screen.getByLabelText('Hours')).toBeDisabled();
+            expect(screen.getByLabelText('Minutes')).toBeDisabled();
+        });
+        it('should enable hours and minutes when days is less than 7', async ()=>{
+            const user = user_event.setup();
+            renderWithProviders(/*#__PURE__*/ jsx(GetPresignedUrlButton, {
+                ...defaultProps
+            }));
+            await user.click(screen.getByRole('button', {
+                name: /get pre-signed url/i
+            }));
+            const daysInput = screen.getByLabelText('Days');
+            await user.clear(daysInput);
+            await user.type(daysInput, '3');
+            expect(screen.getByLabelText('Hours')).not.toBeDisabled();
+            expect(screen.getByLabelText('Minutes')).not.toBeDisabled();
+        });
+        it('should reset hours and minutes to 0 when days becomes 7', async ()=>{
+            const user = user_event.setup();
+            renderWithProviders(/*#__PURE__*/ jsx(GetPresignedUrlButton, {
+                ...defaultProps
+            }));
+            await user.click(screen.getByRole('button', {
+                name: /get pre-signed url/i
+            }));
+            const daysInput = screen.getByLabelText('Days');
+            await user.clear(daysInput);
+            await user.type(daysInput, '3');
+            const hoursInput = screen.getByLabelText('Hours');
+            const minutesInput = screen.getByLabelText('Minutes');
+            await user.clear(hoursInput);
+            await user.type(hoursInput, '5');
+            await user.clear(minutesInput);
+            await user.type(minutesInput, '30');
+            expect(hoursInput).toHaveValue(5);
+            expect(minutesInput).toHaveValue(30);
+            await user.clear(daysInput);
+            await user.type(daysInput, '7');
+            expect(hoursInput).toHaveValue(0);
+            expect(minutesInput).toHaveValue(0);
+        });
+        it('should clamp hours input to 0-23 range', async ()=>{
+            const user = user_event.setup();
+            renderWithProviders(/*#__PURE__*/ jsx(GetPresignedUrlButton, {
+                ...defaultProps
+            }));
+            await user.click(screen.getByRole('button', {
+                name: /get pre-signed url/i
+            }));
+            const daysInput = screen.getByLabelText('Days');
+            await user.clear(daysInput);
+            await user.type(daysInput, '3');
+            const hoursInput = screen.getByLabelText('Hours');
+            await user.clear(hoursInput);
+            await user.type(hoursInput, '30');
+            expect(hoursInput).toHaveValue(23);
+        });
+        it('should clamp minutes input to 0-59 range', async ()=>{
+            const user = user_event.setup();
+            renderWithProviders(/*#__PURE__*/ jsx(GetPresignedUrlButton, {
+                ...defaultProps
+            }));
+            await user.click(screen.getByRole('button', {
+                name: /get pre-signed url/i
+            }));
+            const daysInput = screen.getByLabelText('Days');
+            await user.clear(daysInput);
+            await user.type(daysInput, '3');
+            const minutesInput = screen.getByLabelText('Minutes');
+            await user.clear(minutesInput);
+            await user.type(minutesInput, '99');
+            expect(minutesInput).toHaveValue(59);
+        });
+    });
+    describe('Generate Button State', ()=>{
+        it('should be disabled when total expiration is 0', async ()=>{
+            const user = user_event.setup();
+            renderWithProviders(/*#__PURE__*/ jsx(GetPresignedUrlButton, {
+                ...defaultProps
+            }));
+            await user.click(screen.getByRole('button', {
+                name: /get pre-signed url/i
+            }));
+            const daysInput = screen.getByLabelText('Days');
+            await user.clear(daysInput);
+            await user.type(daysInput, '0');
+            expect(screen.getByRole('button', {
+                name: /generate a pre-signed url/i
+            })).toBeDisabled();
+        });
+        it('should be enabled with valid expiration time', async ()=>{
+            const user = user_event.setup();
+            renderWithProviders(/*#__PURE__*/ jsx(GetPresignedUrlButton, {
+                ...defaultProps
+            }));
+            await user.click(screen.getByRole('button', {
+                name: /get pre-signed url/i
+            }));
+            expect(screen.getByRole('button', {
+                name: /generate a pre-signed url/i
+            })).not.toBeDisabled();
+        });
+        it('should be disabled while generating', async ()=>{
+            mockUseGetPresignedDownload.mockReturnValue({
+                mutateAsync: jest.fn().mockImplementation(()=>new Promise(()=>{})),
+                isPending: true
+            });
+            const user = user_event.setup();
+            renderWithProviders(/*#__PURE__*/ jsx(GetPresignedUrlButton, {
+                ...defaultProps
+            }));
+            await user.click(screen.getByRole('button', {
+                name: /get pre-signed url/i
+            }));
+            expect(screen.getByRole('button', {
+                name: /generate a pre-signed url/i
+            })).toBeDisabled();
+        });
+    });
+    describe('URL Generation', ()=>{
+        it('should call getPresignedDownload with correct params', async ()=>{
+            const mockMutateAsync = jest.fn().mockResolvedValue(mockPresignedResult);
+            mockUseGetPresignedDownload.mockReturnValue({
+                mutateAsync: mockMutateAsync,
+                isPending: false
+            });
+            const user = user_event.setup();
+            renderWithProviders(/*#__PURE__*/ jsx(GetPresignedUrlButton, {
+                ...defaultProps
+            }));
+            await user.click(screen.getByRole('button', {
+                name: /get pre-signed url/i
+            }));
+            await user.click(screen.getByRole('button', {
+                name: /generate a pre-signed url/i
+            }));
+            expect(mockMutateAsync).toHaveBeenCalledWith({
+                Bucket: 'test-bucket',
+                Key: 'folder/test-object.txt',
+                VersionId: 'test-version-id',
+                expiresIn: 604800
+            });
+        });
+        it('should not include versionId when not provided', async ()=>{
+            const mockMutateAsync = jest.fn().mockResolvedValue(mockPresignedResult);
+            mockUseGetPresignedDownload.mockReturnValue({
+                mutateAsync: mockMutateAsync,
+                isPending: false
+            });
+            const user = user_event.setup();
+            renderWithProviders(/*#__PURE__*/ jsx(GetPresignedUrlButton, {
+                bucketName: "test-bucket",
+                objectKey: "test.txt"
+            }));
+            await user.click(screen.getByRole('button', {
+                name: /get pre-signed url/i
+            }));
+            await user.click(screen.getByRole('button', {
+                name: /generate a pre-signed url/i
+            }));
+            expect(mockMutateAsync).toHaveBeenCalledWith({
+                Bucket: 'test-bucket',
+                Key: 'test.txt',
+                expiresIn: 604800
+            });
+        });
+        it('should display generated URL on success', async ()=>{
+            const user = user_event.setup();
+            renderWithProviders(/*#__PURE__*/ jsx(GetPresignedUrlButton, {
+                ...defaultProps
+            }));
+            await user.click(screen.getByRole('button', {
+                name: /get pre-signed url/i
+            }));
+            await user.click(screen.getByRole('button', {
+                name: /generate a pre-signed url/i
+            }));
+            await waitFor(()=>{
+                expect(screen.getByLabelText('Generated pre-signed URL')).toHaveValue(mockPresignedResult.Url);
+            });
+        });
+        it('should display expiration date preview', async ()=>{
+            const user = user_event.setup();
+            renderWithProviders(/*#__PURE__*/ jsx(GetPresignedUrlButton, {
+                ...defaultProps
+            }));
+            await user.click(screen.getByRole('button', {
+                name: /get pre-signed url/i
+            }));
+            expect(screen.getByText(/Access ends on:/)).toBeInTheDocument();
+        });
+        it('should change button label after first generation', async ()=>{
+            const user = user_event.setup();
+            renderWithProviders(/*#__PURE__*/ jsx(GetPresignedUrlButton, {
+                ...defaultProps
+            }));
+            await user.click(screen.getByRole('button', {
+                name: /get pre-signed url/i
+            }));
+            expect(screen.getByRole('button', {
+                name: /generate a pre-signed url/i
+            })).toBeInTheDocument();
+            await user.click(screen.getByRole('button', {
+                name: /generate a pre-signed url/i
+            }));
+            await waitFor(()=>{
+                expect(screen.getByRole('button', {
+                    name: /generate another pre-signed url/i
+                })).toBeInTheDocument();
+            });
+        });
+        it('should calculate correct expiration seconds', async ()=>{
+            const mockMutateAsync = jest.fn().mockResolvedValue(mockPresignedResult);
+            mockUseGetPresignedDownload.mockReturnValue({
+                mutateAsync: mockMutateAsync,
+                isPending: false
+            });
+            const user = user_event.setup();
+            renderWithProviders(/*#__PURE__*/ jsx(GetPresignedUrlButton, {
+                ...defaultProps
+            }));
+            await user.click(screen.getByRole('button', {
+                name: /get pre-signed url/i
+            }));
+            const daysInput = screen.getByLabelText('Days');
+            await user.clear(daysInput);
+            await user.type(daysInput, '2');
+            const hoursInput = screen.getByLabelText('Hours');
+            await user.clear(hoursInput);
+            await user.type(hoursInput, '3');
+            const minutesInput = screen.getByLabelText('Minutes');
+            await user.clear(minutesInput);
+            await user.type(minutesInput, '30');
+            await user.click(screen.getByRole('button', {
+                name: /generate a pre-signed url/i
+            }));
+            expect(mockMutateAsync).toHaveBeenCalledWith(expect.objectContaining({
+                expiresIn: 185400
+            }));
+        });
+    });
+    describe('Error Handling', ()=>{
+        it('should show toast with error.message for Error instances', async ()=>{
+            const mockShowToast = jest.fn();
+            mockUseToast.mockReturnValue({
+                showToast: mockShowToast
+            });
+            const errorMessage = 'Access denied to bucket';
+            mockUseGetPresignedDownload.mockReturnValue({
+                mutateAsync: jest.fn().mockRejectedValue(new Error(errorMessage)),
+                isPending: false
+            });
+            const user = user_event.setup();
+            renderWithProviders(/*#__PURE__*/ jsx(GetPresignedUrlButton, {
+                ...defaultProps
+            }));
+            await user.click(screen.getByRole('button', {
+                name: /get pre-signed url/i
+            }));
+            await user.click(screen.getByRole('button', {
+                name: /generate a pre-signed url/i
+            }));
+            await waitFor(()=>{
+                expect(mockShowToast).toHaveBeenCalledWith({
+                    open: true,
+                    message: errorMessage,
+                    status: 'error'
+                });
+            });
+        });
+        it('should show generic toast for non-Error failures', async ()=>{
+            const mockShowToast = jest.fn();
+            mockUseToast.mockReturnValue({
+                showToast: mockShowToast
+            });
+            mockUseGetPresignedDownload.mockReturnValue({
+                mutateAsync: jest.fn().mockRejectedValue('string error'),
+                isPending: false
+            });
+            const user = user_event.setup();
+            renderWithProviders(/*#__PURE__*/ jsx(GetPresignedUrlButton, {
+                ...defaultProps
+            }));
+            await user.click(screen.getByRole('button', {
+                name: /get pre-signed url/i
+            }));
+            await user.click(screen.getByRole('button', {
+                name: /generate a pre-signed url/i
+            }));
+            await waitFor(()=>{
+                expect(mockShowToast).toHaveBeenCalledWith({
+                    open: true,
+                    message: 'Failed to generate presigned URL',
+                    status: 'error'
+                });
+            });
+        });
+        it('should not display URL when generation fails', async ()=>{
+            mockUseGetPresignedDownload.mockReturnValue({
+                mutateAsync: jest.fn().mockRejectedValue(new Error('Failed')),
+                isPending: false
+            });
+            const user = user_event.setup();
+            renderWithProviders(/*#__PURE__*/ jsx(GetPresignedUrlButton, {
+                ...defaultProps
+            }));
+            await user.click(screen.getByRole('button', {
+                name: /get pre-signed url/i
+            }));
+            await user.click(screen.getByRole('button', {
+                name: /generate a pre-signed url/i
+            }));
+            await waitFor(()=>{
+                expect(screen.queryByLabelText('Generated pre-signed URL')).not.toBeInTheDocument();
+            });
+        });
+    });
+    describe('Copy Button', ()=>{
+        it('should render copy button with generated URL', async ()=>{
+            const user = user_event.setup();
+            renderWithProviders(/*#__PURE__*/ jsx(GetPresignedUrlButton, {
+                ...defaultProps
+            }));
+            await user.click(screen.getByRole('button', {
+                name: /get pre-signed url/i
+            }));
+            await user.click(screen.getByRole('button', {
+                name: /generate a pre-signed url/i
+            }));
+            await waitFor(()=>{
+                expect(screen.getByRole('button', {
+                    name: /copy/i
+                })).toBeInTheDocument();
+            });
+        });
+    });
+});

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 { type CoreUITheme } from '@scality/core-ui/dist/next';
+import { type InvalidateQueryFilters, type QueryClient, type QueryKey } from '@tanstack/react-query';
+import type React from 'react';
+import type { GetConfigFunction } from '../../types';
 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 { CoreUiThemeProvider } from "@scality/core-ui/dist/next";
+import { coreUIAvailableThemes } from "@scality/core-ui/dist/style/theme";
+import { useQueryClient } from "@tanstack/react-query";
+import { createContext, useCallback, useContext, useMemo } from "react";
+import { ANONYMOUS_S3_CONFIG_IDENTIFIER, computeS3ConfigIdentifier } from "../../utils/s3ConfigIdentifier.js";
+import { QueryProvider } from "./QueryProvider.js";
+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?.cacheKey,
+        currentConfig?.credentials?.accessKeyId,
+        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 };