@scality/data-browser-library 1.0.4 → 1.0.6

package/dist/components/objects/ObjectPage.js

@@ -10,11 +10,13 @@ const ObjectPage = ()=>{
     const navigate = useDataBrowserNavigate();
     const [searchParams] = useSearchParams();
     const [item, setItem] = useState(null);
+    const [multipleSelected, setMultipleSelected] = useState(false);
     const prefix = searchParams.get('prefix') || '';
     const handlePrefixChange = useCallback((newPrefix)=>{
         const newSearchParams = new URLSearchParams(searchParams);
         newSearchParams.set('prefix', newPrefix);
         setItem(null);
+        setMultipleSelected(false);
         navigate(`?${newSearchParams.toString()}`, {
             replace: true
         });
@@ -22,12 +24,25 @@ const ObjectPage = ()=>{
         navigate,
         searchParams
     ]);
+    const handleObjectSelect = useCallback((object)=>{
+        setItem(object);
+        setMultipleSelected(false);
+    }, []);
+    const handleSelectedObjectsChange = useCallback((objects)=>{
+        if (1 === objects.length) {
+            setItem(objects[0]);
+            setMultipleSelected(false);
+        } else if (objects.length > 1) {
+            setItem(null);
+            setMultipleSelected(true);
+        } else {
+            setItem(null);
+            setMultipleSelected(false);
+        }
+    }, []);
     if (!bucketName) return /*#__PURE__*/ jsx("div", {
         children: "Bucket name is required"
     });
-    const handleObjectSelect = (object)=>{
-        setItem(object);
-    };
     return /*#__PURE__*/ jsx(BrowserPageLayout, {
         iconName: "Bucket",
         title: bucketName,
@@ -35,10 +50,12 @@ const ObjectPage = ()=>{
             bucketName: bucketName,
             prefix: prefix,
             onObjectSelect: handleObjectSelect,
-            onPrefixChange: handlePrefixChange
+            onPrefixChange: handlePrefixChange,
+            onSelectedObjectsChange: handleSelectedObjectsChange
         }),
         rightPanel: /*#__PURE__*/ jsx(ObjectDetails, {
-            item: item
+            item: item,
+            multipleSelected: multipleSelected
         }),
         withArrowNavigation: true,
         arrowNavigationPath: `/buckets/${bucketName}`

package/dist/components/ui/ArrayFieldActions.js

@@ -1,11 +1,9 @@
 import { jsx, jsxs } from "react/jsx-runtime";
 import { Icon, spacing } from "@scality/core-ui";
-import { convertSizeToRem } from "@scality/core-ui/dist/components/inputv2/inputv2";
 import { Box, Button } from "@scality/core-ui/dist/next";
 function ArrayFieldActions({ onRemove, onAdd, canRemove, canAdd = true, showAdd, removeLabel = 'Remove', addLabel = 'Add' }) {
     return /*#__PURE__*/ jsxs(Box, {
         display: "flex",
-        width: convertSizeToRem('1/2'),
         gap: spacing.r8,
         justifyContent: "flex-start",
         children: [

package/dist/components/ui/FilterFormSection.js

@@ -1,8 +1,9 @@
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
-import { FormGroup, FormSection, Stack, Text } from "@scality/core-ui";
+import { FormGroup, FormSection, Stack } from "@scality/core-ui";
 import { convertRemToPixels } from "@scality/core-ui/dist/components/tablev2/TableUtils";
-import { Box, Input, Select } from "@scality/core-ui/dist/next";
+import { Input, Select } from "@scality/core-ui/dist/next";
 import { ArrayFieldActions } from "./ArrayFieldActions.js";
+import { FormCell, FormColumnHeaders, FormRow } from "./FormGrid.js";
 const filterTypeOptions = [
     {
         value: 'none',
@@ -68,42 +69,22 @@ function FilterFormSection({ filterType, onFilterTypeChange, prefixRegister, tag
                     direction: "vertical",
                     gap: "r8",
                     children: [
-                        /*#__PURE__*/ jsxs(Stack, {
-                            gap: "r8",
-                            children: [
-                                /*#__PURE__*/ jsx(Box, {
-                                    flex: "1",
-                                    children: /*#__PURE__*/ jsx(Text, {
-                                        color: "textSecondary",
-                                        children: "Key"
-                                    })
-                                }),
-                                /*#__PURE__*/ jsx(Box, {
-                                    flex: "1",
-                                    children: /*#__PURE__*/ jsx(Text, {
-                                        color: "textSecondary",
-                                        children: "Value"
-                                    })
-                                }),
-                                /*#__PURE__*/ jsx(Box, {
-                                    width: "80px"
-                                })
-                            ]
-                        }),
-                        tagFields.map((field, index)=>/*#__PURE__*/ jsxs(Stack, {
-                                gap: "r8",
+                        /*#__PURE__*/ jsx(FormColumnHeaders, {}),
+                        tagFields.map((field, index)=>/*#__PURE__*/ jsxs(FormRow, {
                                 children: [
-                                    /*#__PURE__*/ jsx(Input, {
-                                        id: `tag-key-${index}`,
-                                        placeholder: "Key",
-                                        size: "1/2",
-                                        ...tagKeyRegister(index)
+                                    /*#__PURE__*/ jsx(FormCell, {
+                                        children: /*#__PURE__*/ jsx(Input, {
+                                            id: `tag-key-${index}`,
+                                            placeholder: "Key",
+                                            ...tagKeyRegister(index)
+                                        })
                                     }),
-                                    /*#__PURE__*/ jsx(Input, {
-                                        id: `tag-value-${index}`,
-                                        placeholder: "Value",
-                                        size: "1/2",
-                                        ...tagValueRegister(index)
+                                    /*#__PURE__*/ jsx(FormCell, {
+                                        children: /*#__PURE__*/ jsx(Input, {
+                                            id: `tag-value-${index}`,
+                                            placeholder: "Value",
+                                            ...tagValueRegister(index)
+                                        })
                                     }),
                                     /*#__PURE__*/ jsx(ArrayFieldActions, {
                                         showAdd: index === tagFields.length - 1,

package/dist/components/ui/FormGrid.d.ts

@@ -0,0 +1,7 @@
+export declare const FormRow: import("styled-components").StyledComponent<"div", any, {
+    columns?: string;
+}, never>;
+export declare const FormCell: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const FormColumnHeaders: ({ wideKey }: {
+    wideKey?: boolean;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/components/ui/FormGrid.js

@@ -0,0 +1,37 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Text, spacing } from "@scality/core-ui";
+import styled_components from "styled-components";
+const ACTIONS_WIDTH = `calc(${spacing.r32} * 2 + ${spacing.r8})`;
+const FormRow = styled_components.div`
+  display: grid;
+  grid-template-columns: ${({ columns })=>columns || '1fr 1fr'} ${ACTIONS_WIDTH};
+  gap: ${spacing.r8};
+  align-items: center;
+`;
+const FormCell = styled_components.div`
+  min-width: 0;
+  > * {
+    width: 100% !important;
+  }
+`;
+const FormColumnHeaders = ({ wideKey })=>/*#__PURE__*/ jsxs(FormRow, {
+        columns: wideKey ? '3fr auto 2fr' : void 0,
+        children: [
+            /*#__PURE__*/ jsx(Text, {
+                color: "textPrimary",
+                children: "Key"
+            }),
+            wideKey && /*#__PURE__*/ jsx("span", {
+                style: {
+                    visibility: 'hidden'
+                },
+                children: ":"
+            }),
+            /*#__PURE__*/ jsx(Text, {
+                color: "textPrimary",
+                children: "Value"
+            }),
+            /*#__PURE__*/ jsx("span", {})
+        ]
+    });
+export { FormCell, FormColumnHeaders, FormRow };

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/__tests__/factory.test.js

@@ -212,7 +212,9 @@ describe('s3RuntimeConfigSchema', ()=>{
                     endpoint: 'https://s3.amazonaws.com',
                     region: 'us-east-1',
                     forcePathStyle: true
-                }
+                },
+                allowCustomEndpoint: true,
+                allowSessionToken: true
             };
             const { error } = s3RuntimeConfigSchema.validate(config);
             expect(error).toBeUndefined();
@@ -282,6 +284,32 @@ describe('s3RuntimeConfigSchema', ()=>{
             expect(error).toBeDefined();
             expect(error?.message).toContain('boolean');
         });
+        it('should reject config with wrong type for allowCustomEndpoint', ()=>{
+            const config = {
+                s3: {
+                    region: 'us-east-1'
+                },
+                allowCustomEndpoint: 'yes'
+            };
+            const { error } = s3RuntimeConfigSchema.validate(config, {
+                convert: false
+            });
+            expect(error).toBeDefined();
+            expect(error?.message).toContain('boolean');
+        });
+        it('should reject config with wrong type for allowSessionToken', ()=>{
+            const config = {
+                s3: {
+                    region: 'us-east-1'
+                },
+                allowSessionToken: 'yes'
+            };
+            const { error } = s3RuntimeConfigSchema.validate(config, {
+                convert: false
+            });
+            expect(error).toBeDefined();
+            expect(error?.message).toContain('boolean');
+        });
     });
     describe('Schema behavior', ()=>{
         it('should return all validation errors when abortEarly is false', ()=>{

package/dist/config/factory.d.ts

@@ -5,6 +5,8 @@ export type S3RuntimeConfig = {
         region: string;
         forcePathStyle?: boolean;
     };
+    allowCustomEndpoint?: boolean;
+    allowSessionToken?: boolean;
 };
 export declare const s3RuntimeConfigSchema: Joi.ObjectSchema<any>;
 /**

package/dist/config/factory.js

@@ -4,7 +4,9 @@ const s3RuntimeConfigSchema = joi.object({
         endpoint: joi.string().optional().allow('origin'),
         region: joi.string().min(1).required(),
         forcePathStyle: joi.boolean().optional()
-    }).required()
+    }).required(),
+    allowCustomEndpoint: joi.boolean().optional(),
+    allowSessionToken: joi.boolean().optional()
 });
 async function loadRuntimeConfig(configUrl) {
     const response = await fetch(configUrl);

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