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

package/dist/components/buckets/notifications/EventsSection.js

@@ -1,39 +1,70 @@
 import { jsx, jsxs } from "react/jsx-runtime";
 import { Checkbox, FormGroup, FormSection, Stack, Text, Wrap } from "@scality/core-ui";
-import { useCallback } from "react";
-import { Controller, useFormContext } from "react-hook-form";
-import { objectCreationEvents, objectDeletionEvents, othersEvents } from "./events.js";
 import { Box } from "@scality/core-ui/dist/next";
+import { useCallback, useMemo } from "react";
+import { Controller, useFormContext } from "react-hook-form";
+import { useSupportedNotificationEvents } from "../../../hooks/useSupportedNotificationEvents.js";
+import { getFilteredEventGroups } from "./events.js";
 function EventsSection() {
     const { control, formState: { errors } } = useFormContext();
+    const supportedEvents = useSupportedNotificationEvents();
+    const eventGroups = useMemo(()=>getFilteredEventGroups(supportedEvents), [
+        supportedEvents
+    ]);
+    const { objectCreation, objectDeletion, objectRestoration, lifecycle, replication, objectTagging, storageAccess, testing } = eventGroups;
+    const getRelatedEvents = useCallback((eventValue)=>{
+        const basePattern = eventValue.slice(0, -1);
+        const eventGroupMap = {
+            's3:ObjectCreated': objectCreation.events,
+            's3:ObjectRemoved': objectDeletion.events,
+            's3:ObjectRestore': objectRestoration.events,
+            's3:Replication': replication.events,
+            's3:ObjectTagging': objectTagging.events
+        };
+        for (const [prefix, events] of Object.entries(eventGroupMap))if (eventValue.startsWith(prefix)) return events;
+        if (eventValue.startsWith('s3:LifecycleExpiration')) return lifecycle.events.filter((e)=>e.startsWith(basePattern));
+        return [
+            eventValue
+        ];
+    }, [
+        objectCreation.events,
+        objectDeletion.events,
+        objectRestoration.events,
+        lifecycle.events,
+        replication.events,
+        objectTagging.events
+    ]);
     const toggleEvent = useCallback((currentEvents, eventValue, onChange)=>{
-        const isWildcard = eventValue.endsWith("*");
+        const isWildcard = eventValue.endsWith('*');
         const isSelected = currentEvents.includes(eventValue);
-        if (isWildcard) if (isSelected) {
-            const relatedEvents = eventValue.startsWith("s3:ObjectCreated") ? objectCreationEvents.events : eventValue.startsWith("s3:ObjectRemoved") ? objectDeletionEvents.events : eventValue.startsWith("s3:LifecycleExpiration") ? othersEvents.events.filter((e)=>e.startsWith("s3:LifecycleExpiration")) : [
-                eventValue
-            ];
-            onChange(currentEvents.filter((e)=>!relatedEvents.includes(e)));
-        } else {
-            const relatedEvents = eventValue.startsWith("s3:ObjectCreated") ? objectCreationEvents.events : eventValue.startsWith("s3:ObjectRemoved") ? objectDeletionEvents.events : eventValue.startsWith("s3:LifecycleExpiration") ? othersEvents.events.filter((e)=>e.startsWith("s3:LifecycleExpiration")) : [
+        if (!isWildcard) {
+            const newEvents = isSelected ? currentEvents.filter((e)=>e !== eventValue) : [
+                ...currentEvents,
                 eventValue
             ];
+            onChange(newEvents);
+            return;
+        }
+        const relatedEvents = getRelatedEvents(eventValue);
+        if (isSelected) onChange(currentEvents.filter((e)=>!relatedEvents.includes(e)));
+        else {
             const newEvents = [
                 ...currentEvents.filter((e)=>!relatedEvents.includes(e)),
                 ...relatedEvents
             ];
             onChange(newEvents);
         }
-        else onChange(isSelected ? currentEvents.filter((e)=>e !== eventValue) : [
-            ...currentEvents,
-            eventValue
-        ]);
-    }, []);
+    }, [
+        getRelatedEvents
+    ]);
     const isEventDisabled = (event, selectedEvents)=>{
-        if (event.endsWith("*")) return false;
-        if (event.startsWith("s3:ObjectCreated")) return selectedEvents.includes("s3:ObjectCreated:*");
-        if (event.startsWith("s3:ObjectRemoved")) return selectedEvents.includes("s3:ObjectRemoved:*");
-        if (event.startsWith("s3:LifecycleExpiration")) return selectedEvents.includes("s3:LifecycleExpiration:*");
+        if (event.endsWith('*')) return false;
+        if (event.startsWith('s3:ObjectCreated')) return selectedEvents.includes('s3:ObjectCreated:*');
+        if (event.startsWith('s3:ObjectRemoved')) return selectedEvents.includes('s3:ObjectRemoved:*');
+        if (event.startsWith('s3:ObjectRestore')) return selectedEvents.includes('s3:ObjectRestore:*');
+        if (event.startsWith('s3:LifecycleExpiration')) return selectedEvents.includes('s3:LifecycleExpiration:*');
+        if (event.startsWith('s3:Replication')) return selectedEvents.includes('s3:Replication:*');
+        else if (event.startsWith('s3:ObjectTagging')) return selectedEvents.includes('s3:ObjectTagging:*');
         return false;
     };
     return /*#__PURE__*/ jsxs(FormSection, {
@@ -62,15 +93,100 @@ function EventsSection() {
                             direction: "vertical",
                             gap: "r16",
                             children: [
-                                /*#__PURE__*/ jsxs(Stack, {
+                                objectCreation.events.length > 0 && /*#__PURE__*/ jsxs(Stack, {
+                                    direction: "vertical",
+                                    gap: "r8",
+                                    children: [
+                                        /*#__PURE__*/ jsx(Text, {
+                                            color: "textPrimary",
+                                            children: objectCreation.label
+                                        }),
+                                        objectCreation.events.map((event)=>/*#__PURE__*/ jsx(Checkbox, {
+                                                id: event,
+                                                label: event,
+                                                checked: value.includes(event),
+                                                disabled: isEventDisabled(event, value),
+                                                onChange: ()=>toggleEvent(value, event, onChange)
+                                            }, event))
+                                    ]
+                                }),
+                                objectDeletion.events.length > 0 && /*#__PURE__*/ jsxs(Stack, {
+                                    direction: "vertical",
+                                    gap: "r8",
+                                    children: [
+                                        /*#__PURE__*/ jsx(Text, {
+                                            color: "textPrimary",
+                                            children: objectDeletion.label
+                                        }),
+                                        objectDeletion.events.map((event)=>/*#__PURE__*/ jsx(Checkbox, {
+                                                id: event,
+                                                label: event,
+                                                checked: value.includes(event),
+                                                disabled: isEventDisabled(event, value),
+                                                onChange: ()=>toggleEvent(value, event, onChange)
+                                            }, event))
+                                    ]
+                                }),
+                                objectRestoration.events.length > 0 && /*#__PURE__*/ jsxs(Stack, {
+                                    direction: "vertical",
+                                    gap: "r8",
+                                    children: [
+                                        /*#__PURE__*/ jsx(Text, {
+                                            color: "textPrimary",
+                                            children: objectRestoration.label
+                                        }),
+                                        objectRestoration.events.map((event)=>/*#__PURE__*/ jsx(Checkbox, {
+                                                id: event,
+                                                label: event,
+                                                checked: value.includes(event),
+                                                disabled: isEventDisabled(event, value),
+                                                onChange: ()=>toggleEvent(value, event, onChange)
+                                            }, event))
+                                    ]
+                                }),
+                                lifecycle.events.length > 0 && /*#__PURE__*/ jsxs(Stack, {
+                                    direction: "vertical",
+                                    gap: "r8",
+                                    children: [
+                                        /*#__PURE__*/ jsx(Text, {
+                                            color: "textPrimary",
+                                            children: lifecycle.label
+                                        }),
+                                        lifecycle.events.map((event)=>/*#__PURE__*/ jsx(Checkbox, {
+                                                id: event,
+                                                label: event,
+                                                checked: value.includes(event),
+                                                disabled: isEventDisabled(event, value),
+                                                onChange: ()=>toggleEvent(value, event, onChange)
+                                            }, event))
+                                    ]
+                                }),
+                                replication.events.length > 0 && /*#__PURE__*/ jsxs(Stack, {
+                                    direction: "vertical",
+                                    gap: "r8",
+                                    children: [
+                                        /*#__PURE__*/ jsx(Text, {
+                                            color: "textPrimary",
+                                            children: replication.label
+                                        }),
+                                        replication.events.map((event)=>/*#__PURE__*/ jsx(Checkbox, {
+                                                id: event,
+                                                label: event,
+                                                checked: value.includes(event),
+                                                disabled: isEventDisabled(event, value),
+                                                onChange: ()=>toggleEvent(value, event, onChange)
+                                            }, event))
+                                    ]
+                                }),
+                                objectTagging.events.length > 0 && /*#__PURE__*/ jsxs(Stack, {
                                     direction: "vertical",
                                     gap: "r8",
                                     children: [
                                         /*#__PURE__*/ jsx(Text, {
                                             color: "textPrimary",
-                                            children: objectCreationEvents.label
+                                            children: objectTagging.label
                                         }),
-                                        objectCreationEvents.events.map((event)=>/*#__PURE__*/ jsx(Checkbox, {
+                                        objectTagging.events.map((event)=>/*#__PURE__*/ jsx(Checkbox, {
                                                 id: event,
                                                 label: event,
                                                 checked: value.includes(event),
@@ -79,15 +195,15 @@ function EventsSection() {
                                             }, event))
                                     ]
                                 }),
-                                /*#__PURE__*/ jsxs(Stack, {
+                                storageAccess.events.length > 0 && /*#__PURE__*/ jsxs(Stack, {
                                     direction: "vertical",
                                     gap: "r8",
                                     children: [
                                         /*#__PURE__*/ jsx(Text, {
                                             color: "textPrimary",
-                                            children: objectDeletionEvents.label
+                                            children: storageAccess.label
                                         }),
-                                        objectDeletionEvents.events.map((event)=>/*#__PURE__*/ jsx(Checkbox, {
+                                        storageAccess.events.map((event)=>/*#__PURE__*/ jsx(Checkbox, {
                                                 id: event,
                                                 label: event,
                                                 checked: value.includes(event),
@@ -96,15 +212,15 @@ function EventsSection() {
                                             }, event))
                                     ]
                                 }),
-                                /*#__PURE__*/ jsxs(Stack, {
+                                testing.events.length > 0 && /*#__PURE__*/ jsxs(Stack, {
                                     direction: "vertical",
                                     gap: "r8",
                                     children: [
                                         /*#__PURE__*/ jsx(Text, {
                                             color: "textPrimary",
-                                            children: othersEvents.label
+                                            children: testing.label
                                         }),
-                                        othersEvents.events.map((event)=>/*#__PURE__*/ jsx(Checkbox, {
+                                        testing.events.map((event)=>/*#__PURE__*/ jsx(Checkbox, {
                                                 id: event,
                                                 label: event,
                                                 checked: value.includes(event),

package/dist/components/buckets/notifications/__tests__/events.test.d.ts

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

package/dist/components/buckets/notifications/__tests__/events.test.js

@@ -0,0 +1,56 @@
+import { filterSupportedEvents, getFilteredEventGroups } from "../events.js";
+describe('events', ()=>{
+    it('returns all events when supportedEvents is not configured', ()=>{
+        const events = [
+            's3:ObjectCreated:*',
+            's3:ObjectCreated:Put'
+        ];
+        const result = filterSupportedEvents(events);
+        expect(result).toEqual(events);
+    });
+    it('filters events to only include supported ones', ()=>{
+        const events = [
+            's3:ObjectCreated:*',
+            's3:ObjectCreated:Put',
+            's3:ObjectCreated:Copy'
+        ];
+        const supportedEvents = [
+            's3:ObjectCreated:*',
+            's3:ObjectCreated:Put'
+        ];
+        const result = filterSupportedEvents(events, supportedEvents);
+        expect(result).toEqual([
+            's3:ObjectCreated:*',
+            's3:ObjectCreated:Put'
+        ]);
+    });
+    it('filters event groups based on supported events', ()=>{
+        const supportedEvents = [
+            's3:ObjectCreated:Put',
+            's3:ObjectRemoved:Delete',
+            's3:Replication:OperationFailedReplication'
+        ];
+        const result = getFilteredEventGroups(supportedEvents);
+        expect(result.objectCreation.events).toEqual([
+            's3:ObjectCreated:Put'
+        ]);
+        expect(result.objectDeletion.events).toEqual([
+            's3:ObjectRemoved:Delete'
+        ]);
+        expect(result.replication.events).toEqual([
+            's3:Replication:OperationFailedReplication'
+        ]);
+        expect(result.lifecycle.events).toEqual([]);
+    });
+    it('preserves category labels in filtered groups', ()=>{
+        const result = getFilteredEventGroups();
+        expect(result.objectCreation.label).toBe('Object Creation');
+        expect(result.objectDeletion.label).toBe('Object Deletion');
+        expect(result.objectRestoration.label).toBe('Object Restoration');
+        expect(result.lifecycle.label).toBe('Lifecycle');
+        expect(result.replication.label).toBe('Replication');
+        expect(result.objectTagging.label).toBe('Object Tagging');
+        expect(result.storageAccess.label).toBe('Storage & Access');
+        expect(result.testing.label).toBe('Testing');
+    });
+});

package/dist/components/buckets/notifications/events.d.ts

@@ -1,12 +1,76 @@
+import type { S3EventCategory, S3EventType } from '../../../config/types';
 export declare const objectCreationEvents: {
-    label: string;
-    events: string[];
+    label: S3EventCategory;
+    events: S3EventType[];
 };
 export declare const objectDeletionEvents: {
-    label: string;
-    events: string[];
+    label: S3EventCategory;
+    events: S3EventType[];
 };
-export declare const othersEvents: {
-    label: string;
-    events: string[];
+export declare const objectRestorationEvents: {
+    label: S3EventCategory;
+    events: S3EventType[];
+};
+export declare const lifecycleEvents: {
+    label: S3EventCategory;
+    events: S3EventType[];
+};
+export declare const replicationEvents: {
+    label: S3EventCategory;
+    events: S3EventType[];
+};
+export declare const objectTaggingEvents: {
+    label: S3EventCategory;
+    events: S3EventType[];
+};
+export declare const storageAccessEvents: {
+    label: S3EventCategory;
+    events: S3EventType[];
+};
+export declare const testingEvents: {
+    label: S3EventCategory;
+    events: S3EventType[];
+};
+/**
+ * Filters events to only include supported ones
+ * If no supported events are configured, all events are returned
+ */
+export declare function filterSupportedEvents(events: S3EventType[], supportedEvents?: S3EventType[]): S3EventType[];
+/**
+ * Gets filtered event groups based on supported events
+ * If a wildcard is not supported, but specific events are, the wildcard is filtered out
+ */
+export declare function getFilteredEventGroups(supportedEvents?: S3EventType[]): {
+    objectCreation: {
+        label: S3EventCategory;
+        events: S3EventType[];
+    };
+    objectDeletion: {
+        label: S3EventCategory;
+        events: S3EventType[];
+    };
+    objectRestoration: {
+        label: S3EventCategory;
+        events: S3EventType[];
+    };
+    lifecycle: {
+        label: S3EventCategory;
+        events: S3EventType[];
+    };
+    replication: {
+        label: S3EventCategory;
+        events: S3EventType[];
+    };
+    objectTagging: {
+        label: S3EventCategory;
+        events: S3EventType[];
+    };
+    storageAccess: {
+        label: S3EventCategory;
+        events: S3EventType[];
+    };
+    testing: {
+        label: S3EventCategory;
+        events: S3EventType[];
+    };
 };

package/dist/components/buckets/notifications/events.js

@@ -1,27 +1,109 @@
 const objectCreationEvents = {
-    label: "Object creation",
+    label: 'Object Creation',
     events: [
-        "s3:ObjectCreated:*",
-        "s3:ObjectCreated:Put",
-        "s3:ObjectCreated:Copy",
-        "s3:ObjectCreated:CompleteMultipartUpload"
+        's3:ObjectCreated:*',
+        's3:ObjectCreated:Put',
+        's3:ObjectCreated:Post',
+        's3:ObjectCreated:Copy',
+        's3:ObjectCreated:CompleteMultipartUpload'
     ]
 };
 const objectDeletionEvents = {
-    label: "Object deletion",
+    label: 'Object Deletion',
     events: [
-        "s3:ObjectRemoved:*",
-        "s3:ObjectRemoved:Delete",
-        "s3:ObjectRemoved:DeleteMarkerCreated"
+        's3:ObjectRemoved:*',
+        's3:ObjectRemoved:Delete',
+        's3:ObjectRemoved:DeleteMarkerCreated'
     ]
 };
-const othersEvents = {
-    label: "Others",
+const objectRestorationEvents = {
+    label: 'Object Restoration',
     events: [
-        "s3:Replication:OperationFailedReplication",
-        "s3:LifecycleExpiration:*",
-        "s3:LifecycleExpiration:DeleteMarkerCreated",
-        "s3:LifecycleExpiration:Delete"
+        's3:ObjectRestore:*',
+        's3:ObjectRestore:Post',
+        's3:ObjectRestore:Completed',
+        's3:ObjectRestore:Delete'
     ]
 };
-export { objectCreationEvents, objectDeletionEvents, othersEvents };
+const lifecycleEvents = {
+    label: 'Lifecycle',
+    events: [
+        's3:LifecycleExpiration:*',
+        's3:LifecycleExpiration:Delete',
+        's3:LifecycleExpiration:DeleteMarkerCreated',
+        's3:LifecycleTransition'
+    ]
+};
+const replicationEvents = {
+    label: 'Replication',
+    events: [
+        's3:Replication:*',
+        's3:Replication:OperationFailedReplication',
+        's3:Replication:OperationMissedThreshold',
+        's3:Replication:OperationReplicatedAfterThreshold',
+        's3:Replication:OperationNotTracked'
+    ]
+};
+const objectTaggingEvents = {
+    label: 'Object Tagging',
+    events: [
+        's3:ObjectTagging:*',
+        's3:ObjectTagging:Put',
+        's3:ObjectTagging:Delete'
+    ]
+};
+const storageAccessEvents = {
+    label: 'Storage & Access',
+    events: [
+        's3:ReducedRedundancyLostObject',
+        's3:IntelligentTiering',
+        's3:ObjectAcl:Put'
+    ]
+};
+const testingEvents = {
+    label: 'Testing',
+    events: [
+        's3:TestEvent'
+    ]
+};
+function filterSupportedEvents(events, supportedEvents) {
+    if (!supportedEvents || 0 === supportedEvents.length) return events;
+    return events.filter((event)=>supportedEvents.includes(event));
+}
+function getFilteredEventGroups(supportedEvents) {
+    return {
+        objectCreation: {
+            label: objectCreationEvents.label,
+            events: filterSupportedEvents(objectCreationEvents.events, supportedEvents)
+        },
+        objectDeletion: {
+            label: objectDeletionEvents.label,
+            events: filterSupportedEvents(objectDeletionEvents.events, supportedEvents)
+        },
+        objectRestoration: {
+            label: objectRestorationEvents.label,
+            events: filterSupportedEvents(objectRestorationEvents.events, supportedEvents)
+        },
+        lifecycle: {
+            label: lifecycleEvents.label,
+            events: filterSupportedEvents(lifecycleEvents.events, supportedEvents)
+        },
+        replication: {
+            label: replicationEvents.label,
+            events: filterSupportedEvents(replicationEvents.events, supportedEvents)
+        },
+        objectTagging: {
+            label: objectTaggingEvents.label,
+            events: filterSupportedEvents(objectTaggingEvents.events, supportedEvents)
+        },
+        storageAccess: {
+            label: storageAccessEvents.label,
+            events: filterSupportedEvents(storageAccessEvents.events, supportedEvents)
+        },
+        testing: {
+            label: testingEvents.label,
+            events: filterSupportedEvents(testingEvents.events, supportedEvents)
+        }
+    };
+}
+export { filterSupportedEvents, getFilteredEventGroups, lifecycleEvents, objectCreationEvents, objectDeletionEvents, objectRestorationEvents, objectTaggingEvents, replicationEvents, storageAccessEvents, testingEvents };

package/dist/components/index.d.ts

@@ -1,13 +1,27 @@
-export { DeleteBucketButton } from "./buckets/DeleteBucketButton";
-export { BucketList } from "./buckets/BucketList";
-export { BucketOverview } from "./buckets/BucketOverview";
-export { BucketPage } from "./buckets/BucketPage";
-export { BucketPolicyPage } from "./buckets/BucketPolicyPage";
-export { BucketNotificationCreatePage } from "./buckets/notifications/BucketNotificationCreatePage";
-export { UploadButton } from "./objects/UploadButton";
-export { CreateFolderButton } from "./objects/CreateFolderButton";
-export { ObjectDetails } from "./objects/ObjectDetails";
-export { ObjectList } from "./objects/ObjectList";
-export { ObjectPage } from "./objects/ObjectPage";
-export { MetadataSearch } from "./search/MetadataSearch";
-export { DataBrowserProvider, useDataBrowserContext, useDataBrowserTheme, } from "./providers/DataBrowserProvider";
+export { useDataBrowserNavigate } from '../hooks/useDataBrowserNavigate';
+export { Breadcrumb, type BreadcrumbItem, DataBrowserBreadcrumb, useBreadcrumbPaths, } from './breadcrumb';
+export { BucketAccessor } from './buckets/BucketAccessor';
+export { BucketCorsPage } from './buckets/BucketCorsPage';
+export { BucketCreate, type BucketCreateFormData, baseBucketCreateSchema, bucketErrorMessage, bucketNameValidationSchema, } from './buckets/BucketCreate';
+export { BucketLifecycleFormPage } from './buckets/BucketLifecycleFormPage';
+export { BucketList } from './buckets/BucketList';
+export { BucketOverview, BucketOverviewField, BucketOverviewSection, useBucketOverviewContext, } from './buckets/BucketOverview';
+export { BucketPage } from './buckets/BucketPage';
+export { BucketPolicyPage } from './buckets/BucketPolicyPage';
+export { BucketReplicationFormPage } from './buckets/BucketReplicationFormPage';
+export { BucketVersioning } from './buckets/BucketVersioning';
+export { DeleteBucketButton } from './buckets/DeleteBucketButton';
+export { EmptyBucketButton } from './buckets/EmptyBucketButton';
+export { BucketNotificationFormPage } from './buckets/notifications/BucketNotificationFormPage';
+export { DataBrowserUI } from './DataBrowserUI';
+export { CreateFolderButton } from './objects/CreateFolderButton';
+export { ObjectDetails } from './objects/ObjectDetails';
+export { ObjectList, type TableItem } from './objects/ObjectList';
+export { EditRetentionButton } from './objects/ObjectLock/EditRetentionButton';
+export { ObjectLockSettings } from './objects/ObjectLock/ObjectLockSettings';
+export { ObjectPage } from './objects/ObjectPage';
+export { UploadButton } from './objects/UploadButton';
+export { DataBrowserProvider, useDataBrowserConfig, useDataBrowserContext, useInvalidateQueries, } from './providers/DataBrowserProvider';
+export { QueryProvider } from './providers/QueryProvider';
+export { MetadataSearch } from './search/MetadataSearch';
+export { ArrayFieldActions } from './ui/ArrayFieldActions';

package/dist/components/index.js

@@ -1,14 +1,28 @@
-import { DeleteBucketButton } from "./buckets/DeleteBucketButton.js";
+import { useDataBrowserNavigate } from "../hooks/useDataBrowserNavigate.js";
+import { Breadcrumb, DataBrowserBreadcrumb, useBreadcrumbPaths } from "./breadcrumb/index.js";
+import { BucketAccessor } from "./buckets/BucketAccessor.js";
+import { BucketCorsPage } from "./buckets/BucketCorsPage.js";
+import { BucketCreate, baseBucketCreateSchema, bucketErrorMessage, bucketNameValidationSchema } from "./buckets/BucketCreate.js";
+import { BucketLifecycleFormPage } from "./buckets/BucketLifecycleFormPage.js";
 import { BucketList } from "./buckets/BucketList.js";
-import { BucketOverview } from "./buckets/BucketOverview.js";
+import { BucketOverview, BucketOverviewField, BucketOverviewSection, useBucketOverviewContext } from "./buckets/BucketOverview.js";
 import { BucketPage } from "./buckets/BucketPage.js";
 import { BucketPolicyPage } from "./buckets/BucketPolicyPage.js";
-import { BucketNotificationCreatePage } from "./buckets/notifications/BucketNotificationCreatePage.js";
-import { UploadButton } from "./objects/UploadButton.js";
+import { BucketReplicationFormPage } from "./buckets/BucketReplicationFormPage.js";
+import { BucketVersioning } from "./buckets/BucketVersioning.js";
+import { DeleteBucketButton } from "./buckets/DeleteBucketButton.js";
+import { EmptyBucketButton } from "./buckets/EmptyBucketButton.js";
+import { BucketNotificationFormPage } from "./buckets/notifications/BucketNotificationFormPage.js";
+import { DataBrowserUI } from "./DataBrowserUI.js";
 import { CreateFolderButton } from "./objects/CreateFolderButton.js";
 import { ObjectDetails } from "./objects/ObjectDetails/index.js";
 import { ObjectList } from "./objects/ObjectList.js";
+import { EditRetentionButton } from "./objects/ObjectLock/EditRetentionButton.js";
+import { ObjectLockSettings } from "./objects/ObjectLock/ObjectLockSettings.js";
 import { ObjectPage } from "./objects/ObjectPage.js";
+import { UploadButton } from "./objects/UploadButton.js";
+import { DataBrowserProvider, useDataBrowserConfig, useDataBrowserContext, useInvalidateQueries } from "./providers/DataBrowserProvider.js";
+import { QueryProvider } from "./providers/QueryProvider.js";
 import { MetadataSearch } from "./search/MetadataSearch.js";
-import { DataBrowserProvider, useDataBrowserContext, useDataBrowserTheme } from "./providers/DataBrowserProvider.js";
-export { BucketList, BucketNotificationCreatePage, BucketOverview, BucketPage, BucketPolicyPage, CreateFolderButton, DataBrowserProvider, DeleteBucketButton, MetadataSearch, ObjectDetails, ObjectList, ObjectPage, UploadButton, useDataBrowserContext, useDataBrowserTheme };
+import { ArrayFieldActions } from "./ui/ArrayFieldActions.js";
+export { ArrayFieldActions, Breadcrumb, BucketAccessor, BucketCorsPage, BucketCreate, BucketLifecycleFormPage, BucketList, BucketNotificationFormPage, BucketOverview, BucketOverviewField, BucketOverviewSection, BucketPage, BucketPolicyPage, BucketReplicationFormPage, BucketVersioning, CreateFolderButton, DataBrowserBreadcrumb, DataBrowserProvider, DataBrowserUI, DeleteBucketButton, EditRetentionButton, EmptyBucketButton, MetadataSearch, ObjectDetails, ObjectList, ObjectLockSettings, ObjectPage, QueryProvider, UploadButton, baseBucketCreateSchema, bucketErrorMessage, bucketNameValidationSchema, useBreadcrumbPaths, useBucketOverviewContext, useDataBrowserConfig, useDataBrowserContext, useDataBrowserNavigate, useInvalidateQueries };

package/dist/components/layouts/ArrowNavigation.d.ts

@@ -0,0 +1,3 @@
+export default function ArrowNavigation({ path }: {
+    path: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/layouts/ArrowNavigation.js

@@ -0,0 +1,28 @@
+import { jsx } from "react/jsx-runtime";
+import { Icon } from "@scality/core-ui";
+import styled_components from "styled-components";
+import { useDataBrowserNavigate } from "../../hooks/useDataBrowserNavigate.js";
+const IconWrapper = styled_components.div`
+  display: inline-block;
+  cursor: pointer;
+
+  svg {
+    color: ${(props)=>props.theme.textPrimary};
+    transition: color 0.2s ease;
+  }
+
+  &:hover svg {
+    color: ${(props)=>props.theme.textSecondary};
+  }
+`;
+function ArrowNavigation({ path }) {
+    const navigate = useDataBrowserNavigate();
+    return /*#__PURE__*/ jsx(IconWrapper, {
+        onClick: ()=>navigate(path),
+        children: /*#__PURE__*/ jsx(Icon, {
+            name: "Arrow-left",
+            size: '2x'
+        })
+    });
+}
+export { ArrowNavigation as default };

package/dist/components/layouts/BrowserPageLayout.d.ts

@@ -1,9 +1,13 @@
-import React from "react";
+import type { IconName } from '@scality/core-ui/dist/components/icon/Icon.component';
+import type React from 'react';
 export declare const HeadTitle: import("styled-components").StyledComponent<"div", any, {}, never>;
 interface BrowserPageLayoutProps {
     title: React.ReactNode;
     leftPanel: React.ReactNode;
     rightPanel: React.ReactNode;
+    iconName?: IconName;
+    withArrowNavigation?: boolean;
+    arrowNavigationPath?: string;
 }
 export declare const BrowserPageLayout: React.FC<BrowserPageLayoutProps>;
 export {};