@scality/data-browser-library 1.0.0-preview.13 → 1.0.0-preview.16

package/dist/components/buckets/__tests__/BucketVersioning.test.js

@@ -5,13 +5,13 @@ import { createMockMutationResult, createTestWrapper, findToggleByLabel } from "
 import { BucketVersioning } from "../BucketVersioning.js";
 import { BucketOverviewContext } from "../BucketOverview.js";
 const mockShowToast = jest.fn();
-jest.mock("@scality/core-ui", ()=>({
-        ...jest.requireActual("@scality/core-ui"),
+jest.mock('@scality/core-ui', ()=>({
+        ...jest.requireActual('@scality/core-ui'),
         useToast: ()=>({
                 showToast: mockShowToast
             })
     }));
-jest.mock("../../../hooks");
+jest.mock('../../../hooks');
 const mockUseGetBucketVersioning = jest.mocked(useGetBucketVersioning);
 const mockUseGetBucketObjectLockConfiguration = jest.mocked(useGetBucketObjectLockConfiguration);
 const mockUseISVBucketStatus = jest.mocked(useISVBucketStatus);
@@ -24,7 +24,7 @@ const renderBucketVersioning = (props = {})=>{
         ...render(/*#__PURE__*/ jsx(Wrapper, {
             children: /*#__PURE__*/ jsx(BucketOverviewContext.Provider, {
                 value: {
-                    bucketName: "test-bucket"
+                    bucketName: 'test-bucket'
                 },
                 children: /*#__PURE__*/ jsx(BucketVersioning, {
                     ...props
@@ -37,18 +37,18 @@ const renderBucketVersioning = (props = {})=>{
 const mockHookDefaults = ()=>{
     mockUseGetBucketVersioning.mockReturnValue({
         data: {
-            Status: "Enabled"
+            Status: 'Enabled'
         },
-        status: "success",
+        status: 'success',
         error: null
     });
     mockUseGetBucketObjectLockConfiguration.mockReturnValue({
         data: {
             ObjectLockConfiguration: {
-                ObjectLockEnabled: "Disabled"
+                ObjectLockEnabled: 'Disabled'
             }
         },
-        status: "success",
+        status: 'success',
         error: null
     });
     mockUseISVBucketStatus.mockReturnValue({
@@ -57,107 +57,107 @@ const mockHookDefaults = ()=>{
         isISVManaged: false,
         isvApplication: void 0,
         isLoading: false,
-        bucketTagsStatus: "success"
+        bucketTagsStatus: 'success'
     });
 };
-describe("BucketVersioning", ()=>{
+describe('BucketVersioning', ()=>{
     beforeEach(()=>{
         jest.clearAllMocks();
         mockHookDefaults();
     });
-    it("renders toggle with Active label when versioning is enabled", ()=>{
+    it('renders toggle with Active label when versioning is enabled', ()=>{
         renderBucketVersioning();
-        const toggle = findToggleByLabel("Active");
+        const toggle = findToggleByLabel('Active');
         expect(toggle).toBeInTheDocument();
         expect(toggle).toBeChecked();
     });
-    it("renders toggle with Inactive label when versioning is suspended", ()=>{
+    it('renders toggle with Inactive label when versioning is suspended', ()=>{
         mockUseGetBucketVersioning.mockReturnValue({
             data: {
-                Status: "Suspended"
+                Status: 'Suspended'
             },
-            status: "success",
+            status: 'success',
             error: null
         });
         renderBucketVersioning();
-        const toggle = findToggleByLabel("Inactive");
+        const toggle = findToggleByLabel('Inactive');
         expect(toggle).toBeInTheDocument();
         expect(toggle).not.toBeChecked();
     });
-    it("calls mutation with Suspended status when disabling versioning", ()=>{
+    it('calls mutation with Suspended status when disabling versioning', ()=>{
         const { mutate } = renderBucketVersioning();
-        const toggle = findToggleByLabel("Active");
+        const toggle = findToggleByLabel('Active');
         fireEvent.click(toggle);
         expect(mutate).toHaveBeenCalledWith({
-            Bucket: "test-bucket",
+            Bucket: 'test-bucket',
             VersioningConfiguration: {
-                Status: "Suspended"
+                Status: 'Suspended'
             }
         }, expect.any(Object));
     });
-    it("calls mutation with Enabled status when enabling versioning", ()=>{
+    it('calls mutation with Enabled status when enabling versioning', ()=>{
         mockUseGetBucketVersioning.mockReturnValue({
             data: {
-                Status: "Suspended"
+                Status: 'Suspended'
             },
-            status: "success",
+            status: 'success',
             error: null
         });
         const { mutate } = renderBucketVersioning();
-        const toggle = findToggleByLabel("Inactive");
+        const toggle = findToggleByLabel('Inactive');
         fireEvent.click(toggle);
         expect(mutate).toHaveBeenCalledWith({
-            Bucket: "test-bucket",
+            Bucket: 'test-bucket',
             VersioningConfiguration: {
-                Status: "Enabled"
+                Status: 'Enabled'
             }
         }, expect.any(Object));
     });
-    it("disables toggle when versioning data is loading", ()=>{
+    it('disables toggle when versioning data is loading', ()=>{
         mockUseGetBucketVersioning.mockReturnValue({
             data: void 0,
-            status: "pending",
+            status: 'pending',
             error: null
         });
         renderBucketVersioning();
-        const toggle = screen.getByRole("checkbox");
-        expect(toggle).toHaveAttribute("aria-disabled", "true");
+        const toggle = screen.getByRole('checkbox');
+        expect(toggle).toHaveAttribute('aria-disabled', 'true');
     });
-    it("renders static Enabled text when Object Lock is enabled", ()=>{
+    it('renders static Enabled text when Object Lock is enabled', ()=>{
         mockUseGetBucketObjectLockConfiguration.mockReturnValue({
             data: {
                 ObjectLockConfiguration: {
-                    ObjectLockEnabled: "Enabled"
+                    ObjectLockEnabled: 'Enabled'
                 }
             },
-            status: "success"
+            status: 'success'
         });
         renderBucketVersioning();
-        expect(screen.getByText("Enabled")).toBeInTheDocument();
+        expect(screen.getByText('Enabled')).toBeInTheDocument();
         expect(screen.getByText(/Versioning cannot be suspended because Object-lock is enabled/i)).toBeInTheDocument();
-        expect(screen.queryByRole("checkbox")).not.toBeInTheDocument();
+        expect(screen.queryByRole('checkbox')).not.toBeInTheDocument();
     });
-    it("disables toggle when bucket is managed by Veeam", ()=>{
+    it('disables toggle when bucket is managed by Veeam', ()=>{
         mockUseISVBucketStatus.mockReturnValue({
             isVeeamBucket: true,
             isCommvaultBucket: false,
             isISVManaged: true,
-            isvApplication: "Veeam",
+            isvApplication: 'Veeam',
             isLoading: false,
-            bucketTagsStatus: "success"
+            bucketTagsStatus: 'success'
         });
         renderBucketVersioning();
-        const toggle = screen.getByRole("checkbox");
-        expect(toggle).toHaveAttribute("aria-disabled", "true");
+        const toggle = screen.getByRole('checkbox');
+        expect(toggle).toHaveAttribute('aria-disabled', 'true');
     });
-    it("disables toggle when versioning query errors", ()=>{
+    it('disables toggle when versioning query errors', ()=>{
         mockUseGetBucketVersioning.mockReturnValue({
             data: void 0,
-            status: "error",
-            error: new Error("Failed to fetch versioning")
+            status: 'error',
+            error: new Error('Failed to fetch versioning')
         });
         renderBucketVersioning();
-        const toggle = screen.getByRole("checkbox");
-        expect(toggle).toHaveAttribute("aria-disabled", "true");
+        const toggle = screen.getByRole('checkbox');
+        expect(toggle).toHaveAttribute('aria-disabled', 'true');
     });
 });

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

@@ -6,26 +6,27 @@ import { Button, Input } from "@scality/core-ui/dist/next";
 import joi from "joi";
 import { useCallback } from "react";
 import { FormProvider, useForm } from "react-hook-form";
-import { useNavigate, useParams } from "react-router-dom";
+import { useParams } from "react-router";
 import { useGetBucketNotification, useSetBucketNotification } from "../../../hooks/index.js";
+import { useDataBrowserNavigate } from "../../../hooks/useDataBrowserNavigate.js";
 import { EventsSection } from "./EventsSection.js";
 const schema = joi.object({
     ruleName: joi.string().required().messages({
-        "string.empty": "This field is required"
+        'string.empty': 'This field is required'
     }),
     queueArn: joi.string().required().pattern(/^arn:aws:sqs:[a-z0-9-]+:\d+:.+$/).messages({
-        "string.empty": "This field is required",
-        "string.pattern.base": "Must be a valid ARN (e.g., arn:aws:sqs:region:account-id:queue-name)"
+        'string.empty': 'This field is required',
+        'string.pattern.base': 'Must be a valid ARN (e.g., arn:aws:sqs:region:account-id:queue-name)'
     }),
     events: joi.array().min(1).required().messages({
-        "array.min": "At least one event must be selected"
+        'array.min': 'At least one event must be selected'
     }),
-    prefix: joi.string().allow("").optional(),
-    suffix: joi.string().allow("").optional()
+    prefix: joi.string().allow('').optional(),
+    suffix: joi.string().allow('').optional()
 });
 function BucketNotificationCreatePage() {
     const { bucketName } = useParams();
-    const navigate = useNavigate();
+    const navigate = useDataBrowserNavigate();
     const { showToast } = useToast();
     const { data: existingNotificationData, status: notificationStatus } = useGetBucketNotification({
         Bucket: bucketName
@@ -33,19 +34,19 @@ function BucketNotificationCreatePage() {
     const existingRuleNames = existingNotificationData?.QueueConfigurations?.map((config)=>config.Id) || [];
     const dynamicSchema = schema.keys({
         ruleName: joi.string().required().invalid(...existingRuleNames).messages({
-            "string.empty": "This field is required",
-            "any.invalid": "A rule with this name already exists"
+            'string.empty': 'This field is required',
+            'any.invalid': 'A rule with this name already exists'
         })
     });
     const methods = useForm({
         resolver: joiResolver(dynamicSchema),
-        mode: "onChange",
+        mode: 'onChange',
         defaultValues: {
-            ruleName: "",
-            queueArn: "",
+            ruleName: '',
+            queueArn: '',
             events: [],
-            prefix: "",
-            suffix: ""
+            prefix: '',
+            suffix: ''
         }
     });
     const { mutate: setNotification, isPending: isSaving } = useSetBucketNotification();
@@ -61,22 +62,22 @@ function BucketNotificationCreatePage() {
         const filterRules = [
             ...data.prefix ? [
                 {
-                    Name: "prefix",
+                    Name: 'prefix',
                     Value: data.prefix
                 }
             ] : [],
             ...data.suffix ? [
                 {
-                    Name: "suffix",
+                    Name: 'suffix',
                     Value: data.suffix
                 }
             ] : []
         ];
         const filteredEvents = data.events.filter((event)=>{
-            if (event.endsWith("*")) return true;
-            if (event.startsWith("s3:ObjectCreated:")) return !data.events.includes("s3:ObjectCreated:*");
-            if (event.startsWith("s3:ObjectRemoved:")) return !data.events.includes("s3:ObjectRemoved:*");
-            if (event.startsWith("s3:LifecycleExpiration:")) return !data.events.includes("s3:LifecycleExpiration:*");
+            if (event.endsWith('*')) return true;
+            if (event.startsWith('s3:ObjectCreated:')) return !data.events.includes('s3:ObjectCreated:*');
+            if (event.startsWith('s3:ObjectRemoved:')) return !data.events.includes('s3:ObjectRemoved:*');
+            if (event.startsWith('s3:LifecycleExpiration:')) return !data.events.includes('s3:LifecycleExpiration:*');
             return true;
         });
         const newQueueConfiguration = {
@@ -103,17 +104,17 @@ function BucketNotificationCreatePage() {
             onSuccess: ()=>{
                 showToast({
                     open: true,
-                    message: "Notification created successfully",
-                    status: "success"
+                    message: 'Notification created successfully',
+                    status: 'success'
                 });
                 navigate(`/buckets/${bucketName}`);
             },
             onError: (error)=>{
-                const errorMessage = error instanceof Error ? error.message : "Failed to create notification";
+                const errorMessage = error instanceof Error ? error.message : 'Failed to create notification';
                 showToast({
                     open: true,
                     message: errorMessage,
-                    status: "error"
+                    status: 'error'
                 });
             }
         });
@@ -124,7 +125,7 @@ function BucketNotificationCreatePage() {
         showToast,
         existingNotificationData
     ]);
-    if ("pending" === notificationStatus) return /*#__PURE__*/ jsx(Loader, {
+    if ('pending' === notificationStatus) return /*#__PURE__*/ jsx(Loader, {
         centered: true,
         children: /*#__PURE__*/ jsx(Text, {
             children: "Loading..."
@@ -134,8 +135,8 @@ function BucketNotificationCreatePage() {
         ...methods,
         children: /*#__PURE__*/ jsxs(Form, {
             layout: {
-                kind: "page",
-                title: "Create Bucket Notification"
+                kind: 'page',
+                title: 'Create Bucket Notification'
             },
             requireMode: "partial",
             onSubmit: handleSubmit(onSubmit),
@@ -172,7 +173,7 @@ function BucketNotificationCreatePage() {
                         required: true,
                         content: /*#__PURE__*/ jsx(Input, {
                             id: "ruleName",
-                            ...register("ruleName")
+                            ...register('ruleName')
                         })
                     })
                 }),
@@ -190,13 +191,13 @@ function BucketNotificationCreatePage() {
                         content: /*#__PURE__*/ jsx(Input, {
                             id: "queueArn",
                             placeholder: "arn:aws:sqs:us-east-1:1xx:name",
-                            ...register("queueArn")
+                            ...register('queueArn')
                         })
                     })
                 }),
                 /*#__PURE__*/ jsx(FormSection, {
                     title: {
-                        name: "Filters"
+                        name: 'Filters'
                     },
                     children: /*#__PURE__*/ jsxs(Stack, {
                         direction: "horizontal",
@@ -210,7 +211,7 @@ function BucketNotificationCreatePage() {
                                     id: "prefix",
                                     placeholder: "",
                                     size: "2/3",
-                                    ...register("prefix")
+                                    ...register('prefix')
                                 })
                             }),
                             /*#__PURE__*/ jsx(FormGroup, {
@@ -221,7 +222,7 @@ function BucketNotificationCreatePage() {
                                     id: "suffix",
                                     placeholder: "",
                                     size: "2/3",
-                                    ...register("suffix")
+                                    ...register('suffix')
                                 })
                             })
                         ]

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 { useCallback, useMemo } from "react";
 import { Controller, useFormContext } from "react-hook-form";
-import { objectCreationEvents, objectDeletionEvents, othersEvents } from "./events.js";
+import { getFilteredEventGroups } from "./events.js";
 import { Box } from "@scality/core-ui/dist/next";
+import { useSupportedNotificationEvents } from "../../../hooks/useSupportedNotificationEvents.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 {};