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

package/dist/hooks/objectOperations.js

@@ -3,65 +3,65 @@ import { useCreateS3InfiniteQueryHook } from "./factories/useCreateS3InfiniteQue
 import { useCreateS3MutationHook } from "./factories/useCreateS3MutationHook.js";
 import { useCreateS3QueryHook } from "./factories/useCreateS3QueryHook.js";
 import { SearchObjectsV2Command, SearchObjectsVersionCommand } from "@scality/zenkoclient";
-const useListObjects = useCreateS3InfiniteQueryHook(ListObjectsV2Command, "ListObjects");
-const useListObjectVersions = useCreateS3InfiniteQueryHook(ListObjectVersionsCommand, "ListObjectVersions");
-const useSearchObjects = useCreateS3InfiniteQueryHook(SearchObjectsV2Command, "SearchObjects");
-const useSearchObjectsVersions = useCreateS3InfiniteQueryHook(SearchObjectsVersionCommand, "SearchObjectsVersions");
-const useObjectMetadata = useCreateS3QueryHook(HeadObjectCommand, "HeadObject");
-const useGetObject = useCreateS3QueryHook(GetObjectCommand, "GetObject");
-const usePutObject = useCreateS3MutationHook(PutObjectCommand, "PutObject", [
-    "ListObjects",
-    "SearchObjects"
+const useListObjects = useCreateS3InfiniteQueryHook(ListObjectsV2Command, 'ListObjects');
+const useListObjectVersions = useCreateS3InfiniteQueryHook(ListObjectVersionsCommand, 'ListObjectVersions');
+const useSearchObjects = useCreateS3InfiniteQueryHook(SearchObjectsV2Command, 'SearchObjects');
+const useSearchObjectsVersions = useCreateS3InfiniteQueryHook(SearchObjectsVersionCommand, 'SearchObjectsVersions');
+const useObjectMetadata = useCreateS3QueryHook(HeadObjectCommand, 'HeadObject');
+const useGetObject = useCreateS3QueryHook(GetObjectCommand, 'GetObject');
+const usePutObject = useCreateS3MutationHook(PutObjectCommand, 'PutObject', [
+    'ListObjects',
+    'SearchObjects'
 ]);
-const useCreateFolder = useCreateS3MutationHook(PutObjectCommand, "PutObject", [
-    "ListObjects",
-    "SearchObjects"
+const useCreateFolder = useCreateS3MutationHook(PutObjectCommand, 'PutObject', [
+    'ListObjects',
+    'SearchObjects'
 ]);
-const useUploadObjects = useCreateS3MutationHook(PutObjectCommand, "PutObject", [
-    "ListObjects",
-    "SearchObjects"
+const useUploadObjects = useCreateS3MutationHook(PutObjectCommand, 'PutObject', [
+    'ListObjects',
+    'SearchObjects'
 ]);
-const useDeleteObject = useCreateS3MutationHook(DeleteObjectCommand, "DeleteObject", [
-    "ListObjects",
-    "SearchObjects"
+const useDeleteObject = useCreateS3MutationHook(DeleteObjectCommand, 'DeleteObject', [
+    'ListObjects',
+    'SearchObjects'
 ]);
-const useDeleteObjects = useCreateS3MutationHook(DeleteObjectsCommand, "DeleteObjects", [
-    "ListObjects",
-    "ListObjectVersions",
-    "SearchObjects",
-    "SearchObjectsVersions"
+const useDeleteObjects = useCreateS3MutationHook(DeleteObjectsCommand, 'DeleteObjects', [
+    'ListObjects',
+    'ListObjectVersions',
+    'SearchObjects',
+    'SearchObjectsVersions'
 ]);
-const useCopyObject = useCreateS3MutationHook(CopyObjectCommand, "CopyObject", [
-    "ListObjects",
-    "SearchObjects",
-    "HeadObject"
+const useCopyObject = useCreateS3MutationHook(CopyObjectCommand, 'CopyObject', [
+    'ListObjects',
+    'SearchObjects',
+    'HeadObject'
 ]);
-const useObjectRetention = useCreateS3QueryHook(GetObjectRetentionCommand, "GetObjectRetention");
-const useSetObjectRetention = useCreateS3MutationHook(PutObjectRetentionCommand, "PutObjectRetention", [
-    "GetObjectRetention"
+const useObjectRetention = useCreateS3QueryHook(GetObjectRetentionCommand, 'GetObjectRetention');
+const useSetObjectRetention = useCreateS3MutationHook(PutObjectRetentionCommand, 'PutObjectRetention', [
+    'GetObjectRetention'
 ]);
-const useObjectLegalHold = useCreateS3QueryHook(GetObjectLegalHoldCommand, "GetObjectLegalHold");
-const useSetObjectLegalHold = useCreateS3MutationHook(PutObjectLegalHoldCommand, "PutObjectLegalHold", [
-    "GetObjectLegalHold",
-    "BatchObjectLegalHold"
+const useObjectLegalHold = useCreateS3QueryHook(GetObjectLegalHoldCommand, 'GetObjectLegalHold');
+const useSetObjectLegalHold = useCreateS3MutationHook(PutObjectLegalHoldCommand, 'PutObjectLegalHold', [
+    'GetObjectLegalHold',
+    'BatchObjectLegalHold'
 ]);
-const useObjectTagging = useCreateS3QueryHook(GetObjectTaggingCommand, "GetObjectTagging");
-const useSetObjectTagging = useCreateS3MutationHook(PutObjectTaggingCommand, "PutObjectTagging", [
-    "GetObjectTagging"
+const useObjectTagging = useCreateS3QueryHook(GetObjectTaggingCommand, 'GetObjectTagging');
+const useSetObjectTagging = useCreateS3MutationHook(PutObjectTaggingCommand, 'PutObjectTagging', [
+    'GetObjectTagging'
 ]);
-const useDeleteObjectTagging = useCreateS3MutationHook(DeleteObjectTaggingCommand, "DeleteObjectTagging", [
-    "GetObjectTagging"
+const useDeleteObjectTagging = useCreateS3MutationHook(DeleteObjectTaggingCommand, 'DeleteObjectTagging', [
+    'GetObjectTagging'
 ]);
-const useObjectAcl = useCreateS3QueryHook(GetObjectAclCommand, "GetObjectAcl");
-const useSetObjectAcl = useCreateS3MutationHook(PutObjectAclCommand, "PutObjectAcl", [
-    "GetObjectAcl"
+const useObjectAcl = useCreateS3QueryHook(GetObjectAclCommand, 'GetObjectAcl');
+const useSetObjectAcl = useCreateS3MutationHook(PutObjectAclCommand, 'PutObjectAcl', [
+    'GetObjectAcl'
 ]);
-const useGetObjectAttributes = useCreateS3QueryHook(GetObjectAttributesCommand, "GetObjectAttributes");
-const useGetObjectTorrent = useCreateS3QueryHook(GetObjectTorrentCommand, "GetObjectTorrent");
-const useRestoreObject = useCreateS3MutationHook(RestoreObjectCommand, "RestoreObject", [
-    "HeadObject",
-    "ListObjects"
+const useGetObjectAttributes = useCreateS3QueryHook(GetObjectAttributesCommand, 'GetObjectAttributes');
+const useGetObjectTorrent = useCreateS3QueryHook(GetObjectTorrentCommand, 'GetObjectTorrent');
+const useRestoreObject = useCreateS3MutationHook(RestoreObjectCommand, 'RestoreObject', [
+    'HeadObject',
+    'ListObjects'
 ]);
-const useSelectObjectContent = useCreateS3QueryHook(SelectObjectContentCommand, "SelectObjectContent");
-const useListMultipartUploads = useCreateS3InfiniteQueryHook(ListMultipartUploadsCommand, "ListMultipartUploads");
+const useSelectObjectContent = useCreateS3QueryHook(SelectObjectContentCommand, 'SelectObjectContent');
+const useListMultipartUploads = useCreateS3InfiniteQueryHook(ListMultipartUploadsCommand, 'ListMultipartUploads');
 export { useCopyObject, useCreateFolder, useDeleteObject, useDeleteObjectTagging, useDeleteObjects, useGetObject, useGetObjectAttributes, useGetObjectTorrent, useListMultipartUploads, useListObjectVersions, useListObjects, useObjectAcl, useObjectLegalHold, useObjectMetadata, useObjectRetention, useObjectTagging, usePutObject, useRestoreObject, useSearchObjects, useSearchObjectsVersions, useSelectObjectContent, useSetObjectAcl, useSetObjectLegalHold, useSetObjectRetention, useSetObjectTagging, useUploadObjects };

package/dist/hooks/presignedOperations.d.ts

@@ -6,8 +6,8 @@
  * 2. Get Presigned POST
  * 3. Get Presigned Upload (PUT)
  */
-import { PresignedPostOptions, PresignedPost } from "@aws-sdk/s3-presigned-post";
-import { GetObjectCommandInput, PutObjectCommandInput } from "@aws-sdk/client-s3";
+import { PresignedPostOptions, PresignedPost } from '@aws-sdk/s3-presigned-post';
+import { GetObjectCommandInput, PutObjectCommandInput } from '@aws-sdk/client-s3';
 /**
  * Hook for getting presigned download URLs
  *

package/dist/hooks/presignedOperations.js

@@ -23,7 +23,7 @@ const generatePresignedDownloadUrl = async (client, config)=>{
             VersionId: config.VersionId
         };
     } catch (error) {
-        throw createS3OperationError(error, "GeneratePresignedDownload", config.Bucket, config.Key);
+        throw createS3OperationError(error, 'GeneratePresignedDownload', config.Bucket, config.Key);
     }
 };
 const generatePresignedUploadUrl = async (client, config)=>{
@@ -45,7 +45,7 @@ const generatePresignedUploadUrl = async (client, config)=>{
             Key: Key
         };
     } catch (error) {
-        throw createS3OperationError(error, "GeneratePresignedUpload", config.Bucket, config.Key);
+        throw createS3OperationError(error, 'GeneratePresignedUpload', config.Bucket, config.Key);
     }
 };
 const generatePresignedPost = async (client, config)=>{
@@ -63,7 +63,7 @@ const generatePresignedPost = async (client, config)=>{
             ExpiresAt: expiresAt
         };
     } catch (error) {
-        throw createS3OperationError(error, "GeneratePresignedPost", config.Bucket, config.Key);
+        throw createS3OperationError(error, 'GeneratePresignedPost', config.Bucket, config.Key);
     }
 };
 const useGetPresignedDownload = useCreateS3FunctionMutationHook(generatePresignedDownloadUrl);

package/dist/hooks/useBatchObjectLegalHold.js

@@ -1,18 +1,21 @@
 import { useQuery } from "@tanstack/react-query";
 import { useS3Client } from "./useS3Client.js";
+import { useDataBrowserContext } from "../components/providers/DataBrowserProvider.js";
 import { GetObjectLegalHoldCommand } from "@aws-sdk/client-s3";
 const useBatchObjectLegalHold = (bucketName, objects, enabled = true)=>{
+    const { s3ConfigIdentifier } = useDataBrowserContext();
     const s3Client = useS3Client();
     return useQuery({
         queryKey: [
-            "BatchObjectLegalHold",
+            s3ConfigIdentifier,
+            'BatchObjectLegalHold',
             bucketName,
-            ...objects.map((obj)=>`${obj.Key}:${obj.VersionId || "null"}`)
+            ...objects.map((obj)=>`${obj.Key}:${obj.VersionId || 'null'}`)
         ],
         queryFn: async ()=>{
             const results = {};
             await Promise.allSettled(objects.map(async (obj)=>{
-                const key = `${obj.Key}:${obj.VersionId || "null"}`;
+                const key = `${obj.Key}:${obj.VersionId || 'null'}`;
                 try {
                     const command = new GetObjectLegalHoldCommand({
                         Bucket: bucketName,
@@ -25,7 +28,7 @@ const useBatchObjectLegalHold = (bucketName, objects, enabled = true)=>{
                     results[key] = {
                         key: obj.Key,
                         versionId: obj.VersionId,
-                        isLegalHoldEnabled: response.LegalHold?.Status === "ON"
+                        isLegalHoldEnabled: response.LegalHold?.Status === 'ON'
                     };
                 } catch (error) {
                     results[key] = {

package/dist/hooks/useDataBrowserNavigate.d.ts

@@ -0,0 +1,28 @@
+import { NavigateOptions } from 'react-router';
+/**
+ * Normalizes a path by prefixing it with the basePath.
+ * Handles edge cases like missing slashes, relative paths, and root paths.
+ *
+ * @param basePath - The base path prefix (e.g., "/accounts/my-account/buckets")
+ * @param to - The target path (e.g., "/my-bucket")
+ * @returns The normalized absolute path (e.g., "/accounts/my-account/buckets/my-bucket")
+ */
+export declare const normalizePath: (basePath: string, to: string) => string;
+/**
+ * Hook for navigation with automatic basePath prefixing.
+ * Must be used within DataBrowserUI component.
+ *
+ * This hook wraps react-router's useNavigate and automatically prefixes all
+ * navigation paths with the basePath configured in DataBrowserUI props.
+ * This allows internal navigation to work correctly when DataBrowserUI is
+ * mounted at any route within the application.
+ *
+ * @example
+ * ```tsx
+ * // If DataBrowserUI has basePath="/accounts/my-account/buckets"
+ * const navigate = useDataBrowserNavigate();
+ * navigate('/my-bucket'); // Navigates to "/accounts/my-account/buckets/my-bucket"
+ * navigate(-1); // History navigation works as normal (no prefixing)
+ * ```
+ */
+export declare const useDataBrowserNavigate: () => (to: string | number, options?: NavigateOptions) => void;

package/dist/hooks/useDataBrowserNavigate.js

@@ -0,0 +1,24 @@
+import { useCallback } from "react";
+import { useNavigate } from "react-router";
+import { useDataBrowserUICustomization } from "../contexts/DataBrowserUICustomizationContext.js";
+const normalizePath = (basePath, to)=>{
+    if (!basePath) return to;
+    if (!to.startsWith('/')) return to;
+    const base = basePath.replace(/^\/+|\/+$/g, '');
+    const path = to.replace(/^\/+/, '');
+    if (!path) return base ? `/${base}` : '/';
+    return `/${base}/${path}`.replace(/\/+/g, '/');
+};
+const useDataBrowserNavigate = ()=>{
+    const navigate = useNavigate();
+    const { basePath = '' } = useDataBrowserUICustomization();
+    return useCallback((to, options)=>{
+        if ('number' == typeof to) return void navigate(to);
+        const targetPath = normalizePath(basePath, to);
+        options ? navigate(targetPath, options) : navigate(targetPath);
+    }, [
+        navigate,
+        basePath
+    ]);
+};
+export { normalizePath, useDataBrowserNavigate };

package/dist/hooks/useDeleteBucketConfigRule.d.ts

@@ -1,4 +1,4 @@
-import type { UseMutationResult } from "@tanstack/react-query";
+import type { UseMutationResult } from '@tanstack/react-query';
 interface BucketCommandInput {
     Bucket: string | undefined;
 }
@@ -10,7 +10,7 @@ interface UseDeleteBucketConfigRuleOptions<TRule extends {
     rules: TRule[];
     updateMutation: UseMutationResult<TUpdateOutput, TError, TUpdateInput, unknown>;
     deleteMutation: UseMutationResult<TDeleteOutput, TError, TDeleteInput, unknown>;
-    buildUpdateInput: (remainingRules: TRule[]) => Omit<TUpdateInput, "Bucket">;
+    buildUpdateInput: (remainingRules: TRule[]) => Omit<TUpdateInput, 'Bucket'>;
     successMessage?: string;
     errorMessage?: string;
     onSuccess?: () => void;

package/dist/hooks/useDeleteBucketConfigRule.js

@@ -1,16 +1,16 @@
 import { useToast } from "@scality/core-ui";
-function useDeleteBucketConfigRule({ bucketName, ruleId, rules, updateMutation, deleteMutation, buildUpdateInput, successMessage = "Rule deleted successfully", errorMessage = "Failed to delete rule", onSuccess, onError }) {
+function useDeleteBucketConfigRule({ bucketName, ruleId, rules, updateMutation, deleteMutation, buildUpdateInput, successMessage = 'Rule deleted successfully', errorMessage = 'Failed to delete rule', onSuccess, onError }) {
     const { showToast } = useToast();
     const { mutate: updateConfig, status: updateStatus } = updateMutation;
     const { mutate: deleteConfig, status: deleteStatus } = deleteMutation;
-    const isDeleting = "pending" === updateStatus || "pending" === deleteStatus;
+    const isDeleting = 'pending' === updateStatus || 'pending' === deleteStatus;
     const deleteRule = ()=>{
         const remainingRules = rules.filter((rule)=>rule.ID !== ruleId);
         const handleSuccess = ()=>{
             showToast({
                 open: true,
                 message: successMessage,
-                status: "success"
+                status: 'success'
             });
             onSuccess?.();
         };
@@ -20,7 +20,7 @@ function useDeleteBucketConfigRule({ bucketName, ruleId, rules, updateMutation,
             showToast({
                 open: true,
                 message: displayMessage,
-                status: "error"
+                status: 'error'
             });
             onError?.(errorToReport);
         };

package/dist/hooks/useEmptyBucket.js

@@ -1,6 +1,6 @@
 import { useCallback, useState } from "react";
-import { useQueryClient } from "@tanstack/react-query";
 import { useS3Client } from "./useS3Client.js";
+import { useInvalidateQueries } from "../components/providers/DataBrowserProvider.js";
 import { DeleteObjectsCommand, ListObjectVersionsCommand } from "@aws-sdk/client-s3";
 const useEmptyBucket = (options = {})=>{
     const { maxObjects = 20000, maxKeysPerList = 1000, bypassGovernanceRetention = true, onProgress, onSuccess, onError } = options;
@@ -8,7 +8,7 @@ const useEmptyBucket = (options = {})=>{
     const [error, setError] = useState(null);
     const [result, setResult] = useState(null);
     const s3Client = useS3Client();
-    const queryClient = useQueryClient();
+    const invalidateQueries = useInvalidateQueries();
     const emptyBucket = useCallback(async (bucketName)=>{
         setIsEmptying(true);
         setError(null);
@@ -50,7 +50,7 @@ const useEmptyBucket = (options = {})=>{
                 deletedCount += successCount;
                 totalAttempted += objectsToDelete.length;
                 if (deleteResponse.Errors) allErrors.push(...deleteResponse.Errors.map((error)=>({
-                        key: error.Key || "unknown",
+                        key: error.Key || 'unknown',
                         code: error.Code,
                         message: error.Message
                     })));
@@ -70,20 +70,20 @@ const useEmptyBucket = (options = {})=>{
                 limitReached
             };
             setResult(bucketResult);
-            queryClient.invalidateQueries({
+            invalidateQueries({
                 queryKey: [
-                    "ListObjects"
+                    'ListObjects'
                 ]
             });
-            queryClient.invalidateQueries({
+            invalidateQueries({
                 queryKey: [
-                    "ListObjectVersions"
+                    'ListObjectVersions'
                 ]
             });
             onSuccess?.(bucketResult);
             return bucketResult;
         } catch (err) {
-            const errorObj = err instanceof Error ? err : new Error("Failed to empty bucket");
+            const errorObj = err instanceof Error ? err : new Error('Failed to empty bucket');
             setError(errorObj);
             onError?.(errorObj);
             return null;
@@ -92,13 +92,13 @@ const useEmptyBucket = (options = {})=>{
         }
     }, [
         s3Client,
+        invalidateQueries,
         maxObjects,
         maxKeysPerList,
         bypassGovernanceRetention,
         onProgress,
         onSuccess,
-        onError,
-        queryClient
+        onError
     ]);
     const reset = useCallback(()=>{
         setIsEmptying(false);

package/dist/hooks/useFeatures.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Hook to check if a feature is enabled in the S3 configuration.
+ *
+ * @param feature - The feature name to check
+ * @returns true if enabled, false if disabled, undefined if config not available
+ */
+export declare function useFeatures(feature: string): boolean | undefined;

package/dist/hooks/useFeatures.js

@@ -0,0 +1,8 @@
+import { useDataBrowserContext } from "../components/providers/DataBrowserProvider.js";
+function useFeatures(feature) {
+    const { getS3Config } = useDataBrowserContext();
+    if (!getS3Config) return;
+    const config = getS3Config();
+    return config.features?.includes(feature) ?? false;
+}
+export { useFeatures };

package/dist/hooks/useISVBucketDetection.js

@@ -1,12 +1,12 @@
 import { useGetBucketTagging } from "./bucketConfiguration.js";
-import { useFeatures } from "../utils/useFeatures.js";
+import { useFeatures } from "./useFeatures.js";
 import { BUCKET_TAG_APPLICATION, BUCKET_TAG_VEEAM_APPLICATION, COMMVAULT_APPLICATION, VEEAM_BACKUP_REPLICATION, VEEAM_OFFICE_365, VEEAM_OFFICE_365_V8, VEEAM_VBO_APPLICATION } from "../utils/constants.js";
 const useISVBucketStatus = (bucketName)=>{
-    const isISVFeatureEnabled = useFeatures("ISV");
+    const isISVFeatureEnabled = useFeatures('ISV');
     const { data: bucketTags, status: bucketTagsStatus } = useGetBucketTagging({
         Bucket: bucketName
     }, {
-        enabled: isISVFeatureEnabled
+        enabled: true === isISVFeatureEnabled
     });
     const veeamTagApplication = bucketTags?.TagSet?.find((tag)=>tag.Key === BUCKET_TAG_VEEAM_APPLICATION)?.Value;
     const ISVApplicationTag = bucketTags?.TagSet?.find((tag)=>tag.Key === BUCKET_TAG_APPLICATION)?.Value;
@@ -19,8 +19,8 @@ const useISVBucketStatus = (bucketName)=>{
         isVeeamBucket: isVeeam,
         isCommvaultBucket,
         isISVManaged,
-        isvApplication: isCommvaultBucket ? "Commvault" : isVeeam ? "Veeam" : void 0,
-        isLoading: isISVFeatureEnabled && "pending" === bucketTagsStatus,
+        isvApplication: isCommvaultBucket ? 'Commvault' : isVeeam ? 'Veeam' : void 0,
+        isLoading: isISVFeatureEnabled && 'pending' === bucketTagsStatus,
         bucketTagsStatus
     };
 };

package/dist/hooks/useIsBucketEmpty.js

@@ -1,16 +1,16 @@
 import { useMemo } from "react";
 import { useListObjects } from "./objectOperations.js";
-const isInfiniteData = (data)=>null != data && "object" == typeof data && "pages" in data && Array.isArray(data.pages);
+const isInfiniteData = (data)=>null != data && 'object' == typeof data && 'pages' in data && Array.isArray(data.pages);
 const useIsBucketEmpty = (bucketName)=>{
     const { data, status, error } = useListObjects({
         Bucket: bucketName,
         MaxKeys: 1,
-        Delimiter: "/"
+        Delimiter: '/'
     }, {
         enabled: !!bucketName
     });
     const isEmpty = useMemo(()=>{
-        if ("pending" === status || !data) return null;
+        if ('pending' === status || !data) return null;
         if (!isInfiniteData(data)) return null;
         for (const page of data.pages){
             if (page?.Contents && page.Contents.length > 0) {
@@ -29,7 +29,7 @@ const useIsBucketEmpty = (bucketName)=>{
     ]);
     return {
         isEmpty,
-        isLoading: "pending" === status,
+        isLoading: 'pending' === status,
         error: error instanceof Error ? error : null
     };
 };

package/dist/hooks/useLoginMutation.d.ts

@@ -4,7 +4,7 @@
  * This file contains the login authentication hook using the factory pattern
  * for consistency with other S3 operations.
  */
-import { S3BrowserConfig, S3Credentials } from "../types";
+import { S3BrowserConfig, S3Credentials } from '../types';
 export type LoginConfig = S3BrowserConfig & {
     credentials: S3Credentials;
 };

package/dist/hooks/useLoginMutation.js

@@ -5,5 +5,5 @@ class LoginAuthenticationCommand {
         this.input = input;
     }
 }
-const useLoginMutation = useCreateS3LoginHook(LoginAuthenticationCommand, "S3 Authentication");
+const useLoginMutation = useCreateS3LoginHook(LoginAuthenticationCommand, 'S3 Authentication');
 export { useLoginMutation };

package/dist/hooks/useS3Client.d.ts

@@ -1 +1,7 @@
+/**
+ * Hook to get the S3 client instance.
+ *
+ * Recreates client only when s3ConfigIdentifier changes.
+ * The client is memoized to avoid unnecessary recreations.
+ */
 export declare const useS3Client: () => import("@aws-sdk/client-s3").S3Client;

package/dist/hooks/useS3Client.js

@@ -2,12 +2,13 @@ import { useMemo } from "react";
 import { useDataBrowserContext } from "../components/providers/DataBrowserProvider.js";
 import { createS3Client } from "../utils/s3Client.js";
 const useS3Client = ()=>{
-    const { getS3Config } = useDataBrowserContext();
+    const { s3ConfigIdentifier, getS3Config } = useDataBrowserContext();
+    if (!getS3Config) throw new Error('useS3Client: S3 config not available. Ensure DataBrowserProvider has getS3Config prop set.');
     return useMemo(()=>{
         const config = getS3Config();
         return createS3Client(config);
     }, [
-        getS3Config
+        s3ConfigIdentifier
     ]);
 };
 export { useS3Client };

package/dist/hooks/useS3ConfigSwitch.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Hook that handles navigation and query cleanup when S3 config changes.
+ * Must be used inside both DataBrowserProvider and DataBrowserUICustomizationProvider.
+ *
+ * When the S3 config identifier changes:
+ * - Navigates to the buckets page first (to trigger component unmounting)
+ * - Clears all queries associated with the previous config (after navigation)
+ *
+ * @internal This hook is designed for internal use within DataBrowserUI only.
+ */
+export declare const useS3ConfigSwitch: () => void;

package/dist/hooks/useS3ConfigSwitch.js

@@ -0,0 +1,37 @@
+import { useEffect, useRef } from "react";
+import { useNavigate } from "react-router";
+import { useQueryClient } from "@tanstack/react-query";
+import { useDataBrowserContext } from "../components/providers/DataBrowserProvider.js";
+import { useDataBrowserUICustomization } from "../contexts/DataBrowserUICustomizationContext.js";
+import { normalizePath } from "./useDataBrowserNavigate.js";
+const useS3ConfigSwitch = ()=>{
+    const { s3ConfigIdentifier } = useDataBrowserContext();
+    const { basePath = '' } = useDataBrowserUICustomization();
+    const queryClient = useQueryClient();
+    const navigate = useNavigate();
+    const prevConfigIdRef = useRef();
+    useEffect(()=>{
+        if (void 0 !== prevConfigIdRef.current && prevConfigIdRef.current !== s3ConfigIdentifier) {
+            const previousConfigId = prevConfigIdRef.current;
+            const bucketsPath = normalizePath(basePath, '/buckets');
+            navigate(bucketsPath, {
+                replace: true
+            });
+            queueMicrotask(()=>{
+                queryClient.removeQueries({
+                    queryKey: [
+                        previousConfigId
+                    ],
+                    exact: false
+                });
+            });
+        }
+        prevConfigIdRef.current = s3ConfigIdentifier;
+    }, [
+        s3ConfigIdentifier,
+        navigate,
+        basePath,
+        queryClient
+    ]);
+};
+export { useS3ConfigSwitch };

package/dist/hooks/useSupportedNotificationEvents.d.ts

@@ -0,0 +1,6 @@
+import type { S3EventType } from '../config/types';
+/**
+ * Hook to get supported notification events from the DataBrowser configuration
+ * If no supported events are configured, returns undefined (meaning all events are supported)
+ */
+export declare function useSupportedNotificationEvents(): S3EventType[] | undefined;

package/dist/hooks/useSupportedNotificationEvents.js

@@ -0,0 +1,8 @@
+import { useDataBrowserContext } from "../components/providers/DataBrowserProvider.js";
+function useSupportedNotificationEvents() {
+    const { getS3Config } = useDataBrowserContext();
+    if (!getS3Config) return;
+    const config = getS3Config();
+    return config?.supportedNotificationEvents;
+}
+export { useSupportedNotificationEvents };

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-export * from "./components";
-export * from "./hooks";
-export * from "./types";
-export * from "./utils";
-export * from "./config/factory";
-export * from "./config/types";
+export * from './components';
+export * from './hooks';
+export * from './types';
+export * from './utils';
+export * from './config/factory';
+export * from './config/types';

package/dist/test/msw/handlers/deleteBucket.d.ts

@@ -1 +1 @@
-export declare const deleteBucketHandler: import("msw").RestHandler<import("msw").MockedRequest<import("msw").DefaultRequestBody>>;
+export declare const deleteBucketHandler: import("msw").HttpHandler;

package/dist/test/msw/handlers/deleteBucket.js

@@ -1,14 +1,24 @@
-import { rest } from "msw";
+import { HttpResponse, http } from "msw";
 import { createS3ErrorXml, getS3BaseUrl } from "../utils.js";
-const deleteBucketHandler = rest["delete"](`${getS3BaseUrl()}/:bucketName`, (req, res, ctx)=>{
-    const { bucketName } = req.params;
-    if ("string" == typeof bucketName) {
-        if (bucketName.includes("non-existent-bucket")) return res(ctx.status(404), ctx.xml(createS3ErrorXml("NoSuchBucket", "The specified bucket does not exist", bucketName)));
-        if (bucketName.includes("bucket-not-empty")) return res(ctx.status(409), ctx.xml(createS3ErrorXml("BucketNotEmpty", "The bucket you tried to delete is not empty", bucketName)));
-        if (bucketName.includes("restricted-bucket")) return res(ctx.status(403), ctx.xml(createS3ErrorXml("AccessDenied", "Access Denied")));
-        if (bucketName.includes("network-error-bucket")) return res.networkError("Failed to connect");
-        if (bucketName.includes("error-callback-bucket")) return res(ctx.status(500), ctx.xml(createS3ErrorXml("InternalError", "We encountered an internal error. Please try again.")));
+const deleteBucketHandler = http["delete"](`${getS3BaseUrl()}/:bucketName`, async ({ params })=>{
+    const { bucketName } = params;
+    if ('string' == typeof bucketName) {
+        if (bucketName.includes('non-existent-bucket')) return HttpResponse.xml(createS3ErrorXml('NoSuchBucket', 'The specified bucket does not exist', bucketName), {
+            status: 404
+        });
+        if (bucketName.includes('bucket-not-empty')) return HttpResponse.xml(createS3ErrorXml('BucketNotEmpty', 'The bucket you tried to delete is not empty', bucketName), {
+            status: 409
+        });
+        if (bucketName.includes('restricted-bucket')) return HttpResponse.xml(createS3ErrorXml('AccessDenied', 'Access Denied'), {
+            status: 403
+        });
+        if (bucketName.includes('network-error-bucket')) return HttpResponse.error();
+        if (bucketName.includes('error-callback-bucket')) return HttpResponse.xml(createS3ErrorXml('InternalError', 'We encountered an internal error. Please try again.'), {
+            status: 500
+        });
     }
-    return res(ctx.status(204));
+    return new Response(null, {
+        status: 204
+    });
 });
 export { deleteBucketHandler };

package/dist/test/msw/handlers/getBucketAcl.d.ts

@@ -1 +1 @@
-export declare const getBucketAclHandler: import("msw").RestHandler<import("msw").MockedRequest<import("msw").DefaultRequestBody>>;
+export declare const getBucketAclHandler: import("msw").HttpHandler;