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

package/dist/hooks/factories/useCreateS3MutationHook.js

@@ -1,8 +1,10 @@
 import { useMutation, useQueryClient } from "@tanstack/react-query";
-import { useS3Client } from "../useS3Client.js";
+import { useDataBrowserContext } from "../../components/providers/DataBrowserProvider.js";
 import { createS3OperationError } from "../../utils/errorHandling.js";
+import { useS3Client } from "../useS3Client.js";
 function useCreateS3MutationHook(Command, operationName, invalidationKeys) {
     return (options)=>{
+        const { s3ConfigIdentifier } = useDataBrowserContext();
         const s3Client = useS3Client();
         const queryClient = useQueryClient();
         return useMutation({
@@ -11,7 +13,7 @@ function useCreateS3MutationHook(Command, operationName, invalidationKeys) {
                     const command = new Command(params);
                     return await s3Client.send(command);
                 } catch (error) {
-                    const bucketName = "Bucket" in params ? params.Bucket : void 0;
+                    const bucketName = 'Bucket' in params ? params.Bucket : void 0;
                     throw createS3OperationError(error, operationName, bucketName);
                 }
             },
@@ -19,6 +21,7 @@ function useCreateS3MutationHook(Command, operationName, invalidationKeys) {
                 if (invalidationKeys) invalidationKeys.forEach((key)=>{
                     queryClient.invalidateQueries({
                         queryKey: [
+                            s3ConfigIdentifier,
                             key
                         ]
                     });
@@ -30,6 +33,7 @@ function useCreateS3MutationHook(Command, operationName, invalidationKeys) {
 }
 function useCreateS3FunctionMutationHook(operation, invalidationKeys) {
     return (options)=>{
+        const { s3ConfigIdentifier } = useDataBrowserContext();
         const s3Client = useS3Client();
         const queryClient = useQueryClient();
         return useMutation({
@@ -38,6 +42,7 @@ function useCreateS3FunctionMutationHook(operation, invalidationKeys) {
                 if (invalidationKeys) invalidationKeys.forEach((key)=>{
                     queryClient.invalidateQueries({
                         queryKey: [
+                            s3ConfigIdentifier,
                             key
                         ]
                     });

package/dist/hooks/factories/useCreateS3QueryHook.d.ts

@@ -1,3 +1,3 @@
-import { QueryKey, UseQueryOptions, UseQueryResult } from "@tanstack/react-query";
-import { EnhancedS3Error } from "../../utils/errorHandling";
+import { type QueryKey, type UseQueryOptions, type UseQueryResult } from '@tanstack/react-query';
+import { type EnhancedS3Error } from '../../utils/errorHandling';
 export declare function useCreateS3QueryHook<TInput extends object, TOutput>(Command: new (input: TInput) => any, operationName: string): (params?: TInput, options?: Omit<UseQueryOptions<TOutput, EnhancedS3Error, TOutput, QueryKey>, "queryKey" | "queryFn">) => UseQueryResult<TOutput, EnhancedS3Error>;

package/dist/hooks/factories/useCreateS3QueryHook.js

@@ -1,13 +1,35 @@
 import { useQuery } from "@tanstack/react-query";
+import { useDataBrowserContext } from "../../components/providers/DataBrowserProvider.js";
+import { createS3OperationError, isNotFoundError, shouldRetryError } from "../../utils/errorHandling.js";
 import { useS3Client } from "../useS3Client.js";
-import { createS3OperationError, shouldRetryError } from "../../utils/errorHandling.js";
+function getEmptyConfigForOperation(operationName) {
+    switch(operationName){
+        case 'GetBucketLifecycleConfiguration':
+            return {
+                Rules: []
+            };
+        case 'GetBucketReplication':
+            return {
+                ReplicationConfiguration: {
+                    Rules: [],
+                    Role: ''
+                }
+            };
+        case 'GetPublicAccessBlock':
+            return {};
+        default:
+            return null;
+    }
+}
 function useCreateS3QueryHook(Command, operationName) {
     return (params, options)=>{
+        const { s3ConfigIdentifier } = useDataBrowserContext();
+        const s3Client = useS3Client();
         const queryKey = [
+            s3ConfigIdentifier,
             operationName,
             params
         ];
-        const s3Client = useS3Client();
         return useQuery({
             queryKey,
             queryFn: async ({ signal })=>{
@@ -17,7 +39,11 @@ function useCreateS3QueryHook(Command, operationName) {
                         abortSignal: signal
                     });
                 } catch (error) {
-                    const bucketName = params && "Bucket" in params ? params.Bucket : void 0;
+                    const bucketName = params && 'Bucket' in params ? params.Bucket : void 0;
+                    if (isNotFoundError(error)) {
+                        const emptyConfig = getEmptyConfigForOperation(operationName);
+                        if (null !== emptyConfig) return emptyConfig;
+                    }
                     throw createS3OperationError(error, operationName, bucketName);
                 }
             },

package/dist/hooks/index.d.ts

@@ -1,8 +1,19 @@
-export { useS3Client } from "./useS3Client";
-export type { LoginConfig, LoginMutationResult } from "./useLoginMutation";
-export { useLoginMutation } from "./loginOperations";
-export { useIsBucketEmpty } from "./useIsBucketEmpty";
-export { useBuckets, useGetBucketLocation, useCreateBucket, useDeleteBucket, } from "./bucketOperations";
-export { useGetBucketAcl, useSetBucketAcl, useGetBucketPolicy, useSetBucketPolicy, useDeleteBucketPolicy, useGetBucketVersioning, useSetBucketVersioning, useGetBucketCors, useSetBucketCors, useDeleteBucketCors, useGetBucketLifecycle, useSetBucketLifecycle, useDeleteBucketLifecycle, useGetBucketNotification, useSetBucketNotification, useGetBucketEncryption, useSetBucketEncryption, useGetBucketTagging, useSetBucketTagging, useDeleteBucketTagging, useGetBucketObjectLockConfiguration, useSetBucketObjectLockConfiguration, useGetBucketReplication, useSetBucketReplication, useDeleteBucketReplication, } from "./bucketConfiguration";
-export { useListObjects, useListObjectVersions, useObjectMetadata, useObjectRetention, useGetObject, usePutObject, useCreateFolder, useUploadObjects, useDeleteObject, useDeleteObjects, useCopyObject, useSetObjectRetention, useObjectLegalHold, useSetObjectLegalHold, useObjectTagging, useSetObjectTagging, useDeleteObjectTagging, useObjectAcl, useSetObjectAcl, useGetObjectAttributes, useGetObjectTorrent, useRestoreObject, useSelectObjectContent, useListMultipartUploads, useSearchObjects, useSearchObjectsVersions, } from "./objectOperations";
-export { useGetPresignedDownload, useGetPresignedUpload, useGetPresignedPost, } from "./presignedOperations";
+export { useDeleteBucketCors, useDeleteBucketLifecycle, useDeleteBucketPolicy, useDeleteBucketReplication, useDeleteBucketTagging, useGetBucketAcl, useGetBucketCors, useGetBucketEncryption, useGetBucketLifecycle, useGetBucketNotification, useGetBucketObjectLockConfiguration, useGetBucketPolicy, useGetBucketReplication, useGetBucketTagging, useGetBucketVersioning, useGetPublicAccessBlock, useSetBucketAcl, useSetBucketCors, useSetBucketEncryption, useSetBucketLifecycle, useSetBucketNotification, useSetBucketObjectLockConfiguration, useSetBucketPolicy, useSetBucketReplication, useSetBucketTagging, useSetBucketVersioning, } from './bucketConfiguration';
+export { useBuckets, useCreateBucket, useDeleteBucket, useGetBucketLocation, useValidateBucketAccess, } from './bucketOperations';
+export type { LoginConfig, LoginMutationResult } from './loginOperations';
+export { useLoginMutation } from './loginOperations';
+export { useCopyObject, useCreateFolder, useDeleteObject, useDeleteObjects, useDeleteObjectTagging, useGetObject, useGetObjectAttributes, useGetObjectTorrent, useListMultipartUploads, useListObjects, useListObjectVersions, useObjectAcl, useObjectLegalHold, useObjectMetadata, useObjectRetention, useObjectTagging, usePutObject, useRestoreObject, useSearchObjects, useSearchObjectsVersions, useSelectObjectContent, useSetObjectAcl, useSetObjectLegalHold, useSetObjectRetention, useSetObjectTagging, useUploadObjects, } from './objectOperations';
+export { useGetPresignedDownload, useGetPresignedPost, useGetPresignedUpload, } from './presignedOperations';
+export { getAccessibleBucketsStorageKey, getLimitedAccessFlagKey, setLimitedAccessFlag, useAccessibleBuckets, } from './useAccessibleBuckets';
+export { useBatchObjectLegalHold } from './useBatchObjectLegalHold';
+export { type BucketConfigEditorConfig, type BucketConfigEditorResult, useBucketConfigEditor, } from './useBucketConfigEditor';
+export { useDeleteBucketConfigRule } from './useDeleteBucketConfigRule';
+export { useEmptyBucket } from './useEmptyBucket';
+export { useFeatures } from './useFeatures';
+export { useISVBucketStatus } from './useISVBucketDetection';
+export { useIsBucketEmpty } from './useIsBucketEmpty';
+export { type LimitedAccessFlowHandlers, type UseLimitedAccessFlowOptions, useLimitedAccessFlow, } from './useLimitedAccessFlow';
+export { useS3Client } from './useS3Client';
+export { useS3ConfigSwitch } from './useS3ConfigSwitch';
+export { useSupportedNotificationEvents } from './useSupportedNotificationEvents';
+export { useTableRowSelection } from './useTableRowSelection';

package/dist/hooks/index.js

@@ -1,8 +1,19 @@
-import { useS3Client } from "./useS3Client.js";
+import { useDeleteBucketCors, useDeleteBucketLifecycle, useDeleteBucketPolicy, useDeleteBucketReplication, useDeleteBucketTagging, useGetBucketAcl, useGetBucketCors, useGetBucketEncryption, useGetBucketLifecycle, useGetBucketNotification, useGetBucketObjectLockConfiguration, useGetBucketPolicy, useGetBucketReplication, useGetBucketTagging, useGetBucketVersioning, useGetPublicAccessBlock, useSetBucketAcl, useSetBucketCors, useSetBucketEncryption, useSetBucketLifecycle, useSetBucketNotification, useSetBucketObjectLockConfiguration, useSetBucketPolicy, useSetBucketReplication, useSetBucketTagging, useSetBucketVersioning } from "./bucketConfiguration.js";
+import { useBuckets, useCreateBucket, useDeleteBucket, useGetBucketLocation, useValidateBucketAccess } from "./bucketOperations.js";
 import { useLoginMutation } from "./loginOperations.js";
-import { useIsBucketEmpty } from "./useIsBucketEmpty.js";
-import { useBuckets, useCreateBucket, useDeleteBucket, useGetBucketLocation } from "./bucketOperations.js";
-import { useDeleteBucketCors, useDeleteBucketLifecycle, useDeleteBucketPolicy, useDeleteBucketReplication, useDeleteBucketTagging, useGetBucketAcl, useGetBucketCors, useGetBucketEncryption, useGetBucketLifecycle, useGetBucketNotification, useGetBucketObjectLockConfiguration, useGetBucketPolicy, useGetBucketReplication, useGetBucketTagging, useGetBucketVersioning, useSetBucketAcl, useSetBucketCors, useSetBucketEncryption, useSetBucketLifecycle, useSetBucketNotification, useSetBucketObjectLockConfiguration, useSetBucketPolicy, useSetBucketReplication, useSetBucketTagging, useSetBucketVersioning } from "./bucketConfiguration.js";
 import { 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 } from "./objectOperations.js";
 import { useGetPresignedDownload, useGetPresignedPost, useGetPresignedUpload } from "./presignedOperations.js";
-export { useBuckets, useCopyObject, useCreateBucket, useCreateFolder, useDeleteBucket, useDeleteBucketCors, useDeleteBucketLifecycle, useDeleteBucketPolicy, useDeleteBucketReplication, useDeleteBucketTagging, useDeleteObject, useDeleteObjectTagging, useDeleteObjects, useGetBucketAcl, useGetBucketCors, useGetBucketEncryption, useGetBucketLifecycle, useGetBucketLocation, useGetBucketNotification, useGetBucketObjectLockConfiguration, useGetBucketPolicy, useGetBucketReplication, useGetBucketTagging, useGetBucketVersioning, useGetObject, useGetObjectAttributes, useGetObjectTorrent, useGetPresignedDownload, useGetPresignedPost, useGetPresignedUpload, useIsBucketEmpty, useListMultipartUploads, useListObjectVersions, useListObjects, useLoginMutation, useObjectAcl, useObjectLegalHold, useObjectMetadata, useObjectRetention, useObjectTagging, usePutObject, useRestoreObject, useS3Client, useSearchObjects, useSearchObjectsVersions, useSelectObjectContent, useSetBucketAcl, useSetBucketCors, useSetBucketEncryption, useSetBucketLifecycle, useSetBucketNotification, useSetBucketObjectLockConfiguration, useSetBucketPolicy, useSetBucketReplication, useSetBucketTagging, useSetBucketVersioning, useSetObjectAcl, useSetObjectLegalHold, useSetObjectRetention, useSetObjectTagging, useUploadObjects };
+import { getAccessibleBucketsStorageKey, getLimitedAccessFlagKey, setLimitedAccessFlag, useAccessibleBuckets } from "./useAccessibleBuckets.js";
+import { useBatchObjectLegalHold } from "./useBatchObjectLegalHold.js";
+import { useBucketConfigEditor } from "./useBucketConfigEditor.js";
+import { useDeleteBucketConfigRule } from "./useDeleteBucketConfigRule.js";
+import { useEmptyBucket } from "./useEmptyBucket.js";
+import { useFeatures } from "./useFeatures.js";
+import { useISVBucketStatus } from "./useISVBucketDetection.js";
+import { useIsBucketEmpty } from "./useIsBucketEmpty.js";
+import { useLimitedAccessFlow } from "./useLimitedAccessFlow.js";
+import { useS3Client } from "./useS3Client.js";
+import { useS3ConfigSwitch } from "./useS3ConfigSwitch.js";
+import { useSupportedNotificationEvents } from "./useSupportedNotificationEvents.js";
+import { useTableRowSelection } from "./useTableRowSelection.js";
+export { getAccessibleBucketsStorageKey, getLimitedAccessFlagKey, setLimitedAccessFlag, useAccessibleBuckets, useBatchObjectLegalHold, useBucketConfigEditor, useBuckets, useCopyObject, useCreateBucket, useCreateFolder, useDeleteBucket, useDeleteBucketConfigRule, useDeleteBucketCors, useDeleteBucketLifecycle, useDeleteBucketPolicy, useDeleteBucketReplication, useDeleteBucketTagging, useDeleteObject, useDeleteObjectTagging, useDeleteObjects, useEmptyBucket, useFeatures, useGetBucketAcl, useGetBucketCors, useGetBucketEncryption, useGetBucketLifecycle, useGetBucketLocation, useGetBucketNotification, useGetBucketObjectLockConfiguration, useGetBucketPolicy, useGetBucketReplication, useGetBucketTagging, useGetBucketVersioning, useGetObject, useGetObjectAttributes, useGetObjectTorrent, useGetPresignedDownload, useGetPresignedPost, useGetPresignedUpload, useGetPublicAccessBlock, useISVBucketStatus, useIsBucketEmpty, useLimitedAccessFlow, useListMultipartUploads, useListObjectVersions, useListObjects, useLoginMutation, useObjectAcl, useObjectLegalHold, useObjectMetadata, useObjectRetention, useObjectTagging, usePutObject, useRestoreObject, useS3Client, useS3ConfigSwitch, useSearchObjects, useSearchObjectsVersions, useSelectObjectContent, useSetBucketAcl, useSetBucketCors, useSetBucketEncryption, useSetBucketLifecycle, useSetBucketNotification, useSetBucketObjectLockConfiguration, useSetBucketPolicy, useSetBucketReplication, useSetBucketTagging, useSetBucketVersioning, useSetObjectAcl, useSetObjectLegalHold, useSetObjectRetention, useSetObjectTagging, useSupportedNotificationEvents, useTableRowSelection, useUploadObjects, useValidateBucketAccess };

package/dist/hooks/loginOperations.d.ts

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

package/dist/hooks/loginOperations.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/objectOperations.d.ts

@@ -5,8 +5,8 @@
  * metadata retrieval, uploads, downloads, deletion, and object-level
  * configurations like retention and legal hold.
  */
-import { CopyObjectCommandInput, CopyObjectCommandOutput, DeleteObjectCommandInput, DeleteObjectCommandOutput, DeleteObjectsCommandInput, DeleteObjectsCommandOutput, DeleteObjectTaggingCommandInput, DeleteObjectTaggingCommandOutput, GetObjectAclCommandInput, GetObjectAclCommandOutput, GetObjectAttributesCommandInput, GetObjectAttributesCommandOutput, GetObjectCommandInput, GetObjectCommandOutput, GetObjectLegalHoldCommandInput, GetObjectLegalHoldCommandOutput, GetObjectRetentionCommandInput, GetObjectRetentionCommandOutput, GetObjectTaggingCommandInput, GetObjectTaggingCommandOutput, GetObjectTorrentCommandInput, GetObjectTorrentCommandOutput, HeadObjectCommandInput, HeadObjectCommandOutput, ListMultipartUploadsCommandInput, ListMultipartUploadsCommandOutput, ListObjectsV2CommandInput, ListObjectVersionsCommandInput, PutObjectAclCommandInput, PutObjectAclCommandOutput, PutObjectCommandInput, PutObjectCommandOutput, PutObjectLegalHoldCommandInput, PutObjectLegalHoldCommandOutput, PutObjectRetentionCommandInput, PutObjectRetentionCommandOutput, PutObjectTaggingCommandInput, PutObjectTaggingCommandOutput, RestoreObjectCommandInput, RestoreObjectCommandOutput, SelectObjectContentCommandInput, SelectObjectContentCommandOutput } from "@aws-sdk/client-s3";
-import { SearchObjectsV2CommandInput, SearchObjectsVersionCommandInput } from "@scality/zenkoclient";
+import { type CopyObjectCommandInput, type CopyObjectCommandOutput, type DeleteObjectCommandInput, type DeleteObjectCommandOutput, type DeleteObjectsCommandInput, type DeleteObjectsCommandOutput, type DeleteObjectTaggingCommandInput, type DeleteObjectTaggingCommandOutput, type GetObjectAclCommandInput, type GetObjectAclCommandOutput, type GetObjectAttributesCommandInput, type GetObjectAttributesCommandOutput, type GetObjectCommandInput, type GetObjectCommandOutput, type GetObjectLegalHoldCommandInput, type GetObjectLegalHoldCommandOutput, type GetObjectRetentionCommandInput, type GetObjectRetentionCommandOutput, type GetObjectTaggingCommandInput, type GetObjectTaggingCommandOutput, type GetObjectTorrentCommandInput, type GetObjectTorrentCommandOutput, type HeadObjectCommandInput, type HeadObjectCommandOutput, type ListMultipartUploadsCommandInput, type ListMultipartUploadsCommandOutput, type ListObjectsV2CommandInput, type ListObjectVersionsCommandInput, type PutObjectAclCommandInput, type PutObjectAclCommandOutput, type PutObjectCommandInput, type PutObjectCommandOutput, type PutObjectLegalHoldCommandInput, type PutObjectLegalHoldCommandOutput, type PutObjectRetentionCommandInput, type PutObjectRetentionCommandOutput, type PutObjectTaggingCommandInput, type PutObjectTaggingCommandOutput, type RestoreObjectCommandInput, type RestoreObjectCommandOutput, type SelectObjectContentCommandInput, type SelectObjectContentCommandOutput } from '@aws-sdk/client-s3';
+import { type SearchObjectsV2CommandInput, type SearchObjectsVersionCommandInput } from '@scality/zenkoclient';
 /**
  * Hook for listing S3 objects with infinite scroll support
  *

package/dist/hooks/objectOperations.js

@@ -1,66 +1,67 @@
 import { CopyObjectCommand, DeleteObjectCommand, DeleteObjectTaggingCommand, DeleteObjectsCommand, GetObjectAclCommand, GetObjectAttributesCommand, GetObjectCommand, GetObjectLegalHoldCommand, GetObjectRetentionCommand, GetObjectTaggingCommand, GetObjectTorrentCommand, HeadObjectCommand, ListMultipartUploadsCommand, ListObjectVersionsCommand, ListObjectsV2Command, PutObjectAclCommand, PutObjectCommand, PutObjectLegalHoldCommand, PutObjectRetentionCommand, PutObjectTaggingCommand, RestoreObjectCommand, SelectObjectContentCommand } from "@aws-sdk/client-s3";
+import { SearchObjectsV2Command, SearchObjectsVersionCommand } from "@scality/zenkoclient";
 import { useCreateS3InfiniteQueryHook } from "./factories/useCreateS3InfiniteQueryHook.js";
 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"
+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 { type GetObjectCommandInput, type PutObjectCommandInput } from '@aws-sdk/client-s3';
+import { type PresignedPost, type PresignedPostOptions } from '@aws-sdk/s3-presigned-post';
 /**
  * Hook for getting presigned download URLs
  *
@@ -64,10 +64,10 @@ export declare const useGetPresignedPost: (options?: Omit<import("@tanstack/reac
     Bucket: string;
     Key: string;
     expiresIn?: number;
-} & Omit<PresignedPostOptions, "Expires" | "Bucket" | "Key">, unknown>, "mutationFn"> | undefined) => import("@tanstack/react-query").UseMutationResult<PresignedPost & {
+} & Omit<PresignedPostOptions, "Bucket" | "Expires" | "Key">, unknown>, "mutationFn"> | undefined) => import("@tanstack/react-query").UseMutationResult<PresignedPost & {
     ExpiresAt: Date;
 }, import("../utils/errorHandling").EnhancedS3Error, {
     Bucket: string;
     Key: string;
     expiresIn?: number;
-} & Omit<PresignedPostOptions, "Expires" | "Bucket" | "Key">>;
+} & Omit<PresignedPostOptions, "Bucket" | "Expires" | "Key">>;

package/dist/hooks/presignedOperations.js

@@ -1,6 +1,6 @@
-import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
-import { createPresignedPost } from "@aws-sdk/s3-presigned-post";
 import { GetObjectCommand, PutObjectCommand } from "@aws-sdk/client-s3";
+import { createPresignedPost } from "@aws-sdk/s3-presigned-post";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
 import { createS3OperationError } from "../utils/errorHandling.js";
 import { useCreateS3FunctionMutationHook } from "./factories/index.js";
 const generatePresignedDownloadUrl = async (client, config)=>{
@@ -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/useAccessibleBuckets.d.ts

@@ -0,0 +1,11 @@
+import type { Bucket } from '@aws-sdk/client-s3';
+export declare const getAccessibleBucketsStorageKey: (s3ConfigIdentifier: string) => string;
+export declare const getLimitedAccessFlagKey: (s3ConfigIdentifier: string) => string;
+export declare const setLimitedAccessFlag: (s3ConfigIdentifier: string, value: boolean) => void;
+export declare const useAccessibleBuckets: () => {
+    hasLimitedAccess: boolean;
+    setLimitedAccess: (value: boolean) => void;
+    accessibleBuckets: Bucket[];
+    addAccessibleBucket: (bucketName: string) => void;
+    clearAccessibleBuckets: () => void;
+};

package/dist/hooks/useAccessibleBuckets.js

@@ -0,0 +1,115 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { useDataBrowserContext } from "../components/providers/DataBrowserProvider.js";
+const STORAGE_KEY_PREFIX = 'data-browser-accessible-buckets';
+const LIMITED_ACCESS_FLAG_PREFIX = 'data-browser-limited-access';
+const getAccessibleBucketsStorageKey = (s3ConfigIdentifier)=>`${STORAGE_KEY_PREFIX}-${s3ConfigIdentifier}`;
+const getLimitedAccessFlagKey = (s3ConfigIdentifier)=>`${LIMITED_ACCESS_FLAG_PREFIX}-${s3ConfigIdentifier}`;
+const setLimitedAccessFlag = (s3ConfigIdentifier, value)=>{
+    try {
+        const flagKey = getLimitedAccessFlagKey(s3ConfigIdentifier);
+        if (value) sessionStorage.setItem(flagKey, 'true');
+        else sessionStorage.removeItem(flagKey);
+    } catch  {}
+};
+const readBucketsFromStorage = (storageKey)=>{
+    try {
+        const stored = sessionStorage.getItem(storageKey);
+        if (!stored) return [];
+        const parsed = JSON.parse(stored);
+        if (Array.isArray(parsed) && parsed.length > 0) {
+            if ('string' == typeof parsed[0]) {
+                const now = new Date().toISOString();
+                const bucketData = parsed.map((name)=>({
+                        name,
+                        addedAt: now
+                    }));
+                sessionStorage.setItem(storageKey, JSON.stringify(bucketData));
+                return bucketData.map((item)=>({
+                        Name: item.name,
+                        CreationDate: new Date(item.addedAt)
+                    }));
+            }
+            const bucketData = parsed;
+            return bucketData.map((item)=>({
+                    Name: item.name,
+                    CreationDate: new Date(item.addedAt)
+                }));
+        }
+        return [];
+    } catch  {
+        return [];
+    }
+};
+const readLimitedAccessFlag = (flagKey)=>{
+    try {
+        const flag = sessionStorage.getItem(flagKey);
+        return 'true' === flag;
+    } catch  {
+        return false;
+    }
+};
+const useAccessibleBuckets = ()=>{
+    const { s3ConfigIdentifier } = useDataBrowserContext();
+    const storageKey = useMemo(()=>getAccessibleBucketsStorageKey(s3ConfigIdentifier), [
+        s3ConfigIdentifier
+    ]);
+    const flagKey = useMemo(()=>getLimitedAccessFlagKey(s3ConfigIdentifier), [
+        s3ConfigIdentifier
+    ]);
+    const [hasLimitedAccess, setHasLimitedAccessState] = useState(()=>readLimitedAccessFlag(flagKey));
+    const [accessibleBuckets, setAccessibleBucketsState] = useState(()=>readBucketsFromStorage(storageKey));
+    useEffect(()=>{
+        setHasLimitedAccessState(readLimitedAccessFlag(flagKey));
+        setAccessibleBucketsState(readBucketsFromStorage(storageKey));
+    }, [
+        storageKey,
+        flagKey
+    ]);
+    const setLimitedAccess = useCallback((value)=>{
+        setLimitedAccessFlag(s3ConfigIdentifier, value);
+        setHasLimitedAccessState(value);
+    }, [
+        s3ConfigIdentifier
+    ]);
+    const addAccessibleBucket = useCallback((bucketName)=>{
+        try {
+            const stored = sessionStorage.getItem(storageKey);
+            const bucketData = stored ? JSON.parse(stored) : [];
+            const existingBucket = bucketData.find((b)=>b.name === bucketName);
+            if (!existingBucket) {
+                const newBucket = {
+                    name: bucketName,
+                    addedAt: new Date().toISOString()
+                };
+                bucketData.push(newBucket);
+                sessionStorage.setItem(storageKey, JSON.stringify(bucketData));
+                const newBuckets = bucketData.map((item)=>({
+                        Name: item.name,
+                        CreationDate: new Date(item.addedAt)
+                    }));
+                setAccessibleBucketsState(newBuckets);
+            }
+        } catch  {}
+    }, [
+        storageKey
+    ]);
+    const clearAccessibleBuckets = useCallback(()=>{
+        try {
+            sessionStorage.removeItem(storageKey);
+            sessionStorage.removeItem(flagKey);
+            setAccessibleBucketsState([]);
+            setHasLimitedAccessState(false);
+        } catch  {}
+    }, [
+        storageKey,
+        flagKey
+    ]);
+    return {
+        hasLimitedAccess,
+        setLimitedAccess,
+        accessibleBuckets,
+        addAccessibleBucket,
+        clearAccessibleBuckets
+    };
+};
+export { getAccessibleBucketsStorageKey, getLimitedAccessFlagKey, setLimitedAccessFlag, useAccessibleBuckets };

package/dist/hooks/useBatchObjectLegalHold.d.ts

@@ -0,0 +1,11 @@
+interface ObjectIdentifier {
+    Key: string;
+    VersionId?: string;
+}
+interface LegalHoldStatus {
+    key: string;
+    versionId?: string;
+    isLegalHoldEnabled: boolean;
+}
+export declare const useBatchObjectLegalHold: (bucketName: string, objects: ObjectIdentifier[], enabled?: boolean) => import("@tanstack/react-query").UseQueryResult<Record<string, LegalHoldStatus>, Error>;
+export {};

package/dist/hooks/useBatchObjectLegalHold.js

@@ -0,0 +1,48 @@
+import { GetObjectLegalHoldCommand } from "@aws-sdk/client-s3";
+import { useQuery } from "@tanstack/react-query";
+import { useDataBrowserContext } from "../components/providers/DataBrowserProvider.js";
+import { useS3Client } from "./useS3Client.js";
+const useBatchObjectLegalHold = (bucketName, objects, enabled = true)=>{
+    const { s3ConfigIdentifier } = useDataBrowserContext();
+    const s3Client = useS3Client();
+    return useQuery({
+        queryKey: [
+            s3ConfigIdentifier,
+            'BatchObjectLegalHold',
+            bucketName,
+            ...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'}`;
+                try {
+                    const command = new GetObjectLegalHoldCommand({
+                        Bucket: bucketName,
+                        Key: obj.Key,
+                        ...obj.VersionId && {
+                            VersionId: obj.VersionId
+                        }
+                    });
+                    const response = await s3Client.send(command);
+                    results[key] = {
+                        key: obj.Key,
+                        versionId: obj.VersionId,
+                        isLegalHoldEnabled: response.LegalHold?.Status === 'ON'
+                    };
+                } catch (error) {
+                    results[key] = {
+                        key: obj.Key,
+                        versionId: obj.VersionId,
+                        isLegalHoldEnabled: false
+                    };
+                }
+            }));
+            return results;
+        },
+        enabled: enabled && objects.length > 0,
+        staleTime: 30000,
+        refetchOnWindowFocus: false
+    });
+};
+export { useBatchObjectLegalHold };

package/dist/hooks/useBucketConfigEditor.d.ts

@@ -0,0 +1,31 @@
+import type { BeforeMount } from '@monaco-editor/react';
+import { useForm } from 'react-hook-form';
+type FormValues = {
+    content: string;
+};
+type ValidationResult = {
+    isValid: boolean;
+    parsed?: unknown;
+    error?: string;
+};
+export type BucketConfigEditorConfig = {
+    bucketName: string;
+    initialContent: string | undefined;
+    defaultTemplate: string;
+    isLoading: boolean;
+    notFoundErrorNames: string[];
+    errorInstance: Error | null;
+    validate: (content: string) => ValidationResult;
+    monacoSchema?: unknown;
+};
+export type BucketConfigEditorResult = {
+    bucketName: string;
+    form: ReturnType<typeof useForm<FormValues>>;
+    content: string;
+    isCreateMode: boolean;
+    isValidFormat: boolean;
+    handleBeforeMount: BeforeMount;
+    navigateToBucket: () => void;
+};
+export declare const useBucketConfigEditor: (config: BucketConfigEditorConfig) => BucketConfigEditorResult;
+export {};