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

package/dist/components/breadcrumb/__tests__/useBreadcrumbPaths.test.js

@@ -0,0 +1,134 @@
+import { jsx } from "react/jsx-runtime";
+import { renderHook } from "@testing-library/react";
+import { MemoryRouter } from "react-router";
+import { createTestWrapper } from "../../../test/testUtils.js";
+import { useBreadcrumbPaths } from "../useBreadcrumbPaths.js";
+describe('useBreadcrumbPaths', ()=>{
+    const renderHookWithRouter = (path)=>{
+        const Wrapper = createTestWrapper();
+        return renderHook(()=>useBreadcrumbPaths(), {
+            wrapper: ({ children })=>/*#__PURE__*/ jsx(MemoryRouter, {
+                    initialEntries: [
+                        path
+                    ],
+                    children: /*#__PURE__*/ jsx(Wrapper, {
+                        children: children
+                    })
+                })
+        });
+    };
+    it('returns breadcrumb items for BucketPage routes', ()=>{
+        const root = renderHookWithRouter('/buckets');
+        expect(root.result.current.length).toBeGreaterThan(0);
+        expect(root.result.current[0].label).toContain('amazonaws.com');
+        const detail = renderHookWithRouter('/buckets/my-bucket');
+        expect(detail.result.current.length).toBeGreaterThan(0);
+        expect(detail.result.current[0].label).toContain('amazonaws.com');
+    });
+    it('returns breadcrumb items for ObjectsPage routes', ()=>{
+        const objects = renderHookWithRouter('/buckets/my-bucket/objects');
+        expect(objects.result.current.length).toBeGreaterThan(0);
+        expect(objects.result.current[0].label).toContain('amazonaws.com');
+    });
+    it.each([
+        '/buckets/-/access',
+        '/buckets/-/create',
+        '/buckets/my-bucket/policy',
+        '/buckets/my-bucket/cors',
+        '/buckets/my-bucket/lifecycle/create',
+        '/buckets/my-bucket/lifecycle/edit/rule-123',
+        '/buckets/my-bucket/replication/create',
+        '/buckets/my-bucket/replication/edit/rule-456',
+        '/buckets/my-bucket/notifications/create',
+        '/buckets/my-bucket/notifications/edit/notif-789',
+        '/buckets/my-bucket/objects/object-lock-settings',
+        '/buckets/my-bucket/unknown',
+        '/unknown/route'
+    ])('returns empty array for %s', (path)=>{
+        const { result } = renderHookWithRouter(path);
+        expect(result.current).toEqual([]);
+    });
+    it('generates breadcrumb for root objects view', ()=>{
+        const { result } = renderHookWithRouter('/buckets/my-bucket/objects');
+        expect(result.current.length).toBe(2);
+        expect(result.current[0].path).toBe('/buckets');
+        expect(result.current[1].label).toBe('my-bucket');
+        expect(result.current[1].path).toBeUndefined();
+    });
+    it('generates breadcrumb for folder navigation', ()=>{
+        const { result } = renderHookWithRouter('/buckets/my-bucket/objects?prefix=folder1/');
+        expect(result.current.length).toBe(3);
+        expect(result.current[0].path).toBe('/buckets');
+        expect(result.current[1].label).toBe('my-bucket');
+        expect(result.current[1].path).toBe('/buckets/my-bucket/objects');
+        expect(result.current[2].label).toBe('folder1');
+    });
+    it('generates breadcrumb for nested folders', ()=>{
+        const { result } = renderHookWithRouter('/buckets/my-bucket/objects?prefix=folder1/folder2/');
+        expect(result.current.length).toBe(4);
+        expect(result.current[2].label).toBe('folder1');
+        expect(result.current[3].label).toBe('folder2');
+    });
+    it('generates breadcrumb for file viewing', ()=>{
+        const { result } = renderHookWithRouter('/buckets/my-bucket/objects?prefix=folder/file.txt');
+        expect(result.current.length).toBe(4);
+        expect(result.current[3].label).toBe('file.txt');
+        expect(result.current[3].path).toBeUndefined();
+    });
+    it('handles empty prefix parameter', ()=>{
+        const { result } = renderHookWithRouter('/buckets/my-bucket/objects?prefix=');
+        expect(result.current.length).toBe(2);
+        expect(result.current[1].label).toBe('my-bucket');
+    });
+    it('decodes URL-encoded folder names', ()=>{
+        const { result } = renderHookWithRouter('/buckets/my-bucket/objects?prefix=folder%20with%20spaces/');
+        const folderItem = result.current.find((item)=>'folder with spaces' === item.label);
+        expect(folderItem).toBeDefined();
+    });
+    it('decodes URL-encoded special characters', ()=>{
+        const { result } = renderHookWithRouter('/buckets/my-bucket/objects?prefix=folder%26test/');
+        const folderItem = result.current.find((item)=>'folder&test' === item.label);
+        expect(folderItem).toBeDefined();
+    });
+    it('encodes folder paths in search params for navigation', ()=>{
+        const { result } = renderHookWithRouter('/buckets/my-bucket/objects?prefix=folder1/folder2/');
+        const folder1Item = result.current.find((item)=>'folder1' === item.label);
+        expect(folder1Item?.search).toContain('folder1%2F');
+    });
+    it('handles malformed prefix with only slashes', ()=>{
+        const { result } = renderHookWithRouter('/buckets/my-bucket/objects?prefix=///');
+        expect(result.current.length).toBe(2);
+        expect(result.current[0].path).toBe('/buckets');
+        expect(result.current[1].label).toBe('my-bucket');
+    });
+    it('handles very long folder paths', ()=>{
+        const longPath = Array.from({
+            length: 10
+        }, (_, i)=>`level${i + 1}`).join('/');
+        const { result } = renderHookWithRouter(`/buckets/my-bucket/objects?prefix=${longPath}/`);
+        expect(result.current.length).toBeGreaterThan(10);
+        expect(result.current[0].path).toBe('/buckets');
+    });
+    it('handles bucket names with hyphens and numbers', ()=>{
+        const { result } = renderHookWithRouter('/buckets/my-bucket-123-test/objects');
+        expect(result.current.length).toBe(2);
+        expect(result.current[1].label).toBe('my-bucket-123-test');
+    });
+    it('handles file with multiple dots in name', ()=>{
+        const { result } = renderHookWithRouter('/buckets/my-bucket/objects?prefix=folder/file.backup.tar.gz');
+        const fileItem = result.current.find((item)=>'file.backup.tar.gz' === item.label);
+        expect(fileItem).toBeDefined();
+        expect(fileItem?.path).toBeUndefined();
+    });
+    it('handles malformed route with empty bucket name', ()=>{
+        const { result } = renderHookWithRouter('/buckets//objects');
+        expect(result.current).toEqual([]);
+    });
+    it('handles errors gracefully and returns empty array', ()=>{
+        const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
+        const { result } = renderHookWithRouter('/buckets');
+        expect(result.current).toBeDefined();
+        expect(Array.isArray(result.current)).toBe(true);
+        consoleErrorSpy.mockRestore();
+    });
+});

