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

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

@@ -1,10 +1,10 @@
 import { renderHook, waitFor } from "@testing-library/react";
-import { useCreateS3MutationHook } from "../useCreateS3MutationHook.js";
-import { useS3Client } from "../../useS3Client.js";
+import { createTestWrapper, validateFactoryHook, validateHookResult } from "../../../test/testUtils.js";
 import { createS3OperationError } 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 { useCreateS3MutationHook } from "../useCreateS3MutationHook.js";
+jest.mock('../../useS3Client');
+jest.mock('../../../utils/errorHandling');
 const mockUseS3Client = useS3Client;
 const mockCreateS3OperationError = createS3OperationError;
 class MockCommand {
@@ -16,44 +16,44 @@ class MockCommand {
 const mockS3Client = {
     send: jest.fn()
 };
-describe("useCreateS3MutationHook - Factory Specific", ()=>{
+describe('useCreateS3MutationHook - Factory Specific', ()=>{
     beforeEach(()=>{
         jest.clearAllMocks();
         mockUseS3Client.mockReturnValue(mockS3Client);
     });
-    it("should create a functioning mutation hook", ()=>{
-        const useMutation = useCreateS3MutationHook(MockCommand, "testMutation");
-        validateFactoryHook(useMutation, "testMutation");
+    it('should create a functioning mutation hook', ()=>{
+        const useMutation = useCreateS3MutationHook(MockCommand, 'testMutation');
+        validateFactoryHook(useMutation, 'testMutation');
         const { result } = renderHook(()=>useMutation(), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
-        validateHookResult(result.current, "mutation");
+        validateHookResult(result.current, 'mutation');
     });
-    it("should accept invalidation keys parameter", ()=>{
-        const useMutation = useCreateS3MutationHook(MockCommand, "testMutation", [
-            "ListObjects",
-            "TestQuery"
+    it('should accept invalidation keys parameter', ()=>{
+        const useMutation = useCreateS3MutationHook(MockCommand, 'testMutation', [
+            'ListObjects',
+            'TestQuery'
         ]);
-        validateFactoryHook(useMutation, "testMutation");
+        validateFactoryHook(useMutation, 'testMutation');
         const { result } = renderHook(()=>useMutation(), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
-        validateHookResult(result.current, "mutation");
+        validateHookResult(result.current, 'mutation');
     });
-    it("should execute mutation successfully", async ()=>{
+    it('should execute mutation successfully', async ()=>{
         const mockResponse = {
             success: true,
-            key: "uploaded-file.txt"
+            key: 'uploaded-file.txt'
         };
         mockS3Client.send.mockResolvedValue(mockResponse);
-        const useMutation = useCreateS3MutationHook(MockCommand, "PutObject");
+        const useMutation = useCreateS3MutationHook(MockCommand, 'PutObject');
         const { result } = renderHook(()=>useMutation(), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
         result.current.mutate({
-            Bucket: "test-bucket",
-            Key: "test-file.txt",
-            Body: "content"
+            Bucket: 'test-bucket',
+            Key: 'test-file.txt',
+            Body: 'content'
         });
         await waitFor(()=>{
             expect(result.current.isSuccess).toBe(true);
@@ -61,32 +61,32 @@ describe("useCreateS3MutationHook - Factory Specific", ()=>{
         expect(result.current.data).toEqual(mockResponse);
         expect(mockS3Client.send).toHaveBeenCalledWith(expect.objectContaining({
             input: {
-                Bucket: "test-bucket",
-                Key: "test-file.txt",
-                Body: "content"
+                Bucket: 'test-bucket',
+                Key: 'test-file.txt',
+                Body: 'content'
             }
         }));
     });
-    it("should handle mutation errors with proper context", async ()=>{
-        const mockError = new Error("Access Denied");
-        const enhancedError = new Error("Enhanced Access Denied");
+    it('should handle mutation errors with proper context', async ()=>{
+        const mockError = new Error('Access Denied');
+        const enhancedError = new Error('Enhanced Access Denied');
         mockS3Client.send.mockRejectedValue(mockError);
         mockCreateS3OperationError.mockReturnValue(enhancedError);
-        const useMutation = useCreateS3MutationHook(MockCommand, "PutObject");
+        const useMutation = useCreateS3MutationHook(MockCommand, 'PutObject');
         const { result } = renderHook(()=>useMutation(), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
         result.current.mutate({
-            Bucket: "test-bucket",
-            Key: "test-file.txt"
+            Bucket: 'test-bucket',
+            Key: 'test-file.txt'
         });
         await waitFor(()=>{
             expect(result.current.isError).toBe(true);
         });
         expect(result.current.error).toBe(enhancedError);
-        expect(mockCreateS3OperationError).toHaveBeenCalledWith(mockError, "PutObject", "test-bucket");
+        expect(mockCreateS3OperationError).toHaveBeenCalledWith(mockError, 'PutObject', 'test-bucket');
     });
-    it("should handle mutation callbacks correctly", async ()=>{
+    it('should handle mutation callbacks correctly', async ()=>{
         const mockResponse = {
             success: true
         };
@@ -94,17 +94,17 @@ describe("useCreateS3MutationHook - Factory Specific", ()=>{
         const onError = jest.fn();
         const onSettled = jest.fn();
         mockS3Client.send.mockResolvedValue(mockResponse);
-        const useMutation = useCreateS3MutationHook(MockCommand, "PutObject");
+        const useMutation = useCreateS3MutationHook(MockCommand, 'PutObject');
         const { result } = renderHook(()=>useMutation({
                 onSuccess,
                 onError,
                 onSettled
             }), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
         const variables = {
-            Bucket: "test-bucket",
-            Key: "test-file.txt"
+            Bucket: 'test-bucket',
+            Key: 'test-file.txt'
         };
         result.current.mutate(variables);
         await waitFor(()=>{
@@ -114,28 +114,28 @@ describe("useCreateS3MutationHook - Factory Specific", ()=>{
         expect(onError).not.toHaveBeenCalled();
         expect(onSettled).toHaveBeenCalledWith(mockResponse, null, variables, void 0, expect.any(Object));
     });
-    it("should handle mutation with invalidation keys", async ()=>{
+    it('should handle mutation with invalidation keys', async ()=>{
         const mockResponse = {
             success: true
         };
         mockS3Client.send.mockResolvedValue(mockResponse);
-        const useMutation = useCreateS3MutationHook(MockCommand, "PutObject", [
-            "ListObjects",
-            "TestQuery"
+        const useMutation = useCreateS3MutationHook(MockCommand, 'PutObject', [
+            'ListObjects',
+            'TestQuery'
         ]);
         const { result } = renderHook(()=>useMutation(), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
         result.current.mutate({
-            Bucket: "test-bucket",
-            Key: "test-file.txt"
+            Bucket: 'test-bucket',
+            Key: 'test-file.txt'
         });
         await waitFor(()=>{
             expect(result.current.isSuccess).toBe(true);
         });
         expect(result.current.data).toEqual(mockResponse);
     });
-    it("should handle concurrent mutations correctly", async ()=>{
+    it('should handle concurrent mutations correctly', async ()=>{
         const mockResponse1 = {
             success: true,
             id: 1
@@ -149,20 +149,20 @@ describe("useCreateS3MutationHook - Factory Specific", ()=>{
             callCount++;
             return Promise.resolve(1 === callCount ? mockResponse1 : mockResponse2);
         });
-        const useMutation = useCreateS3MutationHook(MockCommand, "PutObject");
+        const useMutation = useCreateS3MutationHook(MockCommand, 'PutObject');
         const { result: result1 } = renderHook(()=>useMutation(), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
         const { result: result2 } = renderHook(()=>useMutation(), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
         result1.current.mutate({
-            Bucket: "test-bucket",
-            Key: "file1.txt"
+            Bucket: 'test-bucket',
+            Key: 'file1.txt'
         });
         result2.current.mutate({
-            Bucket: "test-bucket",
-            Key: "file2.txt"
+            Bucket: 'test-bucket',
+            Key: 'file2.txt'
         });
         await waitFor(()=>{
             expect(result1.current.isSuccess).toBe(true);
@@ -172,7 +172,7 @@ describe("useCreateS3MutationHook - Factory Specific", ()=>{
         expect(result2.current.data).toEqual(mockResponse2);
         expect(mockS3Client.send).toHaveBeenCalledTimes(2);
     });
-    it("should pass command correctly for mutations", async ()=>{
+    it('should pass command correctly for mutations', async ()=>{
         let capturedCommand;
         mockS3Client.send.mockImplementation((command)=>{
             capturedCommand = command;
@@ -180,21 +180,21 @@ describe("useCreateS3MutationHook - Factory Specific", ()=>{
                 success: true
             });
         });
-        const useMutation = useCreateS3MutationHook(MockCommand, "PutObject");
+        const useMutation = useCreateS3MutationHook(MockCommand, 'PutObject');
         const { result } = renderHook(()=>useMutation(), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
         result.current.mutate({
-            Bucket: "test-bucket",
-            Key: "test-file.txt"
+            Bucket: 'test-bucket',
+            Key: 'test-file.txt'
         });
         await waitFor(()=>{
             expect(result.current.isSuccess).toBe(true);
         });
         expect(capturedCommand).toBeInstanceOf(MockCommand);
         expect(capturedCommand.input).toEqual({
-            Bucket: "test-bucket",
-            Key: "test-file.txt"
+            Bucket: 'test-bucket',
+            Key: 'test-file.txt'
         });
     });
 });

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

@@ -1,12 +1,13 @@
 import { renderHook, waitFor } from "@testing-library/react";
-import { useCreateS3QueryHook } from "../useCreateS3QueryHook.js";
+import { createTestWrapper, validateFactoryHook, validateHookResult } from "../../../test/testUtils.js";
+import { createS3OperationError, isNotFoundError } from "../../../utils/errorHandling.js";
 import { useS3Client } from "../../useS3Client.js";
-import { createS3OperationError } from "../../../utils/errorHandling.js";
-import { createQueryWrapper, validateFactoryHook, validateHookResult } from "../../../test/testUtils.js";
-jest.mock("../../useS3Client");
-jest.mock("../../../utils/errorHandling");
+import { useCreateS3QueryHook } from "../useCreateS3QueryHook.js";
+jest.mock('../../useS3Client');
+jest.mock('../../../utils/errorHandling');
 const mockUseS3Client = useS3Client;
 const mockCreateS3OperationError = createS3OperationError;
+const mockIsNotFoundError = isNotFoundError;
 class MockCommand {
     input;
     constructor(input){
@@ -16,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);
@@ -67,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;
@@ -120,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);
@@ -133,4 +134,46 @@ 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';
+        error.$metadata = {
+            httpStatusCode: 404
+        };
+        mockS3Client.send.mockRejectedValueOnce(error);
+        mockIsNotFoundError.mockReturnValueOnce(true);
+        const useTestQuery = useCreateS3QueryHook(MockCommand, 'GetBucketLifecycleConfiguration');
+        const { result } = renderHook(()=>useTestQuery({
+                Bucket: 'test-bucket'
+            }), {
+            wrapper: createTestWrapper()
+        });
+        await waitFor(()=>{
+            expect(result.current.isSuccess).toBe(true);
+        });
+        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';
+        error.$metadata = {
+            httpStatusCode: 404
+        };
+        const enhancedError = new Error('Enhanced error');
+        mockS3Client.send.mockRejectedValueOnce(error);
+        mockIsNotFoundError.mockReturnValueOnce(true);
+        mockCreateS3OperationError.mockReturnValueOnce(enhancedError);
+        const useTestQuery = useCreateS3QueryHook(MockCommand, 'GetBucketAcl');
+        const { result } = renderHook(()=>useTestQuery({
+                Bucket: 'test-bucket'
+            }), {
+            wrapper: createTestWrapper()
+        });
+        await waitFor(()=>{
+            expect(result.current.isError).toBe(true);
+        });
+        expect(result.current.error).toBe(enhancedError);
+        expect(mockIsNotFoundError).toHaveBeenCalledWith(error);
+    });
 });

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>;