@scality/data-browser-library 1.0.4 → 1.0.5

package/dist/components/ui/Table.elements.js

@@ -6,6 +6,7 @@ const Table = ({ children, ...props })=>/*#__PURE__*/ jsx(Box, {
         height: "100%",
         overflow: "auto",
         width: "100%",
+        paddingRight: spacing.r16,
         ...props,
         children: children
     });

package/dist/config/types.d.ts

@@ -144,12 +144,40 @@ export interface SectionConfig {
     render: () => React.ReactNode;
 }
 /**
- * Storage class selector props
+ * Base props for custom selector components injected into the library.
+ * `value` is the current selection; `onChange` is called when the user picks a new option.
  */
-export interface StorageClassSelectorProps {
+interface SelectorProps {
     value: string;
     onChange: (newValue: string) => void;
 }
+/**
+ * Props for a custom storage class selector used in replication and lifecycle forms.
+ * The component receives the current storage class value and must call `onChange` with the new value.
+ *
+ * `context` indicates which form is rendering the selector, allowing the consumer
+ * to apply different filtering logic (e.g. replication targets vs transition targets).
+ */
+export interface StorageClassSelectorProps extends SelectorProps {
+    context: 'replication' | 'lifecycle';
+}
+/**
+ * Props for a custom location selector in bucket creation (maps to S3 `LocationConstraint`).
+ * The component receives the current location value and must call `onChange` with the new value.
+ */
+export interface LocationSelectorProps extends SelectorProps {
+}
+/**
+ * Props passed to the custom versioning renderer in bucket creation.
+ * Provides commonly-needed form state as props for convenience.
+ *
+ * The component is rendered inside a `FormProvider`, so consumers can also call
+ * `useFormContext()` for full form access (register, setValue, watch, etc.).
+ */
+export interface BucketCreateVersioningProps {
+    isVersioning: boolean;
+    isObjectLockEnabled: boolean;
+}
 /**
  * Main DataBrowserUI component props
  */
@@ -161,6 +189,20 @@ export interface DataBrowserUIProps {
      */
     header?: React.ReactNode;
     storageClassSelector?: React.ComponentType<StorageClassSelectorProps>;
+    /** Label for the storage class selector. Defaults to "Storage Class". */
+    storageClassLabel?: string;
+    /** Custom location selector for bucket creation (LocationConstraint). */
+    locationSelector?: React.ComponentType<LocationSelectorProps>;
+    /** Extra form fields rendered after the location selector inside bucket creation. Components can use useFormContext() to access form state. */
+    bucketCreateExtraFields?: React.ReactNode;
+    /**
+     * Transform form data before the default bucket creation logic runs.
+     * The function receives all form values and must return the full object —
+     * only modify the fields you need (e.g. append ':ingest' suffix to locationConstraint).
+     */
+    transformBucketCreateData?: <T extends Record<string, unknown>>(data: T) => T;
+    /** Custom versioning section for bucket creation. When provided, replaces the default versioning FormGroup entirely. */
+    bucketCreateVersioning?: React.ComponentType<BucketCreateVersioningProps>;
     extraBucketListColumns?: ColumnConfig<Bucket>[];
     extraBucketListActions?: ActionConfig[];
     extraBucketTabs?: TabConfig[];
@@ -222,3 +264,4 @@ export interface DataBrowserUIProps {
 }
 export type S3EventType = 's3:ObjectCreated:*' | 's3:ObjectCreated:Put' | 's3:ObjectCreated:Post' | 's3:ObjectCreated:Copy' | 's3:ObjectCreated:CompleteMultipartUpload' | 's3:ObjectRemoved:*' | 's3:ObjectRemoved:Delete' | 's3:ObjectRemoved:DeleteMarkerCreated' | 's3:ObjectRestore:*' | 's3:ObjectRestore:Post' | 's3:ObjectRestore:Completed' | 's3:ObjectRestore:Delete' | 's3:LifecycleExpiration:*' | 's3:LifecycleExpiration:Delete' | 's3:LifecycleExpiration:DeleteMarkerCreated' | 's3:LifecycleTransition' | 's3:Replication:*' | 's3:Replication:OperationFailedReplication' | 's3:Replication:OperationMissedThreshold' | 's3:Replication:OperationReplicatedAfterThreshold' | 's3:Replication:OperationNotTracked' | 's3:ObjectTagging:*' | 's3:ObjectTagging:Put' | 's3:ObjectTagging:Delete' | 's3:ReducedRedundancyLostObject' | 's3:IntelligentTiering' | 's3:ObjectAcl:Put' | 's3:TestEvent';
 export type S3EventCategory = 'Object Creation' | 'Object Deletion' | 'Object Restoration' | 'Lifecycle' | 'Replication' | 'Object Tagging' | 'Storage & Access' | 'Testing';
+export {};

package/dist/hooks/__tests__/usePresigningS3Client.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hooks/__tests__/usePresigningS3Client.test.js

@@ -0,0 +1,104 @@
+import { S3Client } from "@aws-sdk/client-s3";
+import { renderHook } from "@testing-library/react";
+import { createTestWrapper, testConfig, testCredentials } from "../../test/testUtils.js";
+import { usePresigningS3Client } from "../usePresigningS3Client.js";
+jest.mock('@aws-sdk/client-s3');
+const MockedS3Client = S3Client;
+const proxyConfig = {
+    ...testConfig,
+    proxy: {
+        enabled: true,
+        endpoint: 'https://proxy.example.com/s3',
+        target: 'http://internal-s3.cluster.local'
+    }
+};
+describe('usePresigningS3Client', ()=>{
+    beforeEach(()=>{
+        jest.clearAllMocks();
+        MockedS3Client.mockImplementation(()=>({
+                config: {},
+                middlewareStack: {
+                    use: jest.fn(),
+                    add: jest.fn()
+                }
+            }));
+    });
+    it('should create an S3 client with the direct endpoint when no proxy is configured', ()=>{
+        renderHook(()=>usePresigningS3Client(), {
+            wrapper: createTestWrapper(testConfig, testCredentials)
+        });
+        expect(MockedS3Client).toHaveBeenCalledWith(expect.objectContaining({
+            endpoint: testConfig.endpoint,
+            region: testConfig.region,
+            forcePathStyle: true
+        }));
+    });
+    it('should create an S3 client with the proxy endpoint (not target) when proxy is enabled', ()=>{
+        renderHook(()=>usePresigningS3Client(), {
+            wrapper: createTestWrapper(proxyConfig, testCredentials)
+        });
+        expect(MockedS3Client).toHaveBeenCalledWith(expect.objectContaining({
+            endpoint: 'https://proxy.example.com/s3',
+            region: testConfig.region,
+            forcePathStyle: true
+        }));
+        const constructorCall = MockedS3Client.mock.calls[0][0];
+        expect(constructorCall?.endpoint).not.toContain('internal-s3.cluster.local');
+    });
+    it('should not attach proxy middleware even when proxy is enabled', ()=>{
+        const mockUse = jest.fn();
+        MockedS3Client.mockImplementation(()=>({
+                config: {},
+                middlewareStack: {
+                    use: mockUse,
+                    add: jest.fn()
+                }
+            }));
+        renderHook(()=>usePresigningS3Client(), {
+            wrapper: createTestWrapper(proxyConfig, testCredentials)
+        });
+        expect(mockUse).not.toHaveBeenCalled();
+    });
+    it('should use origin-relative proxy endpoint resolved with window.location.origin', ()=>{
+        const originRelativeConfig = {
+            ...testConfig,
+            proxy: {
+                enabled: true,
+                endpoint: '/zenko/s3',
+                target: 'http://artesca-data-connector-s3api.zenko.svc.cluster.local'
+            }
+        };
+        const originalOrigin = window.location.origin;
+        renderHook(()=>usePresigningS3Client(), {
+            wrapper: createTestWrapper(originRelativeConfig, testCredentials)
+        });
+        expect(MockedS3Client).toHaveBeenCalledWith(expect.objectContaining({
+            endpoint: `${originalOrigin}/zenko/s3`
+        }));
+    });
+    it('should use direct endpoint when proxy is disabled', ()=>{
+        const disabledProxyConfig = {
+            ...testConfig,
+            proxy: {
+                enabled: false,
+                endpoint: 'https://proxy.example.com/s3'
+            }
+        };
+        renderHook(()=>usePresigningS3Client(), {
+            wrapper: createTestWrapper(disabledProxyConfig, testCredentials)
+        });
+        expect(MockedS3Client).toHaveBeenCalledWith(expect.objectContaining({
+            endpoint: testConfig.endpoint
+        }));
+    });
+    it('should return the same client instance on re-render when s3ConfigIdentifier is unchanged', ()=>{
+        const { result, rerender } = renderHook(()=>usePresigningS3Client(), {
+            wrapper: createTestWrapper(testConfig, testCredentials)
+        });
+        const firstClient = result.current;
+        rerender();
+        const secondClient = result.current;
+        expect(firstClient).toBe(secondClient);
+        expect(MockedS3Client).toHaveBeenCalledTimes(1);
+    });
+});

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

@@ -14,5 +14,5 @@
  */
 export { useCreateS3InfiniteQueryHook } from './useCreateS3InfiniteQueryHook';
 export { useCreateS3LoginHook } from './useCreateS3LoginHook';
-export { useCreateS3FunctionMutationHook, useCreateS3MutationHook, } from './useCreateS3MutationHook';
+export { useCreatePresigningMutationHook, useCreateS3FunctionMutationHook, useCreateS3MutationHook, } from './useCreateS3MutationHook';
 export { useCreateS3QueryHook } from './useCreateS3QueryHook';

package/dist/hooks/factories/index.js

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

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

@@ -2,4 +2,5 @@ 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>;
+export declare function useCreateS3FunctionMutationHook<TInput, TOutput>(operation: (s3Client: S3Client, input: TInput) => Promise<TOutput>, invalidationKeys?: string[]): (options?: Omit<UseMutationOptions<TOutput, EnhancedS3Error, TInput, unknown>, "mutationFn"> | undefined) => UseMutationResult<TOutput, EnhancedS3Error, TInput>;
+export declare function useCreatePresigningMutationHook<TInput, TOutput>(operation: (s3Client: S3Client, input: TInput) => Promise<TOutput>, invalidationKeys?: string[]): (options?: Omit<UseMutationOptions<TOutput, EnhancedS3Error, TInput, unknown>, "mutationFn"> | undefined) => UseMutationResult<TOutput, EnhancedS3Error, TInput>;

package/dist/hooks/factories/useCreateS3MutationHook.js

@@ -1,6 +1,7 @@
 import { useMutation, useQueryClient } from "@tanstack/react-query";
 import { useDataBrowserContext } from "../../components/providers/DataBrowserProvider.js";
 import { createS3OperationError } from "../../utils/errorHandling.js";
+import { usePresigningS3Client } from "../usePresigningS3Client.js";
 import { useS3Client } from "../useS3Client.js";
 function useCreateS3MutationHook(Command, operationName, invalidationKeys) {
     return (options)=>{
@@ -31,10 +32,10 @@ function useCreateS3MutationHook(Command, operationName, invalidationKeys) {
         });
     };
 }
-function useCreateS3FunctionMutationHook(operation, invalidationKeys) {
+function createFunctionMutationHook(operation, useClient, invalidationKeys) {
     return (options)=>{
         const { s3ConfigIdentifier } = useDataBrowserContext();
-        const s3Client = useS3Client();
+        const s3Client = useClient();
         const queryClient = useQueryClient();
         return useMutation({
             mutationFn: async (params)=>operation(s3Client, params),
@@ -52,4 +53,10 @@ function useCreateS3FunctionMutationHook(operation, invalidationKeys) {
         });
     };
 }
-export { useCreateS3FunctionMutationHook, useCreateS3MutationHook };
+function useCreateS3FunctionMutationHook(operation, invalidationKeys) {
+    return createFunctionMutationHook(operation, useS3Client, invalidationKeys);
+}
+function useCreatePresigningMutationHook(operation, invalidationKeys) {
+    return createFunctionMutationHook(operation, usePresigningS3Client, invalidationKeys);
+}
+export { useCreatePresigningMutationHook, useCreateS3FunctionMutationHook, useCreateS3MutationHook };

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

@@ -1,3 +1,4 @@
 import { type QueryKey, type UseQueryOptions, type UseQueryResult } from '@tanstack/react-query';
 import { type EnhancedS3Error } from '../../utils/errorHandling';
+export declare function createS3QueryKey(s3ConfigIdentifier: string, operationName: string, params?: object): QueryKey;
 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

@@ -21,15 +21,18 @@ function getEmptyConfigForOperation(operationName) {
             return null;
     }
 }
+function createS3QueryKey(s3ConfigIdentifier, operationName, params) {
+    return [
+        s3ConfigIdentifier,
+        operationName,
+        params
+    ];
+}
 function useCreateS3QueryHook(Command, operationName) {
     return (params, options)=>{
         const { s3ConfigIdentifier } = useDataBrowserContext();
         const s3Client = useS3Client();
-        const queryKey = [
-            s3ConfigIdentifier,
-            operationName,
-            params
-        ];
+        const queryKey = createS3QueryKey(s3ConfigIdentifier, operationName, params);
         return useQuery({
             queryKey,
             queryFn: async ({ signal })=>{
@@ -53,4 +56,4 @@ function useCreateS3QueryHook(Command, operationName) {
         });
     };
 }
-export { useCreateS3QueryHook };
+export { createS3QueryKey, useCreateS3QueryHook };

package/dist/hooks/index.d.ts

@@ -7,6 +7,7 @@ export { useGetPresignedDownload, useGetPresignedPost, useGetPresignedUpload, }
 export { getAccessibleBucketsStorageKey, getLimitedAccessFlagKey, setLimitedAccessFlag, useAccessibleBuckets, } from './useAccessibleBuckets';
 export { useBatchObjectLegalHold } from './useBatchObjectLegalHold';
 export { type BucketConfigEditorConfig, type BucketConfigEditorResult, useBucketConfigEditor, } from './useBucketConfigEditor';
+export { useBucketLocations } from './useBucketLocations';
 export { useDeleteBucketConfigRule } from './useDeleteBucketConfigRule';
 export { useEmptyBucket } from './useEmptyBucket';
 export { useFeatures } from './useFeatures';

package/dist/hooks/index.js

@@ -6,6 +6,7 @@ import { useGetPresignedDownload, useGetPresignedPost, useGetPresignedUpload } f
 import { getAccessibleBucketsStorageKey, getLimitedAccessFlagKey, setLimitedAccessFlag, useAccessibleBuckets } from "./useAccessibleBuckets.js";
 import { useBatchObjectLegalHold } from "./useBatchObjectLegalHold.js";
 import { useBucketConfigEditor } from "./useBucketConfigEditor.js";
+import { useBucketLocations } from "./useBucketLocations.js";
 import { useDeleteBucketConfigRule } from "./useDeleteBucketConfigRule.js";
 import { useEmptyBucket } from "./useEmptyBucket.js";
 import { useFeatures } from "./useFeatures.js";
@@ -16,4 +17,4 @@ 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 };
+export { getAccessibleBucketsStorageKey, getLimitedAccessFlagKey, setLimitedAccessFlag, useAccessibleBuckets, useBatchObjectLegalHold, useBucketConfigEditor, useBucketLocations, 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/presignedOperations.js

@@ -2,7 +2,7 @@ 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";
+import { useCreatePresigningMutationHook } from "./factories/index.js";
 const generatePresignedDownloadUrl = async (client, config)=>{
     try {
         const { Bucket, Key, expiresIn = 3600, ...awsOptions } = config;
@@ -66,7 +66,7 @@ const generatePresignedPost = async (client, config)=>{
         throw createS3OperationError(error, 'GeneratePresignedPost', config.Bucket, config.Key);
     }
 };
-const useGetPresignedDownload = useCreateS3FunctionMutationHook(generatePresignedDownloadUrl);
-const useGetPresignedUpload = useCreateS3FunctionMutationHook(generatePresignedUploadUrl);
-const useGetPresignedPost = useCreateS3FunctionMutationHook(generatePresignedPost);
+const useGetPresignedDownload = useCreatePresigningMutationHook(generatePresignedDownloadUrl);
+const useGetPresignedUpload = useCreatePresigningMutationHook(generatePresignedUploadUrl);
+const useGetPresignedPost = useCreatePresigningMutationHook(generatePresignedPost);
 export { useGetPresignedDownload, useGetPresignedPost, useGetPresignedUpload };

package/dist/hooks/useBucketLocations.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Hook for fetching locations of all provided buckets in parallel.
+ * Shares query cache with useGetBucketLocation (same query keys via createS3QueryKey).
+ * Returns a Map<bucketName, locationConstraint>.
+ */
+export declare const useBucketLocations: (bucketNames: string[]) => Map<string, string>;

package/dist/hooks/useBucketLocations.js

@@ -0,0 +1,45 @@
+import { GetBucketLocationCommand } from "@aws-sdk/client-s3";
+import { useQueries } from "@tanstack/react-query";
+import { useMemo } from "react";
+import { useDataBrowserContext } from "../components/providers/DataBrowserProvider.js";
+import { createS3OperationError, shouldRetryError } from "../utils/errorHandling.js";
+import { createS3QueryKey } from "./factories/useCreateS3QueryHook.js";
+import { useS3Client } from "./useS3Client.js";
+const useBucketLocations = (bucketNames)=>{
+    const { s3ConfigIdentifier } = useDataBrowserContext();
+    const s3Client = useS3Client();
+    const results = useQueries({
+        queries: bucketNames.map((name)=>({
+                queryKey: createS3QueryKey(s3ConfigIdentifier, 'GetBucketLocation', {
+                    Bucket: name
+                }),
+                queryFn: async ({ signal })=>{
+                    try {
+                        return await s3Client.send(new GetBucketLocationCommand({
+                            Bucket: name
+                        }), {
+                            abortSignal: signal
+                        });
+                    } catch (error) {
+                        throw createS3OperationError(error, 'GetBucketLocation', name);
+                    }
+                },
+                retry: (failureCount, error)=>shouldRetryError(error, failureCount)
+            }))
+    });
+    const locationsKey = results.map((r, i)=>{
+        if ('success' === r.status && r.data) return `${bucketNames[i]}=${r.data.LocationConstraint || 'us-east-1'}`;
+        return `${bucketNames[i]}:${r.status}`;
+    }).join(',');
+    return useMemo(()=>{
+        const map = new Map();
+        for(let i = 0; i < bucketNames.length; i++){
+            const result = results[i];
+            if ('success' === result.status && result.data) map.set(bucketNames[i], result.data.LocationConstraint || 'us-east-1');
+        }
+        return map;
+    }, [
+        locationsKey
+    ]);
+};
+export { useBucketLocations };

package/dist/hooks/usePresigningS3Client.d.ts

@@ -0,0 +1,13 @@
+import { S3Client } from '@aws-sdk/client-s3';
+/**
+ * Hook to get an S3 client specifically for presigned URL generation.
+ *
+ * When proxy is configured, presigned URLs must use the proxy endpoint
+ * (browser-accessible) rather than the internal target. This client is
+ * created WITHOUT proxy middleware so that `getSignedUrl` produces URLs
+ * pointing to the proxy endpoint instead of the internal S3 service.
+ *
+ * For non-proxy configurations, this returns a standard S3 client
+ * identical to `useS3Client`.
+ */
+export declare const usePresigningS3Client: () => S3Client;

package/dist/hooks/usePresigningS3Client.js

@@ -0,0 +1,21 @@
+import { S3Client } from "@aws-sdk/client-s3";
+import { useMemo } from "react";
+import { useDataBrowserContext } from "../components/providers/DataBrowserProvider.js";
+import { resolveProxyEndpoint } from "../utils/proxyMiddleware.js";
+const usePresigningS3Client = ()=>{
+    const { s3ConfigIdentifier, getS3Config } = useDataBrowserContext();
+    if (!getS3Config) throw new Error('usePresigningS3Client: S3 config not available. Ensure DataBrowserProvider has getS3Config prop set.');
+    return useMemo(()=>{
+        const config = getS3Config();
+        const endpoint = config.proxy?.enabled ? resolveProxyEndpoint(config.proxy.endpoint) : config.endpoint;
+        return new S3Client({
+            endpoint,
+            credentials: config.credentials,
+            forcePathStyle: config.forcePathStyle ?? true,
+            region: config.region
+        });
+    }, [
+        s3ConfigIdentifier
+    ]);
+};
+export { usePresigningS3Client };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scality/data-browser-library",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "A modular React component library for browsing S3 buckets and objects",
   "type": "module",
   "types": "./dist/index.d.ts",