package/dist/components/breadcrumb/index.d.ts

@@ -0,0 +1,8 @@
+export interface BreadcrumbItem {
+    label: string;
+    path?: string;
+    search?: string;
+}
+export { Breadcrumb } from './Breadcrumb';
+export { DataBrowserBreadcrumb } from './DataBrowserBreadcrumb';
+export { useBreadcrumbPaths } from './useBreadcrumbPaths';

package/dist/components/breadcrumb/index.js

@@ -0,0 +1,4 @@
+import { Breadcrumb } from "./Breadcrumb.js";
+import { DataBrowserBreadcrumb } from "./DataBrowserBreadcrumb.js";
+import { useBreadcrumbPaths } from "./useBreadcrumbPaths.js";
+export { Breadcrumb, DataBrowserBreadcrumb, useBreadcrumbPaths };

package/dist/components/breadcrumb/useBreadcrumbPaths.d.ts

@@ -0,0 +1,2 @@
+import type { BreadcrumbItem } from './index';
+export declare const useBreadcrumbPaths: () => BreadcrumbItem[];

package/dist/components/breadcrumb/useBreadcrumbPaths.js

@@ -0,0 +1,82 @@
+import { matchPath, useLocation, useSearchParams } from "react-router";
+import { useDataBrowserConfig } from "../providers/DataBrowserProvider.js";
+const ROUTE_PATTERNS = {
+    BUCKET_OBJECTS: '/buckets/:bucketName/objects',
+    BUCKET_DETAIL: '/buckets/:bucketName',
+    BUCKET_ROOT: '/buckets',
+    BUCKET_SETTINGS: '/buckets/:bucketName/*'
+};
+const formatEndpointLabel = (endpoint)=>{
+    if (!endpoint) return 'Data Browser';
+    try {
+        const url = new URL(endpoint);
+        return url.hostname;
+    } catch  {
+        return endpoint.replace(/^https?:\/\//, '').replace(/\/$/, '');
+    }
+};
+const useBreadcrumbPaths = ()=>{
+    const [searchParams] = useSearchParams();
+    const location = useLocation();
+    const config = useDataBrowserConfig();
+    const endpointLabel = formatEndpointLabel(config.endpoint);
+    try {
+        const objectsMatch = matchPath(ROUTE_PATTERNS.BUCKET_OBJECTS, location.pathname);
+        const bucketListMatch = matchPath(ROUTE_PATTERNS.BUCKET_DETAIL, location.pathname);
+        const bucketRootMatch = matchPath(ROUTE_PATTERNS.BUCKET_ROOT, location.pathname);
+        if (objectsMatch?.params.bucketName) {
+            const bucketName = objectsMatch.params.bucketName;
+            const prefix = searchParams.get('prefix') || '';
+            const breadcrumbs = [
+                {
+                    label: endpointLabel,
+                    path: '/buckets'
+                }
+            ];
+            if (prefix) {
+                breadcrumbs.push({
+                    label: bucketName,
+                    path: `/buckets/${bucketName}/objects`
+                });
+                const segments = prefix.split('/').filter(Boolean);
+                const isFile = !prefix.endsWith('/');
+                segments.forEach((segment, index)=>{
+                    const isLast = index === segments.length - 1;
+                    if (isFile && isLast) breadcrumbs.push({
+                        label: segment
+                    });
+                    else {
+                        const currentPath = segments.slice(0, index + 1).join('/');
+                        breadcrumbs.push({
+                            label: segment,
+                            ...isLast ? {} : {
+                                path: `/buckets/${bucketName}/objects`,
+                                search: `?prefix=${encodeURIComponent(`${currentPath}/`)}`
+                            }
+                        });
+                    }
+                });
+            } else breadcrumbs.push({
+                label: bucketName
+            });
+            return breadcrumbs;
+        }
+        if (bucketListMatch && !location.pathname.includes('/objects') && !location.pathname.includes('/-/')) return [
+            {
+                label: endpointLabel,
+                path: '/buckets'
+            }
+        ];
+        if (bucketRootMatch) return [
+            {
+                label: endpointLabel,
+                path: '/buckets'
+            }
+        ];
+        return [];
+    } catch (error) {
+        console.error('Error generating breadcrumb paths:', error);
+        return [];
+    }
+};
+export { useBreadcrumbPaths };

package/dist/components/buckets/BucketAccessor.d.ts

@@ -0,0 +1,2 @@
+export declare const BucketAccessor: () => import("react/jsx-runtime").JSX.Element;
+export default BucketAccessor;

package/dist/components/buckets/BucketAccessor.js

@@ -0,0 +1,125 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { joiResolver } from "@hookform/resolvers/joi";
+import { Form, FormGroup, FormSection, Stack, useToast } from "@scality/core-ui";
+import { Button, Input } from "@scality/core-ui/dist/next";
+import { convertRemToPixels } from "@scality/core-ui/dist/utils";
+import joi from "joi";
+import { FormProvider, useForm } from "react-hook-form";
+import { useAccessibleBuckets, useValidateBucketAccess } from "../../hooks/index.js";
+import { useDataBrowserNavigate } from "../../hooks/useDataBrowserNavigate.js";
+const bucketAccessSchema = joi.object({
+    bucketName: joi.string().required().label('Bucket Name').messages({
+        'string.empty': 'Bucket name is required'
+    }),
+    prefix: joi.string().allow('').optional().label('Prefix')
+});
+const BucketAccessor = ()=>{
+    const navigate = useDataBrowserNavigate();
+    const { showToast } = useToast();
+    const { addAccessibleBucket } = useAccessibleBuckets();
+    const useFormMethods = useForm({
+        mode: 'all',
+        resolver: joiResolver(bucketAccessSchema),
+        defaultValues: {
+            bucketName: '',
+            prefix: ''
+        }
+    });
+    const { register, handleSubmit, formState, watch } = useFormMethods;
+    const { isValid, errors } = formState;
+    const bucketName = watch('bucketName');
+    const prefix = watch('prefix');
+    const { refetch, isFetching } = useValidateBucketAccess({
+        Bucket: bucketName,
+        Prefix: prefix ? `${prefix}/` : '',
+        MaxKeys: 1,
+        Delimiter: '/'
+    }, {
+        enabled: false
+    });
+    const handleCancel = ()=>{
+        navigate('/buckets');
+    };
+    const onSubmit = async (data)=>{
+        const { isSuccess, error } = await refetch();
+        if (isSuccess) {
+            addAccessibleBucket(data.bucketName);
+            const targetPath = data.prefix ? `/buckets/${data.bucketName}/objects?prefix=${encodeURIComponent(data.prefix + '/')}` : `/buckets/${data.bucketName}/objects`;
+            navigate(targetPath);
+        } else if (error) {
+            let errorMessage = 'Failed to access bucket';
+            if (error instanceof Error) {
+                const errorName = error.name || '';
+                const errorMsg = error.message || '';
+                errorMessage = 'NoSuchBucket' === errorName || errorMsg.includes('NoSuchBucket') ? 'The specified bucket does not exist' : 'AccessDenied' === errorName || errorMsg.includes('AccessDenied') ? "You don't have permission to access this bucket" : errorMsg || errorMessage;
+            }
+            showToast({
+                open: true,
+                message: errorMessage,
+                status: 'error'
+            });
+        }
+    };
+    return /*#__PURE__*/ jsx(FormProvider, {
+        ...useFormMethods,
+        children: /*#__PURE__*/ jsx(Form, {
+            layout: {
+                kind: 'page',
+                title: 'Access a specific S3 Bucket'
+            },
+            requireMode: "all",
+            onSubmit: handleSubmit(onSubmit),
+            rightActions: /*#__PURE__*/ jsxs(Stack, {
+                gap: "r16",
+                children: [
+                    /*#__PURE__*/ jsx(Button, {
+                        id: "cancel-btn",
+                        variant: "outline",
+                        onClick: handleCancel,
+                        type: "button",
+                        label: "Cancel"
+                    }),
+                    /*#__PURE__*/ jsx(Button, {
+                        disabled: !isValid || isFetching,
+                        isLoading: isFetching,
+                        id: "access-bucket-btn",
+                        type: "submit",
+                        variant: "primary",
+                        label: "Access"
+                    })
+                ]
+            }),
+            children: /*#__PURE__*/ jsxs(FormSection, {
+                forceLabelWidth: convertRemToPixels(17.5),
+                children: [
+                    /*#__PURE__*/ jsx(FormGroup, {
+                        id: "bucketName",
+                        label: "Bucket Name",
+                        required: true,
+                        direction: "horizontal",
+                        content: /*#__PURE__*/ jsx(Input, {
+                            id: "bucketName",
+                            autoFocus: true,
+                            ...register('bucketName')
+                        }),
+                        helpErrorPosition: "bottom",
+                        error: errors.bucketName?.message
+                    }),
+                    /*#__PURE__*/ jsx(FormGroup, {
+                        id: "prefix",
+                        label: "Prefix",
+                        direction: "horizontal",
+                        content: /*#__PURE__*/ jsx(Input, {
+                            id: "prefix",
+                            ...register('prefix')
+                        }),
+                        helpErrorPosition: "bottom",
+                        error: errors.prefix?.message
+                    })
+                ]
+            })
+        })
+    });
+};
+const buckets_BucketAccessor = BucketAccessor;
+export { BucketAccessor, buckets_BucketAccessor as default };

package/dist/components/buckets/BucketConfigEditButton.d.ts

@@ -0,0 +1,8 @@
+interface BucketConfigEditButtonProps {
+    hasConfig: boolean;
+    isLoading?: boolean;
+    onEdit: () => void;
+    configName: string;
+}
+export declare const BucketConfigEditButton: React.FC<BucketConfigEditButtonProps>;
+export {};

package/dist/components/buckets/{BucketPolicyButton.js → BucketConfigEditButton.js}

@@ -1,18 +1,22 @@
 import { jsx } from "react/jsx-runtime";
 import { Icon, spacing } from "@scality/core-ui";
 import { Box, Button } from "@scality/core-ui/dist/next";
-const BucketPolicyButton = ({ hasPolicy, isLoading, onEdit })=>/*#__PURE__*/ jsx(Box, {
+const BucketConfigEditButton = ({ hasConfig, isLoading, onEdit, configName })=>{
+    const action = hasConfig ? 'Edit' : 'Create';
+    return /*#__PURE__*/ jsx(Box, {
         display: "flex",
         alignItems: "center",
         gap: spacing.r8,
         children: /*#__PURE__*/ jsx(Button, {
             isLoading: isLoading,
             variant: "outline",
-            label: hasPolicy ? "Edit" : "Create",
+            label: action,
             icon: /*#__PURE__*/ jsx(Icon, {
-                name: hasPolicy ? "Pen" : "Create-add"
+                name: hasConfig ? 'Pen' : 'Create-add'
             }),
-            onClick: onEdit
+            onClick: onEdit,
+            "aria-label": `${action} ${configName}`
         })
     });
-export { BucketPolicyButton };
+};
+export { BucketConfigEditButton };

package/dist/components/buckets/BucketCorsPage.d.ts

@@ -0,0 +1 @@
+export declare const BucketCorsPage: React.FC;

package/dist/components/buckets/BucketCorsPage.js

@@ -0,0 +1,234 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { Form, FormGroup, FormSection, Icon, Loader, Stack, Text, useToast } from "@scality/core-ui";
+import { Box, Button, CopyButton } from "@scality/core-ui/dist/next";
+import { useCallback, useMemo } from "react";
+import { Controller } from "react-hook-form";
+import { useParams } from "react-router";
+import { useBucketConfigEditor, useDeleteBucketCors, useGetBucketCors, useSetBucketCors } from "../../hooks/index.js";
+import { Editor } from "../Editor.js";
+const DEFAULT_CORS_TEMPLATE = `[
+  {
+    "AllowedHeaders": [
+      "Authorization"
+    ],
+    "AllowedMethods": [
+      "GET"
+    ],
+    "AllowedOrigins": [
+      "*"
+    ],
+    "ExposeHeaders": [],
+    "MaxAgeSeconds": 3000
+  }
+]`;
+const validateCorsConfig = (content)=>{
+    const trimmed = content.trim();
+    if ('' === trimmed) return {
+        isValid: true,
+        parsed: []
+    };
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (!Array.isArray(parsed)) return {
+            isValid: false,
+            error: 'CORS configuration must be an array of rules'
+        };
+        return {
+            isValid: true,
+            parsed
+        };
+    } catch  {
+        return {
+            isValid: false,
+            error: 'Invalid JSON format'
+        };
+    }
+};
+const BucketCorsPage = ()=>{
+    const { bucketName } = useParams();
+    const { showToast } = useToast();
+    const { data: corsData, status: corsStatus, error: corsError } = useGetBucketCors({
+        Bucket: bucketName
+    });
+    const initialContent = useMemo(()=>{
+        if (corsData?.CORSRules && corsData.CORSRules.length > 0) return JSON.stringify(corsData.CORSRules);
+    }, [
+        corsData
+    ]);
+    const { form, content, isCreateMode, isValidFormat, handleBeforeMount, navigateToBucket } = useBucketConfigEditor({
+        bucketName: bucketName,
+        initialContent,
+        defaultTemplate: DEFAULT_CORS_TEMPLATE,
+        isLoading: 'pending' === corsStatus,
+        notFoundErrorNames: [
+            'NoSuchCORSConfiguration'
+        ],
+        errorInstance: corsError,
+        validate: validateCorsConfig
+    });
+    const { control, handleSubmit, setError, clearErrors, formState: { isDirty, errors } } = form;
+    const { mutate: saveCors, isPending: isSaving } = useSetBucketCors();
+    const { mutate: deleteCors, isPending: isDeleting } = useDeleteBucketCors();
+    const onSubmit = useCallback((data)=>{
+        const result = validateCorsConfig(data.content);
+        if (!result.isValid) return;
+        const parsedRules = result.parsed;
+        if (0 === parsedRules.length) return void deleteCors({
+            Bucket: bucketName
+        }, {
+            onSuccess: ()=>{
+                showToast({
+                    open: true,
+                    message: 'CORS configuration deleted',
+                    status: 'success'
+                });
+                navigateToBucket();
+            },
+            onError: (error)=>{
+                setError('content', {
+                    type: 'server',
+                    message: error instanceof Error ? error.message : 'Failed to delete'
+                });
+            }
+        });
+        saveCors({
+            Bucket: bucketName,
+            CORSConfiguration: {
+                CORSRules: parsedRules
+            }
+        }, {
+            onSuccess: ()=>{
+                showToast({
+                    open: true,
+                    message: 'CORS configuration saved',
+                    status: 'success'
+                });
+                navigateToBucket();
+            },
+            onError: (error)=>{
+                setError('content', {
+                    type: 'server',
+                    message: error instanceof Error ? error.message : 'Failed to save'
+                });
+            }
+        });
+    }, [
+        bucketName,
+        saveCors,
+        deleteCors,
+        navigateToBucket,
+        showToast,
+        setError
+    ]);
+    const isPending = isSaving || isDeleting;
+    const hasUnexpectedError = corsError && 'NoSuchCORSConfiguration' !== corsError.name;
+    if ('pending' === corsStatus) return /*#__PURE__*/ jsx(Loader, {
+        centered: true,
+        size: "massive",
+        children: /*#__PURE__*/ jsx(Fragment, {
+            children: "Loading CORS configuration..."
+        })
+    });
+    if (hasUnexpectedError) return /*#__PURE__*/ jsx(Box, {
+        display: "flex",
+        flexDirection: "column",
+        justifyContent: "center",
+        alignItems: "center",
+        height: "100%",
+        gap: "1.5rem",
+        children: /*#__PURE__*/ jsxs(Stack, {
+            gap: "r8",
+            style: {
+                alignItems: 'center'
+            },
+            children: [
+                /*#__PURE__*/ jsx(Icon, {
+                    name: "Exclamation-circle",
+                    size: "2x",
+                    color: "statusWarning"
+                }),
+                /*#__PURE__*/ jsxs(Text, {
+                    variant: "Large",
+                    children: [
+                        "Failed to load CORS configuration: ",
+                        corsError.message || 'Unknown error'
+                    ]
+                })
+            ]
+        })
+    });
+    return /*#__PURE__*/ jsx(Form, {
+        onSubmit: handleSubmit(onSubmit),
+        layout: {
+            kind: 'page',
+            title: `${isCreateMode ? 'Create' : 'Edit'} Bucket CORS`
+        },
+        rightActions: /*#__PURE__*/ jsxs(Stack, {
+            gap: "r16",
+            children: [
+                /*#__PURE__*/ jsx(Button, {
+                    variant: "outline",
+                    label: "Cancel",
+                    onClick: navigateToBucket,
+                    type: "button",
+                    disabled: isPending
+                }),
+                /*#__PURE__*/ jsx(Button, {
+                    variant: "primary",
+                    label: "Save",
+                    icon: /*#__PURE__*/ jsx(Icon, {
+                        name: "Save"
+                    }),
+                    type: "submit",
+                    disabled: !isDirty && !isCreateMode || isPending || !isValidFormat
+                })
+            ]
+        }),
+        children: /*#__PURE__*/ jsxs(FormSection, {
+            children: [
+                /*#__PURE__*/ jsx(FormGroup, {
+                    id: "bucketName",
+                    label: "Bucket Name",
+                    direction: "horizontal",
+                    content: /*#__PURE__*/ jsx(Text, {
+                        children: bucketName
+                    })
+                }),
+                /*#__PURE__*/ jsx(FormGroup, {
+                    id: "corsConfiguration",
+                    label: "CORS Rules",
+                    direction: "vertical",
+                    error: errors.content?.message,
+                    content: /*#__PURE__*/ jsxs(Stack, {
+                        children: [
+                            /*#__PURE__*/ jsx(Controller, {
+                                control: control,
+                                name: "content",
+                                render: ({ field: { onChange, value } })=>/*#__PURE__*/ jsx(Editor, {
+                                        value: value,
+                                        onChange: (newValue)=>{
+                                            onChange(newValue);
+                                            if (errors.content) clearErrors('content');
+                                        },
+                                        language: "json",
+                                        height: "60vh",
+                                        width: "33rem",
+                                        beforeMount: handleBeforeMount
+                                    })
+                            }),
+                            /*#__PURE__*/ jsx(Box, {
+                                alignSelf: "baseline",
+                                children: /*#__PURE__*/ jsx(CopyButton, {
+                                    textToCopy: content,
+                                    label: "CORS",
+                                    variant: "outline"
+                                })
+                            })
+                        ]
+                    })
+                })
+            ]
+        })
+    });
+};
+export { BucketCorsPage };

package/dist/components/buckets/BucketCreate.d.ts

@@ -1,11 +1,12 @@
-import Joi from "joi";
-import { ObjectLockRetentionMode } from "@aws-sdk/client-s3";
+import type { ObjectLockRetentionMode } from '@aws-sdk/client-s3';
+import Joi from 'joi';
 export declare const bucketErrorMessage = "Bucket names can include only lowercase letters, numbers, dots (.), and hyphens (-)";
 export declare const bucketNameValidationSchema: Joi.StringSchema<string>;
 export declare const baseBucketCreateSchema: Joi.ObjectSchema<any>;
 export type BucketCreateFormData = {
     name: string;
     isVersioning: boolean;
+    isEncryptionEnabled: boolean;
     isObjectLockEnabled: boolean;
     isDefaultRetentionEnabled: boolean;
     retentionMode: ObjectLockRetentionMode;