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

package/dist/hooks/objectOperations.js

@@ -1,66 +1,67 @@
 import { CopyObjectCommand, DeleteObjectCommand, DeleteObjectTaggingCommand, DeleteObjectsCommand, GetObjectAclCommand, GetObjectAttributesCommand, GetObjectCommand, GetObjectLegalHoldCommand, GetObjectRetentionCommand, GetObjectTaggingCommand, GetObjectTorrentCommand, HeadObjectCommand, ListMultipartUploadsCommand, ListObjectVersionsCommand, ListObjectsV2Command, PutObjectAclCommand, PutObjectCommand, PutObjectLegalHoldCommand, PutObjectRetentionCommand, PutObjectTaggingCommand, RestoreObjectCommand, SelectObjectContentCommand } from "@aws-sdk/client-s3";
+import { SearchObjectsV2Command, SearchObjectsVersionCommand } from "@scality/zenkoclient";
 import { useCreateS3InfiniteQueryHook } from "./factories/useCreateS3InfiniteQueryHook.js";
 import { useCreateS3MutationHook } from "./factories/useCreateS3MutationHook.js";
 import { useCreateS3QueryHook } from "./factories/useCreateS3QueryHook.js";
-import { SearchObjectsV2Command, SearchObjectsVersionCommand } from "@scality/zenkoclient";
-const useListObjects = useCreateS3InfiniteQueryHook(ListObjectsV2Command, "ListObjects");
-const useListObjectVersions = useCreateS3InfiniteQueryHook(ListObjectVersionsCommand, "ListObjectVersions");
-const useSearchObjects = useCreateS3InfiniteQueryHook(SearchObjectsV2Command, "SearchObjects");
-const useSearchObjectsVersions = useCreateS3InfiniteQueryHook(SearchObjectsVersionCommand, "SearchObjectsVersions");
-const useObjectMetadata = useCreateS3QueryHook(HeadObjectCommand, "HeadObject");
-const useGetObject = useCreateS3QueryHook(GetObjectCommand, "GetObject");
-const usePutObject = useCreateS3MutationHook(PutObjectCommand, "PutObject", [
-    "ListObjects",
-    "SearchObjects"
+const useListObjects = useCreateS3InfiniteQueryHook(ListObjectsV2Command, 'ListObjects');
+const useListObjectVersions = useCreateS3InfiniteQueryHook(ListObjectVersionsCommand, 'ListObjectVersions');
+const useSearchObjects = useCreateS3InfiniteQueryHook(SearchObjectsV2Command, 'SearchObjects');
+const useSearchObjectsVersions = useCreateS3InfiniteQueryHook(SearchObjectsVersionCommand, 'SearchObjectsVersions');
+const useObjectMetadata = useCreateS3QueryHook(HeadObjectCommand, 'HeadObject');
+const useGetObject = useCreateS3QueryHook(GetObjectCommand, 'GetObject');
+const usePutObject = useCreateS3MutationHook(PutObjectCommand, 'PutObject', [
+    'ListObjects',
+    'SearchObjects'
 ]);
-const useCreateFolder = useCreateS3MutationHook(PutObjectCommand, "PutObject", [
-    "ListObjects",
-    "SearchObjects"
+const useCreateFolder = useCreateS3MutationHook(PutObjectCommand, 'PutObject', [
+    'ListObjects',
+    'SearchObjects'
 ]);
-const useUploadObjects = useCreateS3MutationHook(PutObjectCommand, "PutObject", [
-    "ListObjects",
-    "SearchObjects"
+const useUploadObjects = useCreateS3MutationHook(PutObjectCommand, 'PutObject', [
+    'ListObjects',
+    'SearchObjects'
 ]);
-const useDeleteObject = useCreateS3MutationHook(DeleteObjectCommand, "DeleteObject", [
-    "ListObjects",
-    "SearchObjects"
+const useDeleteObject = useCreateS3MutationHook(DeleteObjectCommand, 'DeleteObject', [
+    'ListObjects',
+    'SearchObjects'
 ]);
-const useDeleteObjects = useCreateS3MutationHook(DeleteObjectsCommand, "DeleteObjects", [
-    "ListObjects",
-    "ListObjectVersions",
-    "SearchObjects",
-    "SearchObjectsVersions"
+const useDeleteObjects = useCreateS3MutationHook(DeleteObjectsCommand, 'DeleteObjects', [
+    'ListObjects',
+    'ListObjectVersions',
+    'SearchObjects',
+    'SearchObjectsVersions'
 ]);
-const useCopyObject = useCreateS3MutationHook(CopyObjectCommand, "CopyObject", [
-    "ListObjects",
-    "SearchObjects",
-    "HeadObject"
+const useCopyObject = useCreateS3MutationHook(CopyObjectCommand, 'CopyObject', [
+    'ListObjects',
+    'SearchObjects',
+    'HeadObject'
 ]);
-const useObjectRetention = useCreateS3QueryHook(GetObjectRetentionCommand, "GetObjectRetention");
-const useSetObjectRetention = useCreateS3MutationHook(PutObjectRetentionCommand, "PutObjectRetention", [
-    "GetObjectRetention"
+const useObjectRetention = useCreateS3QueryHook(GetObjectRetentionCommand, 'GetObjectRetention');
+const useSetObjectRetention = useCreateS3MutationHook(PutObjectRetentionCommand, 'PutObjectRetention', [
+    'GetObjectRetention'
 ]);
-const useObjectLegalHold = useCreateS3QueryHook(GetObjectLegalHoldCommand, "GetObjectLegalHold");
-const useSetObjectLegalHold = useCreateS3MutationHook(PutObjectLegalHoldCommand, "PutObjectLegalHold", [
-    "GetObjectLegalHold"
+const useObjectLegalHold = useCreateS3QueryHook(GetObjectLegalHoldCommand, 'GetObjectLegalHold');
+const useSetObjectLegalHold = useCreateS3MutationHook(PutObjectLegalHoldCommand, 'PutObjectLegalHold', [
+    'GetObjectLegalHold',
+    'BatchObjectLegalHold'
 ]);
-const useObjectTagging = useCreateS3QueryHook(GetObjectTaggingCommand, "GetObjectTagging");
-const useSetObjectTagging = useCreateS3MutationHook(PutObjectTaggingCommand, "PutObjectTagging", [
-    "GetObjectTagging"
+const useObjectTagging = useCreateS3QueryHook(GetObjectTaggingCommand, 'GetObjectTagging');
+const useSetObjectTagging = useCreateS3MutationHook(PutObjectTaggingCommand, 'PutObjectTagging', [
+    'GetObjectTagging'
 ]);
-const useDeleteObjectTagging = useCreateS3MutationHook(DeleteObjectTaggingCommand, "DeleteObjectTagging", [
-    "GetObjectTagging"
+const useDeleteObjectTagging = useCreateS3MutationHook(DeleteObjectTaggingCommand, 'DeleteObjectTagging', [
+    'GetObjectTagging'
 ]);
-const useObjectAcl = useCreateS3QueryHook(GetObjectAclCommand, "GetObjectAcl");
-const useSetObjectAcl = useCreateS3MutationHook(PutObjectAclCommand, "PutObjectAcl", [
-    "GetObjectAcl"
+const useObjectAcl = useCreateS3QueryHook(GetObjectAclCommand, 'GetObjectAcl');
+const useSetObjectAcl = useCreateS3MutationHook(PutObjectAclCommand, 'PutObjectAcl', [
+    'GetObjectAcl'
 ]);
-const useGetObjectAttributes = useCreateS3QueryHook(GetObjectAttributesCommand, "GetObjectAttributes");
-const useGetObjectTorrent = useCreateS3QueryHook(GetObjectTorrentCommand, "GetObjectTorrent");
-const useRestoreObject = useCreateS3MutationHook(RestoreObjectCommand, "RestoreObject", [
-    "HeadObject",
-    "ListObjects"
+const useGetObjectAttributes = useCreateS3QueryHook(GetObjectAttributesCommand, 'GetObjectAttributes');
+const useGetObjectTorrent = useCreateS3QueryHook(GetObjectTorrentCommand, 'GetObjectTorrent');
+const useRestoreObject = useCreateS3MutationHook(RestoreObjectCommand, 'RestoreObject', [
+    'HeadObject',
+    'ListObjects'
 ]);
-const useSelectObjectContent = useCreateS3QueryHook(SelectObjectContentCommand, "SelectObjectContent");
-const useListMultipartUploads = useCreateS3InfiniteQueryHook(ListMultipartUploadsCommand, "ListMultipartUploads");
+const useSelectObjectContent = useCreateS3QueryHook(SelectObjectContentCommand, 'SelectObjectContent');
+const useListMultipartUploads = useCreateS3InfiniteQueryHook(ListMultipartUploadsCommand, 'ListMultipartUploads');
 export { useCopyObject, useCreateFolder, useDeleteObject, useDeleteObjectTagging, useDeleteObjects, useGetObject, useGetObjectAttributes, useGetObjectTorrent, useListMultipartUploads, useListObjectVersions, useListObjects, useObjectAcl, useObjectLegalHold, useObjectMetadata, useObjectRetention, useObjectTagging, usePutObject, useRestoreObject, useSearchObjects, useSearchObjectsVersions, useSelectObjectContent, useSetObjectAcl, useSetObjectLegalHold, useSetObjectRetention, useSetObjectTagging, useUploadObjects };

package/dist/hooks/presignedOperations.d.ts

@@ -6,8 +6,8 @@
  * 2. Get Presigned POST
  * 3. Get Presigned Upload (PUT)
  */
-import { PresignedPostOptions, PresignedPost } from "@aws-sdk/s3-presigned-post";
-import { GetObjectCommandInput, PutObjectCommandInput } from "@aws-sdk/client-s3";
+import { type GetObjectCommandInput, type PutObjectCommandInput } from '@aws-sdk/client-s3';
+import { type PresignedPost, type PresignedPostOptions } from '@aws-sdk/s3-presigned-post';
 /**
  * Hook for getting presigned download URLs
  *
@@ -64,10 +64,10 @@ export declare const useGetPresignedPost: (options?: Omit<import("@tanstack/reac
     Bucket: string;
     Key: string;
     expiresIn?: number;
-} & Omit<PresignedPostOptions, "Expires" | "Bucket" | "Key">, unknown>, "mutationFn"> | undefined) => import("@tanstack/react-query").UseMutationResult<PresignedPost & {
+} & Omit<PresignedPostOptions, "Bucket" | "Expires" | "Key">, unknown>, "mutationFn"> | undefined) => import("@tanstack/react-query").UseMutationResult<PresignedPost & {
     ExpiresAt: Date;
 }, import("../utils/errorHandling").EnhancedS3Error, {
     Bucket: string;
     Key: string;
     expiresIn?: number;
-} & Omit<PresignedPostOptions, "Expires" | "Bucket" | "Key">>;
+} & Omit<PresignedPostOptions, "Bucket" | "Expires" | "Key">>;

package/dist/hooks/presignedOperations.js

@@ -1,6 +1,6 @@
-import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
-import { createPresignedPost } from "@aws-sdk/s3-presigned-post";
 import { GetObjectCommand, PutObjectCommand } from "@aws-sdk/client-s3";
+import { createPresignedPost } from "@aws-sdk/s3-presigned-post";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
 import { createS3OperationError } from "../utils/errorHandling.js";
 import { useCreateS3FunctionMutationHook } from "./factories/index.js";
 const generatePresignedDownloadUrl = async (client, config)=>{
@@ -23,7 +23,7 @@ const generatePresignedDownloadUrl = async (client, config)=>{
             VersionId: config.VersionId
         };
     } catch (error) {
-        throw createS3OperationError(error, "GeneratePresignedDownload", config.Bucket, config.Key);
+        throw createS3OperationError(error, 'GeneratePresignedDownload', config.Bucket, config.Key);
     }
 };
 const generatePresignedUploadUrl = async (client, config)=>{
@@ -45,7 +45,7 @@ const generatePresignedUploadUrl = async (client, config)=>{
             Key: Key
         };
     } catch (error) {
-        throw createS3OperationError(error, "GeneratePresignedUpload", config.Bucket, config.Key);
+        throw createS3OperationError(error, 'GeneratePresignedUpload', config.Bucket, config.Key);
     }
 };
 const generatePresignedPost = async (client, config)=>{
@@ -63,7 +63,7 @@ const generatePresignedPost = async (client, config)=>{
             ExpiresAt: expiresAt
         };
     } catch (error) {
-        throw createS3OperationError(error, "GeneratePresignedPost", config.Bucket, config.Key);
+        throw createS3OperationError(error, 'GeneratePresignedPost', config.Bucket, config.Key);
     }
 };
 const useGetPresignedDownload = useCreateS3FunctionMutationHook(generatePresignedDownloadUrl);

package/dist/hooks/useAccessibleBuckets.d.ts

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

package/dist/hooks/useAccessibleBuckets.js

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

package/dist/hooks/useBatchObjectLegalHold.d.ts

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

package/dist/hooks/useBatchObjectLegalHold.js

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

package/dist/hooks/useBucketConfigEditor.d.ts

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

package/dist/hooks/useBucketConfigEditor.js

@@ -0,0 +1,82 @@
+import { useCallback, useEffect, useMemo } from "react";
+import { useForm } from "react-hook-form";
+import { useDataBrowserNavigate } from "./useDataBrowserNavigate.js";
+const useBucketConfigEditor = (config)=>{
+    const navigate = useDataBrowserNavigate();
+    const { bucketName } = config;
+    const form = useForm({
+        mode: 'onChange',
+        defaultValues: {
+            content: ''
+        }
+    });
+    const { watch, reset } = form;
+    const content = watch('content');
+    const isCreateMode = useMemo(()=>{
+        if (!config.errorInstance) return false;
+        return config.notFoundErrorNames.some((name)=>config.errorInstance?.name === name);
+    }, [
+        config.errorInstance,
+        config.notFoundErrorNames
+    ]);
+    const initialValue = useMemo(()=>{
+        if (config.initialContent) try {
+            const parsed = JSON.parse(config.initialContent);
+            return JSON.stringify(parsed, null, 2);
+        } catch  {
+            return config.initialContent;
+        }
+        return config.defaultTemplate;
+    }, [
+        config.initialContent,
+        config.defaultTemplate
+    ]);
+    useEffect(()=>{
+        reset({
+            content: initialValue
+        });
+    }, [
+        initialValue,
+        reset
+    ]);
+    const isValidFormat = useMemo(()=>config.validate(content).isValid, [
+        content,
+        config.validate
+    ]);
+    const handleBeforeMount = useCallback((monaco)=>{
+        const jsonLanguage = monaco.languages.json;
+        if (jsonLanguage?.jsonDefaults) if (config.monacoSchema) jsonLanguage.jsonDefaults.setDiagnosticsOptions({
+            validate: true,
+            schemas: [
+                {
+                    uri: 'http://myserver/schema.json',
+                    fileMatch: [
+                        '*'
+                    ],
+                    schema: config.monacoSchema
+                }
+            ]
+        });
+        else jsonLanguage.jsonDefaults.setDiagnosticsOptions({
+            validate: true
+        });
+    }, [
+        config.monacoSchema
+    ]);
+    const navigateToBucket = useCallback(()=>{
+        navigate(`/buckets/${bucketName}`);
+    }, [
+        navigate,
+        bucketName
+    ]);
+    return {
+        bucketName,
+        form,
+        content,
+        isCreateMode,
+        isValidFormat,
+        handleBeforeMount,
+        navigateToBucket
+    };
+};
+export { useBucketConfigEditor };

package/dist/hooks/useDataBrowserNavigate.d.ts

@@ -0,0 +1,28 @@
+import { type NavigateOptions } from 'react-router';
+/**
+ * Normalizes a path by prefixing it with the basePath.
+ * Handles edge cases like missing slashes, relative paths, and root paths.
+ *
+ * @param basePath - The base path prefix (e.g., "/accounts/my-account/buckets")
+ * @param to - The target path (e.g., "/my-bucket")
+ * @returns The normalized absolute path (e.g., "/accounts/my-account/buckets/my-bucket")
+ */
+export declare const normalizePath: (basePath: string, to: string) => string;
+/**
+ * Hook for navigation with automatic basePath prefixing.
+ * Must be used within DataBrowserUI component.
+ *
+ * This hook wraps react-router's useNavigate and automatically prefixes all
+ * navigation paths with the basePath configured in DataBrowserUI props.
+ * This allows internal navigation to work correctly when DataBrowserUI is
+ * mounted at any route within the application.
+ *
+ * @example
+ * ```tsx
+ * // If DataBrowserUI has basePath="/accounts/my-account/buckets"
+ * const navigate = useDataBrowserNavigate();
+ * navigate('/my-bucket'); // Navigates to "/accounts/my-account/buckets/my-bucket"
+ * navigate(-1); // History navigation works as normal (no prefixing)
+ * ```
+ */
+export declare const useDataBrowserNavigate: () => (to: string | number, options?: NavigateOptions) => void;

package/dist/hooks/useDataBrowserNavigate.js

@@ -0,0 +1,24 @@
+import { useCallback } from "react";
+import { useNavigate } from "react-router";
+import { useDataBrowserUICustomization } from "../contexts/DataBrowserUICustomizationContext.js";
+const normalizePath = (basePath, to)=>{
+    if (!basePath) return to;
+    if (!to.startsWith('/')) return to;
+    const base = basePath.replace(/^\/+|\/+$/g, '');
+    const path = to.replace(/^\/+/, '');
+    if (!path) return base ? `/${base}` : '/';
+    return `/${base}/${path}`.replace(/\/+/g, '/');
+};
+const useDataBrowserNavigate = ()=>{
+    const navigate = useNavigate();
+    const { basePath = '' } = useDataBrowserUICustomization();
+    return useCallback((to, options)=>{
+        if ('number' == typeof to) return void navigate(to);
+        const targetPath = normalizePath(basePath, to);
+        options ? navigate(targetPath, options) : navigate(targetPath);
+    }, [
+        navigate,
+        basePath
+    ]);
+};
+export { normalizePath, useDataBrowserNavigate };

package/dist/hooks/useDeleteBucketConfigRule.d.ts

@@ -1,4 +1,4 @@
-import type { UseMutationResult } from "@tanstack/react-query";
+import type { UseMutationResult } from '@tanstack/react-query';
 interface BucketCommandInput {
     Bucket: string | undefined;
 }
@@ -10,7 +10,7 @@ interface UseDeleteBucketConfigRuleOptions<TRule extends {
     rules: TRule[];
     updateMutation: UseMutationResult<TUpdateOutput, TError, TUpdateInput, unknown>;
     deleteMutation: UseMutationResult<TDeleteOutput, TError, TDeleteInput, unknown>;
-    buildUpdateInput: (remainingRules: TRule[]) => Omit<TUpdateInput, "Bucket">;
+    buildUpdateInput: (remainingRules: TRule[]) => Omit<TUpdateInput, 'Bucket'>;
     successMessage?: string;
     errorMessage?: string;
     onSuccess?: () => void;

package/dist/hooks/useDeleteBucketConfigRule.js

@@ -1,16 +1,16 @@
 import { useToast } from "@scality/core-ui";
-function useDeleteBucketConfigRule({ bucketName, ruleId, rules, updateMutation, deleteMutation, buildUpdateInput, successMessage = "Rule deleted successfully", errorMessage = "Failed to delete rule", onSuccess, onError }) {
+function useDeleteBucketConfigRule({ bucketName, ruleId, rules, updateMutation, deleteMutation, buildUpdateInput, successMessage = 'Rule deleted successfully', errorMessage = 'Failed to delete rule', onSuccess, onError }) {
     const { showToast } = useToast();
     const { mutate: updateConfig, status: updateStatus } = updateMutation;
     const { mutate: deleteConfig, status: deleteStatus } = deleteMutation;
-    const isDeleting = "pending" === updateStatus || "pending" === deleteStatus;
+    const isDeleting = 'pending' === updateStatus || 'pending' === deleteStatus;
     const deleteRule = ()=>{
         const remainingRules = rules.filter((rule)=>rule.ID !== ruleId);
         const handleSuccess = ()=>{
             showToast({
                 open: true,
                 message: successMessage,
-                status: "success"
+                status: 'success'
             });
             onSuccess?.();
         };
@@ -20,7 +20,7 @@ function useDeleteBucketConfigRule({ bucketName, ruleId, rules, updateMutation,
             showToast({
                 open: true,
                 message: displayMessage,
-                status: "error"
+                status: 'error'
             });
             onError?.(errorToReport);
         };

package/dist/hooks/useEmptyBucket.js

@@ -1,14 +1,14 @@
+import { DeleteObjectsCommand, ListObjectVersionsCommand } from "@aws-sdk/client-s3";
 import { useCallback, useState } from "react";
-import { useQueryClient } from "@tanstack/react-query";
+import { useInvalidateQueries } from "../components/providers/DataBrowserProvider.js";
 import { useS3Client } from "./useS3Client.js";
-import { DeleteObjectsCommand, ListObjectVersionsCommand } from "@aws-sdk/client-s3";
 const useEmptyBucket = (options = {})=>{
     const { maxObjects = 20000, maxKeysPerList = 1000, bypassGovernanceRetention = true, onProgress, onSuccess, onError } = options;
     const [isEmptying, setIsEmptying] = useState(false);
     const [error, setError] = useState(null);
     const [result, setResult] = useState(null);
     const s3Client = useS3Client();
-    const queryClient = useQueryClient();
+    const invalidateQueries = useInvalidateQueries();
     const emptyBucket = useCallback(async (bucketName)=>{
         setIsEmptying(true);
         setError(null);
@@ -50,7 +50,7 @@ const useEmptyBucket = (options = {})=>{
                 deletedCount += successCount;
                 totalAttempted += objectsToDelete.length;
                 if (deleteResponse.Errors) allErrors.push(...deleteResponse.Errors.map((error)=>({
-                        key: error.Key || "unknown",
+                        key: error.Key || 'unknown',
                         code: error.Code,
                         message: error.Message
                     })));
@@ -70,20 +70,20 @@ const useEmptyBucket = (options = {})=>{
                 limitReached
             };
             setResult(bucketResult);
-            queryClient.invalidateQueries({
+            invalidateQueries({
                 queryKey: [
-                    "ListObjects"
+                    'ListObjects'
                 ]
             });
-            queryClient.invalidateQueries({
+            invalidateQueries({
                 queryKey: [
-                    "ListObjectVersions"
+                    'ListObjectVersions'
                 ]
             });
             onSuccess?.(bucketResult);
             return bucketResult;
         } catch (err) {
-            const errorObj = err instanceof Error ? err : new Error("Failed to empty bucket");
+            const errorObj = err instanceof Error ? err : new Error('Failed to empty bucket');
             setError(errorObj);
             onError?.(errorObj);
             return null;
@@ -92,13 +92,13 @@ const useEmptyBucket = (options = {})=>{
         }
     }, [
         s3Client,
+        invalidateQueries,
         maxObjects,
         maxKeysPerList,
         bypassGovernanceRetention,
         onProgress,
         onSuccess,
-        onError,
-        queryClient
+        onError
     ]);
     const reset = useCallback(()=>{
         setIsEmptying(false);