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

package/dist/hooks/factories/__tests__/useCreateS3QueryHook.test.js

@@ -1,10 +1,10 @@
 import { renderHook, waitFor } from "@testing-library/react";
-import { useCreateS3QueryHook } from "../useCreateS3QueryHook.js";
-import { useS3Client } from "../../useS3Client.js";
+import { createTestWrapper, validateFactoryHook, validateHookResult } from "../../../test/testUtils.js";
 import { createS3OperationError, isNotFoundError } from "../../../utils/errorHandling.js";
-import { createQueryWrapper, validateFactoryHook, validateHookResult } from "../../../test/testUtils.js";
-jest.mock("../../useS3Client");
-jest.mock("../../../utils/errorHandling");
+import { useS3Client } from "../../useS3Client.js";
+import { useCreateS3QueryHook } from "../useCreateS3QueryHook.js";
+jest.mock('../../useS3Client');
+jest.mock('../../../utils/errorHandling');
 const mockUseS3Client = useS3Client;
 const mockCreateS3OperationError = createS3OperationError;
 const mockIsNotFoundError = isNotFoundError;
@@ -17,48 +17,48 @@ class MockCommand {
 const mockS3Client = {
     send: jest.fn()
 };
-describe("useCreateS3QueryHook - Factory Specific", ()=>{
+describe('useCreateS3QueryHook - Factory Specific', ()=>{
     beforeEach(()=>{
         jest.clearAllMocks();
         mockUseS3Client.mockReturnValue(mockS3Client);
     });
-    it("should create a functioning query hook", ()=>{
-        const useTestQuery = useCreateS3QueryHook(MockCommand, "testOperation");
-        validateFactoryHook(useTestQuery, "testOperation");
+    it('should create a functioning query hook', ()=>{
+        const useTestQuery = useCreateS3QueryHook(MockCommand, 'testOperation');
+        validateFactoryHook(useTestQuery, 'testOperation');
         const { result } = renderHook(()=>useTestQuery({
-                testParam: "value"
+                testParam: 'value'
             }), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
-        validateHookResult(result.current, "query");
+        validateHookResult(result.current, 'query');
     });
-    it("should accept and forward query options correctly", ()=>{
-        const useTestQuery = useCreateS3QueryHook(MockCommand, "testOperation");
+    it('should accept and forward query options correctly', ()=>{
+        const useTestQuery = useCreateS3QueryHook(MockCommand, 'testOperation');
         const customOptions = {
             enabled: false,
             staleTime: 5000,
             refetchOnWindowFocus: false
         };
         const { result } = renderHook(()=>useTestQuery({
-                testParam: "value"
+                testParam: 'value'
             }, customOptions), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
-        expect(result.current.fetchStatus).toBe("idle");
+        expect(result.current.fetchStatus).toBe('idle');
         expect(result.current.isLoading).toBe(false);
     });
-    it("should handle successful query execution", async ()=>{
+    it('should handle successful query execution', async ()=>{
         const mockResponse = {
-            data: "test-response",
-            status: "success"
+            data: 'test-response',
+            status: 'success'
         };
         mockS3Client.send.mockResolvedValue(mockResponse);
-        const useTestQuery = useCreateS3QueryHook(MockCommand, "testOperation");
+        const useTestQuery = useCreateS3QueryHook(MockCommand, 'testOperation');
         const { result } = renderHook(()=>useTestQuery({
-                Bucket: "test-bucket",
-                Key: "test-key"
+                Bucket: 'test-bucket',
+                Key: 'test-key'
             }), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
         await waitFor(()=>{
             expect(result.current.isSuccess).toBe(true);
@@ -68,52 +68,52 @@ describe("useCreateS3QueryHook - Factory Specific", ()=>{
             abortSignal: expect.any(AbortSignal)
         }));
     });
-    it("should handle query errors with proper context", async ()=>{
-        const mockError = new Error("S3 Service Error");
-        const enhancedError = new Error("Enhanced S3 Service Error");
+    it('should handle query errors with proper context', async ()=>{
+        const mockError = new Error('S3 Service Error');
+        const enhancedError = new Error('Enhanced S3 Service Error');
         mockS3Client.send.mockRejectedValue(mockError);
         mockCreateS3OperationError.mockReturnValue(enhancedError);
-        const useTestQuery = useCreateS3QueryHook(MockCommand, "testOperation");
+        const useTestQuery = useCreateS3QueryHook(MockCommand, 'testOperation');
         const { result } = renderHook(()=>useTestQuery({
-                Bucket: "test-bucket",
-                Key: "test-key"
+                Bucket: 'test-bucket',
+                Key: 'test-key'
             }), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
         await waitFor(()=>{
             expect(result.current.isError).toBe(true);
         });
         expect(result.current.error).toBe(enhancedError);
-        expect(mockCreateS3OperationError).toHaveBeenCalledWith(mockError, "testOperation", "test-bucket");
+        expect(mockCreateS3OperationError).toHaveBeenCalledWith(mockError, 'testOperation', 'test-bucket');
     });
-    it("should handle parameter validation correctly", ()=>{
-        const useTestQuery = useCreateS3QueryHook(MockCommand, "testOperation");
+    it('should handle parameter validation correctly', ()=>{
+        const useTestQuery = useCreateS3QueryHook(MockCommand, 'testOperation');
         const { result: invalidResult } = renderHook(()=>useTestQuery({
-                Bucket: "test",
+                Bucket: 'test',
                 Key: void 0
             }), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
-        expect(invalidResult.current.fetchStatus).toBe("idle");
+        expect(invalidResult.current.fetchStatus).toBe('idle');
         const { result: validResult } = renderHook(()=>useTestQuery({
-                Bucket: "test",
-                Key: "valid-key"
+                Bucket: 'test',
+                Key: 'valid-key'
             }), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
-        expect(validResult.current.fetchStatus).not.toBe("idle");
+        expect(validResult.current.fetchStatus).not.toBe('idle');
     });
-    it("should handle empty string parameters correctly", ()=>{
-        const useTestQuery = useCreateS3QueryHook(MockCommand, "testOperation");
+    it('should handle empty string parameters correctly', ()=>{
+        const useTestQuery = useCreateS3QueryHook(MockCommand, 'testOperation');
         const { result: emptyResult } = renderHook(()=>useTestQuery({
-                Bucket: "test",
-                Key: ""
+                Bucket: 'test',
+                Key: ''
             }), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
-        expect(emptyResult.current.fetchStatus).not.toBe("idle");
+        expect(emptyResult.current.fetchStatus).not.toBe('idle');
     });
-    it("should pass AbortSignal correctly to S3 client", async ()=>{
+    it('should pass AbortSignal correctly to S3 client', async ()=>{
         let capturedAbortSignal;
         mockS3Client.send.mockImplementation((_command, options)=>{
             capturedAbortSignal = options?.abortSignal;
@@ -121,12 +121,12 @@ describe("useCreateS3QueryHook - Factory Specific", ()=>{
                 success: true
             });
         });
-        const useTestQuery = useCreateS3QueryHook(MockCommand, "testOperation");
+        const useTestQuery = useCreateS3QueryHook(MockCommand, 'testOperation');
         const { result } = renderHook(()=>useTestQuery({
-                Bucket: "test",
-                Key: "test"
+                Bucket: 'test',
+                Key: 'test'
             }), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
         await waitFor(()=>{
             expect(result.current.isSuccess).toBe(true);
@@ -134,19 +134,19 @@ describe("useCreateS3QueryHook - Factory Specific", ()=>{
         expect(capturedAbortSignal).toBeInstanceOf(AbortSignal);
         expect(capturedAbortSignal?.aborted).toBe(false);
     });
-    it("should return empty config for supported operations when NOT_FOUND error occurs", async ()=>{
-        const error = new Error("Configuration does not exist");
-        error.name = "NoSuchConfiguration";
+    it('should return empty config for supported operations when NOT_FOUND error occurs', async ()=>{
+        const error = new Error('Configuration does not exist');
+        error.name = 'NoSuchConfiguration';
         error.$metadata = {
             httpStatusCode: 404
         };
         mockS3Client.send.mockRejectedValueOnce(error);
         mockIsNotFoundError.mockReturnValueOnce(true);
-        const useTestQuery = useCreateS3QueryHook(MockCommand, "GetBucketLifecycleConfiguration");
+        const useTestQuery = useCreateS3QueryHook(MockCommand, 'GetBucketLifecycleConfiguration');
         const { result } = renderHook(()=>useTestQuery({
-                Bucket: "test-bucket"
+                Bucket: 'test-bucket'
             }), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
         await waitFor(()=>{
             expect(result.current.isSuccess).toBe(true);
@@ -154,21 +154,21 @@ describe("useCreateS3QueryHook - Factory Specific", ()=>{
         expect(result.current.data).toBeDefined();
         expect(mockIsNotFoundError).toHaveBeenCalledWith(error);
     });
-    it("should throw error when NOT_FOUND occurs for unsupported operations", async ()=>{
-        const error = new Error("Bucket not found");
-        error.name = "NoSuchBucket";
+    it('should throw error when NOT_FOUND occurs for unsupported operations', async ()=>{
+        const error = new Error('Bucket not found');
+        error.name = 'NoSuchBucket';
         error.$metadata = {
             httpStatusCode: 404
         };
-        const enhancedError = new Error("Enhanced error");
+        const enhancedError = new Error('Enhanced error');
         mockS3Client.send.mockRejectedValueOnce(error);
         mockIsNotFoundError.mockReturnValueOnce(true);
         mockCreateS3OperationError.mockReturnValueOnce(enhancedError);
-        const useTestQuery = useCreateS3QueryHook(MockCommand, "GetBucketAcl");
+        const useTestQuery = useCreateS3QueryHook(MockCommand, 'GetBucketAcl');
         const { result } = renderHook(()=>useTestQuery({
-                Bucket: "test-bucket"
+                Bucket: 'test-bucket'
             }), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
         await waitFor(()=>{
             expect(result.current.isError).toBe(true);

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

@@ -12,7 +12,7 @@
  * - AbortSignal support for cancellation
  * - Bucket/object context extraction for errors
  */
-export { useCreateS3QueryHook } from "./useCreateS3QueryHook";
-export { useCreateS3MutationHook, useCreateS3FunctionMutationHook, } from "./useCreateS3MutationHook";
-export { useCreateS3InfiniteQueryHook } from "./useCreateS3InfiniteQueryHook";
-export { useCreateS3LoginHook } from "./useCreateS3LoginHook";
+export { useCreateS3InfiniteQueryHook } from './useCreateS3InfiniteQueryHook';
+export { useCreateS3LoginHook } from './useCreateS3LoginHook';
+export { useCreateS3FunctionMutationHook, useCreateS3MutationHook, } from './useCreateS3MutationHook';
+export { useCreateS3QueryHook } from './useCreateS3QueryHook';

package/dist/hooks/factories/index.js

@@ -1,5 +1,5 @@
-import { useCreateS3QueryHook } from "./useCreateS3QueryHook.js";
-import { useCreateS3FunctionMutationHook, useCreateS3MutationHook } from "./useCreateS3MutationHook.js";
 import { useCreateS3InfiniteQueryHook } from "./useCreateS3InfiniteQueryHook.js";
 import { useCreateS3LoginHook } from "./useCreateS3LoginHook.js";
+import { useCreateS3FunctionMutationHook, useCreateS3MutationHook } from "./useCreateS3MutationHook.js";
+import { useCreateS3QueryHook } from "./useCreateS3QueryHook.js";
 export { useCreateS3FunctionMutationHook, useCreateS3InfiniteQueryHook, useCreateS3LoginHook, useCreateS3MutationHook, useCreateS3QueryHook };

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

@@ -1,5 +1,5 @@
-import { UseInfiniteQueryOptions, UseInfiniteQueryResult } from "@tanstack/react-query";
-import { EnhancedS3Error } from "../../utils/errorHandling";
+import { type UseInfiniteQueryOptions, type UseInfiniteQueryResult } from '@tanstack/react-query';
+import { type EnhancedS3Error } from '../../utils/errorHandling';
 /**
  * Factory function for creating S3 infinite query hooks
  *

package/dist/hooks/factories/useCreateS3InfiniteQueryHook.js

@@ -1,11 +1,14 @@
 import { useInfiniteQuery } from "@tanstack/react-query";
-import { useS3Client } from "../useS3Client.js";
+import { useDataBrowserContext } from "../../components/providers/DataBrowserProvider.js";
 import { createS3OperationError, shouldRetryError } from "../../utils/errorHandling.js";
+import { useS3Client } from "../useS3Client.js";
 function useCreateS3InfiniteQueryHook(Command, operationName) {
     return (params, options)=>{
+        const { s3ConfigIdentifier } = useDataBrowserContext();
         const s3Client = useS3Client();
         const queryOptions = {
             queryKey: [
+                s3ConfigIdentifier,
                 operationName,
                 params
             ],
@@ -20,7 +23,7 @@ function useCreateS3InfiniteQueryHook(Command, operationName) {
                     });
                     return response;
                 } 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);
                 }
             },
@@ -28,8 +31,8 @@ function useCreateS3InfiniteQueryHook(Command, operationName) {
             initialPageParam: void 0,
             getNextPageParam: (lastPage)=>getNextPageToken(operationName, lastPage),
             enabled: params ? Object.entries(params).every(([key, value])=>{
-                if ("Prefix" === key) return void 0 !== value;
-                return void 0 !== value && "" !== value;
+                if ('Prefix' === key) return void 0 !== value;
+                return void 0 !== value && '' !== value;
             }) : true,
             ...options
         };
@@ -38,18 +41,18 @@ function useCreateS3InfiniteQueryHook(Command, operationName) {
 }
 function getPaginationParams(operationName, pageParam) {
     switch(operationName){
-        case "ListObjects":
+        case 'ListObjects':
             return {
                 ContinuationToken: pageParam
             };
-        case "ListObjectVersions":
-            if (pageParam.includes("|")) {
-                const [keyMarker, versionIdMarker] = pageParam.split("|");
+        case 'ListObjectVersions':
+            if (pageParam.includes('|')) {
+                const [keyMarker, versionIdMarker] = pageParam.split('|');
                 return {
-                    ...keyMarker && "" !== keyMarker ? {
+                    ...keyMarker && '' !== keyMarker ? {
                         KeyMarker: keyMarker
                     } : {},
-                    ...versionIdMarker && "" !== versionIdMarker ? {
+                    ...versionIdMarker && '' !== versionIdMarker ? {
                         VersionIdMarker: versionIdMarker
                     } : {}
                 };
@@ -65,10 +68,10 @@ function getPaginationParams(operationName, pageParam) {
 }
 function getNextPageToken(operationName, lastPage) {
     switch(operationName){
-        case "ListObjects":
+        case 'ListObjects':
             return lastPage.IsTruncated ? lastPage.NextContinuationToken : void 0;
-        case "ListObjectVersions":
-            return lastPage.IsTruncated && (lastPage.NextKeyMarker || lastPage.NextVersionIdMarker) ? `${lastPage.NextKeyMarker || ""}|${lastPage.NextVersionIdMarker || ""}` : void 0;
+        case 'ListObjectVersions':
+            return lastPage.IsTruncated && (lastPage.NextKeyMarker || lastPage.NextVersionIdMarker) ? `${lastPage.NextKeyMarker || ''}|${lastPage.NextVersionIdMarker || ''}` : void 0;
         default:
             return lastPage.IsTruncated ? lastPage.NextContinuationToken : void 0;
     }

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

@@ -1,5 +1,5 @@
-import { UseMutationOptions, UseMutationResult } from "@tanstack/react-query";
-import { EnhancedS3Error } from "../../utils/errorHandling";
+import { type UseMutationOptions, type UseMutationResult } from '@tanstack/react-query';
+import { type EnhancedS3Error } from '../../utils/errorHandling';
 /**
  * Factory function for creating S3 login mutation hooks
  * This factory handles the special authentication case where we need

package/dist/hooks/factories/useCreateS3LoginHook.js

@@ -1,5 +1,5 @@
-import { useMutation } from "@tanstack/react-query";
 import { ListBucketsCommand } from "@aws-sdk/client-s3";
+import { useMutation } from "@tanstack/react-query";
 import { createS3OperationError } from "../../utils/errorHandling.js";
 import { createS3Client } from "../../utils/s3Client.js";
 function useCreateS3LoginHook(_Command, operationName) {

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

@@ -1,5 +1,5 @@
-import { UseMutationOptions, UseMutationResult } from "@tanstack/react-query";
-import { EnhancedS3Error } from "../../utils/errorHandling";
-import { S3Client } from "@aws-sdk/client-s3";
+import type { S3Client } from '@aws-sdk/client-s3';
+import { type UseMutationOptions, type UseMutationResult } from '@tanstack/react-query';
+import { type EnhancedS3Error } from '../../utils/errorHandling';
 export declare function useCreateS3MutationHook<TInput extends object, TOutput>(Command: new (input: TInput) => any, operationName: string, invalidationKeys?: string[]): (options?: Omit<UseMutationOptions<TOutput, EnhancedS3Error, TInput>, "mutationFn">) => UseMutationResult<TOutput, EnhancedS3Error, TInput>;
 export declare function useCreateS3FunctionMutationHook<TInput, TOutput>(operation: (s3Client: S3Client, input: TInput) => Promise<TOutput>, invalidationKeys?: string[]): (options?: Omit<UseMutationOptions<TOutput, EnhancedS3Error, TInput>, "mutationFn">) => UseMutationResult<TOutput, EnhancedS3Error, TInput>;

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,30 +1,35 @@
 import { useQuery } from "@tanstack/react-query";
-import { useS3Client } from "../useS3Client.js";
+import { useDataBrowserContext } from "../../components/providers/DataBrowserProvider.js";
 import { createS3OperationError, isNotFoundError, shouldRetryError } from "../../utils/errorHandling.js";
+import { useS3Client } from "../useS3Client.js";
 function getEmptyConfigForOperation(operationName) {
     switch(operationName){
-        case "GetBucketLifecycleConfiguration":
+        case 'GetBucketLifecycleConfiguration':
             return {
                 Rules: []
             };
-        case "GetBucketReplication":
+        case 'GetBucketReplication':
             return {
                 ReplicationConfiguration: {
                     Rules: [],
-                    Role: ""
+                    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 })=>{
@@ -34,7 +39,7 @@ 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;

package/dist/hooks/index.d.ts

@@ -1,12 +1,19 @@
-export { useS3Client } from "./useS3Client";
-export type { LoginConfig, LoginMutationResult } from "./useLoginMutation";
-export { useLoginMutation } from "./loginOperations";
-export { useIsBucketEmpty } from "./useIsBucketEmpty";
-export { useEmptyBucket } from "./useEmptyBucket";
-export { useDeleteBucketConfigRule } from "./useDeleteBucketConfigRule";
-export { useTableRowSelection } from "./useTableRowSelection";
-export { useISVBucketStatus } from "./useISVBucketDetection";
-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,12 +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 { useEmptyBucket } from "./useEmptyBucket.js";
-import { useDeleteBucketConfigRule } from "./useDeleteBucketConfigRule.js";
-import { useTableRowSelection } from "./useTableRowSelection.js";
-import { useISVBucketStatus } from "./useISVBucketDetection.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, useDeleteBucketConfigRule, useDeleteBucketCors, useDeleteBucketLifecycle, useDeleteBucketPolicy, useDeleteBucketReplication, useDeleteBucketTagging, useDeleteObject, useDeleteObjectTagging, useDeleteObjects, useEmptyBucket, useGetBucketAcl, useGetBucketCors, useGetBucketEncryption, useGetBucketLifecycle, useGetBucketLocation, useGetBucketNotification, useGetBucketObjectLockConfiguration, useGetBucketPolicy, useGetBucketReplication, useGetBucketTagging, useGetBucketVersioning, useGetObject, useGetObjectAttributes, useGetObjectTorrent, useGetPresignedDownload, useGetPresignedPost, useGetPresignedUpload, useISVBucketStatus, 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, useTableRowSelection, 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
  *