@scality/data-browser-library 1.0.0-preview.11

package/dist/components/buckets/BucketOverview.js

@@ -0,0 +1,291 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { ConstrainedText, Icon, Loader, spacing } from "@scality/core-ui";
+import { Box, Button } from "@scality/core-ui/dist/next";
+import { createContext, useContext } from "react";
+import { useGetBucketAcl, useGetBucketCors, useGetBucketObjectLockConfiguration, useGetBucketPolicy, useGetBucketVersioning } from "../../hooks/index.js";
+import { useDataBrowserContext } from "../providers/DataBrowserProvider.js";
+import { isNotFoundError } from "../../utils/errorHandling.js";
+import { Body, Group, GroupContent, GroupName, GroupValues, Key, Row, Table, TableContainer, Value } from "../ui/Table.elements.js";
+import { BucketLocation } from "./BucketLocation.js";
+import { BucketPolicyButton } from "./BucketPolicyButton.js";
+import { EditRetentionButton } from "../objects/ObjectLock/EditRetentionButton.js";
+const BucketOverviewContext = /*#__PURE__*/ createContext(null);
+function useBucketOverviewContext() {
+    const context = useContext(BucketOverviewContext);
+    if (!context) throw new Error("BucketOverview components must be used within BucketOverview");
+    return context;
+}
+function getDefaultBucketRetention(objectLockData) {
+    if (!objectLockData?.ObjectLockConfiguration?.Rule?.DefaultRetention || !objectLockData.ObjectLockConfiguration.Rule.DefaultRetention.Days && !objectLockData.ObjectLockConfiguration.Rule.DefaultRetention.Years) return "Inactive";
+    const defaultRetention = objectLockData.ObjectLockConfiguration.Rule.DefaultRetention;
+    const retentionPeriod = defaultRetention.Days ? `${defaultRetention.Days} ${1 === defaultRetention.Days ? "day" : "days"}` : defaultRetention.Years ? `${defaultRetention.Years} ${1 === defaultRetention.Years ? "year" : "years"}` : "";
+    const mode = defaultRetention.Mode || "GOVERNANCE";
+    const capitalizedMode = mode.charAt(0).toUpperCase() + mode.slice(1).toLowerCase();
+    return `${capitalizedMode} - ${retentionPeriod}`;
+}
+const BucketOverviewRoot = ({ bucketName, children })=>/*#__PURE__*/ jsx(BucketOverviewContext.Provider, {
+        value: {
+            bucketName
+        },
+        children: /*#__PURE__*/ jsx(TableContainer, {
+            children: children
+        })
+    });
+const Actions = ({ onEmptyBucket, onDeleteBucket, renderEmptyButton, renderDeleteButton, isEmptyBucketDisabled = true, isDeleteBucketDisabled = false })=>{
+    const { bucketName } = useBucketOverviewContext();
+    return /*#__PURE__*/ jsxs(Box, {
+        display: "flex",
+        justifyContent: "flex-end",
+        paddingBottom: spacing.r16,
+        children: [
+            renderEmptyButton ? renderEmptyButton(bucketName) : /*#__PURE__*/ jsx(Button, {
+                icon: /*#__PURE__*/ jsx(Icon, {
+                    name: "Eraser"
+                }),
+                disabled: isEmptyBucketDisabled,
+                variant: "danger",
+                label: "Empty Bucket",
+                onClick: onEmptyBucket,
+                style: {
+                    marginRight: "1rem"
+                }
+            }),
+            renderDeleteButton ? renderDeleteButton(bucketName) : /*#__PURE__*/ jsx(Button, {
+                icon: /*#__PURE__*/ jsx(Icon, {
+                    name: "Delete"
+                }),
+                disabled: isDeleteBucketDisabled,
+                variant: "danger",
+                label: "Delete Bucket",
+                onClick: onDeleteBucket
+            })
+        ]
+    });
+};
+const Section = ({ title, children })=>/*#__PURE__*/ jsxs(Group, {
+        children: [
+            /*#__PURE__*/ jsx(GroupName, {
+                children: title
+            }),
+            /*#__PURE__*/ jsx(GroupContent, {
+                children: children
+            })
+        ]
+    });
+const Field = ({ label, value, loading, error, errorMessage = "Error", children, actions })=>{
+    const renderValue = ()=>{
+        if (loading) return /*#__PURE__*/ jsx(Loader, {});
+        if (error) return errorMessage;
+        return children || value || "N/A";
+    };
+    return /*#__PURE__*/ jsxs(Row, {
+        children: [
+            /*#__PURE__*/ jsx(Key, {
+                children: label
+            }),
+            actions ? /*#__PURE__*/ jsxs(GroupValues, {
+                children: [
+                    renderValue(),
+                    actions
+                ]
+            }) : /*#__PURE__*/ jsx(Value, {
+                children: renderValue()
+            })
+        ]
+    });
+};
+const Sections = ({ children })=>/*#__PURE__*/ jsx(Table, {
+        children: /*#__PURE__*/ jsx(Body, {
+            children: children
+        })
+    });
+const GeneralSection = ({ nameField, versioningField, locationField, renderName, renderVersioning, renderLocation })=>{
+    const { bucketName } = useBucketOverviewContext();
+    const { data: versioningData, status: versioningStatus } = useGetBucketVersioning({
+        Bucket: bucketName
+    });
+    return /*#__PURE__*/ jsxs(Section, {
+        title: "General",
+        children: [
+            nameField ? /*#__PURE__*/ jsx(Field, {
+                label: "Name",
+                children: nameField
+            }) : renderName ? /*#__PURE__*/ jsx(Field, {
+                label: "Name",
+                children: renderName(bucketName)
+            }) : /*#__PURE__*/ jsx(Field, {
+                label: "Name",
+                value: /*#__PURE__*/ jsx(ConstrainedText, {
+                    text: bucketName,
+                    lineClamp: 2
+                })
+            }),
+            versioningField ? /*#__PURE__*/ jsx(Field, {
+                label: "Versioning",
+                children: versioningField
+            }) : renderVersioning ? /*#__PURE__*/ jsx(Field, {
+                label: "Versioning",
+                children: renderVersioning(bucketName)
+            }) : /*#__PURE__*/ jsx(Field, {
+                label: "Versioning",
+                loading: "pending" === versioningStatus,
+                error: "error" === versioningStatus,
+                value: versioningData?.Status === "Enabled" ? "Active" : "Inactive"
+            }),
+            locationField ? /*#__PURE__*/ jsx(Field, {
+                label: "Location",
+                children: locationField
+            }) : renderLocation ? /*#__PURE__*/ jsx(Field, {
+                label: "Location",
+                children: renderLocation(bucketName)
+            }) : /*#__PURE__*/ jsx(Field, {
+                label: "Location",
+                value: /*#__PURE__*/ jsx(BucketLocation, {
+                    bucketName: bucketName
+                })
+            })
+        ]
+    });
+};
+const DataProtectionSection = ({ objectLockField, defaultRetentionField, renderObjectLock, renderDefaultRetention })=>{
+    const { bucketName } = useBucketOverviewContext();
+    const { data: objectLockData, status: objectLockStatus, error: objectLockError } = useGetBucketObjectLockConfiguration({
+        Bucket: bucketName
+    });
+    const isObjectLockNotConfigured = "error" === objectLockStatus && isNotFoundError(objectLockError);
+    const isObjectLockEnabled = objectLockData?.ObjectLockConfiguration?.ObjectLockEnabled === "Enabled";
+    return /*#__PURE__*/ jsxs(Section, {
+        title: "Data protection",
+        children: [
+            objectLockField ? /*#__PURE__*/ jsx(Field, {
+                label: "Object-lock",
+                children: objectLockField
+            }) : renderObjectLock ? /*#__PURE__*/ jsx(Field, {
+                label: "Object-lock",
+                children: renderObjectLock(bucketName)
+            }) : /*#__PURE__*/ jsx(Field, {
+                label: "Object-lock",
+                loading: "pending" === objectLockStatus,
+                error: "error" === objectLockStatus && !isObjectLockNotConfigured,
+                value: isObjectLockEnabled ? "Enabled" : "Disabled"
+            }),
+            !defaultRetentionField && !renderDefaultRetention && isObjectLockEnabled && /*#__PURE__*/ jsx(Field, {
+                label: "Default Retention",
+                loading: "pending" === objectLockStatus,
+                value: getDefaultBucketRetention(objectLockData),
+                actions: /*#__PURE__*/ jsx(EditRetentionButton, {
+                    bucketName: bucketName
+                })
+            }),
+            defaultRetentionField && /*#__PURE__*/ jsx(Field, {
+                label: "Default Retention",
+                children: defaultRetentionField
+            }),
+            renderDefaultRetention && /*#__PURE__*/ jsx(Field, {
+                label: "Default Retention",
+                children: renderDefaultRetention(bucketName)
+            })
+        ]
+    });
+};
+const PermissionsSection = ({ onEditPolicy, ownerField, aclField, corsField, publicField, bucketPolicyField, renderOwner, renderAcl, renderCors, renderPublic, renderBucketPolicy })=>{
+    const { bucketName } = useBucketOverviewContext();
+    const { getS3Config } = useDataBrowserContext();
+    const config = getS3Config();
+    const { data: aclData, status: aclStatus } = useGetBucketAcl({
+        Bucket: bucketName
+    });
+    const { data: corsData, status: corsStatus } = useGetBucketCors({
+        Bucket: bucketName
+    });
+    const { data: policyData, error: policyError, status: policyStatus } = useGetBucketPolicy({
+        Bucket: bucketName
+    });
+    const isPublic = aclData?.Grants?.find((grant)=>grant.Grantee?.URI === (config.publicAclIndicator || "http://acs.amazonaws.com/groups/global/AllUsers"));
+    return /*#__PURE__*/ jsxs(Section, {
+        title: "Permissions",
+        children: [
+            ownerField ? /*#__PURE__*/ jsx(Field, {
+                label: "Owner",
+                children: ownerField
+            }) : renderOwner ? /*#__PURE__*/ jsx(Field, {
+                label: "Owner",
+                children: renderOwner(bucketName)
+            }) : /*#__PURE__*/ jsx(Field, {
+                label: "Owner",
+                loading: "pending" === aclStatus,
+                error: "error" === aclStatus,
+                value: aclData?.Owner?.DisplayName || "N/A"
+            }),
+            aclField ? /*#__PURE__*/ jsx(Field, {
+                label: "ACL",
+                children: aclField
+            }) : renderAcl ? /*#__PURE__*/ jsx(Field, {
+                label: "ACL",
+                children: renderAcl(bucketName)
+            }) : /*#__PURE__*/ jsx(Field, {
+                label: "ACL",
+                loading: "pending" === aclStatus,
+                error: "error" === aclStatus,
+                value: aclData?.Grants?.length ? `${aclData.Grants.length} Grantee${1 !== aclData.Grants.length ? "s" : ""}` : "N/A"
+            }),
+            corsField ? /*#__PURE__*/ jsx(Field, {
+                label: "CORS",
+                children: corsField
+            }) : renderCors ? /*#__PURE__*/ jsx(Field, {
+                label: "CORS",
+                children: renderCors(bucketName)
+            }) : /*#__PURE__*/ jsx(Field, {
+                label: "CORS",
+                loading: "pending" === corsStatus,
+                value: corsData?.CORSRules && corsData.CORSRules.length > 0 ? "Yes" : "No"
+            }),
+            publicField ? /*#__PURE__*/ jsx(Field, {
+                label: "Public",
+                children: publicField
+            }) : renderPublic ? /*#__PURE__*/ jsx(Field, {
+                label: "Public",
+                children: renderPublic(bucketName)
+            }) : /*#__PURE__*/ jsx(Field, {
+                label: "Public",
+                loading: "pending" === aclStatus,
+                value: isPublic ? "Yes" : "No"
+            }),
+            bucketPolicyField ? /*#__PURE__*/ jsx(Field, {
+                label: "Bucket Policy",
+                children: bucketPolicyField
+            }) : renderBucketPolicy ? /*#__PURE__*/ jsx(Field, {
+                label: "Bucket Policy",
+                children: renderBucketPolicy(bucketName, onEditPolicy)
+            }) : /*#__PURE__*/ jsx(Field, {
+                label: "Bucket Policy",
+                error: "error" === policyStatus && policyError?.name !== "NoSuchBucketPolicy",
+                children: /*#__PURE__*/ jsxs(Box, {
+                    display: "flex",
+                    justifyContent: "space-between",
+                    alignItems: "center",
+                    gap: spacing.r8,
+                    children: [
+                        /*#__PURE__*/ jsx("span", {
+                            children: policyData?.Policy ? "Configured" : "Not configured"
+                        }),
+                        /*#__PURE__*/ jsx(BucketPolicyButton, {
+                            hasPolicy: !!policyData?.Policy,
+                            isLoading: "pending" === policyStatus,
+                            onEdit: ()=>onEditPolicy?.(bucketName)
+                        })
+                    ]
+                })
+            })
+        ]
+    });
+};
+const BucketOverview = BucketOverviewRoot;
+BucketOverview.Actions = Actions;
+BucketOverview.Sections = Sections;
+BucketOverview.Section = Section;
+BucketOverview.Field = Field;
+BucketOverview.GeneralSection = GeneralSection;
+BucketOverview.DataProtectionSection = DataProtectionSection;
+BucketOverview.PermissionsSection = PermissionsSection;
+export { BucketOverview, BucketOverviewContext, Field as BucketOverviewField, Section as BucketOverviewSection, useBucketOverviewContext };

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

@@ -0,0 +1,2 @@
+export declare const BucketPage: React.FC;
+export default BucketPage;

package/dist/components/buckets/BucketPage.js

@@ -0,0 +1,47 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { useBuckets } from "../../hooks/index.js";
+import { TextBadge } from "@scality/core-ui";
+import { Navigate, useNavigate, useParams } from "react-router-dom";
+import { BrowserPageLayout } from "../layouts/BrowserPageLayout.js";
+import { BucketDetails } from "./BucketDetails.js";
+import { BucketList } from "./BucketList.js";
+import { BucketLocation } from "./BucketLocation.js";
+const BucketPage_BucketPage = ()=>{
+    const { data, status } = useBuckets();
+    const { bucketName } = useParams();
+    const navigate = useNavigate();
+    const buckets = data?.Buckets || [];
+    const numInstance = buckets.length;
+    if (!bucketName && buckets.length > 0 && "success" === status) {
+        const firstBucketName = buckets[0]?.Name;
+        if (firstBucketName) return /*#__PURE__*/ jsx(Navigate, {
+            to: `/buckets/${firstBucketName}`,
+            replace: true
+        });
+    }
+    return /*#__PURE__*/ jsx(BrowserPageLayout, {
+        title: /*#__PURE__*/ jsxs(Fragment, {
+            children: [
+                "All Buckets",
+                /*#__PURE__*/ jsx(TextBadge, {
+                    text: numInstance.toString(),
+                    variant: "infoPrimary"
+                })
+            ]
+        }),
+        leftPanel: /*#__PURE__*/ jsx(BucketList, {
+            buckets: buckets,
+            bucketStatus: "pending" === status ? "loading" : "error" === status ? "error" : "success",
+            selectedBucketName: bucketName,
+            onBucketSelect: (bucketName)=>navigate(`/buckets/${bucketName}`),
+            onCreateBucket: ()=>navigate("/buckets/-/create"),
+            onNavigateToBucket: (bucketName)=>navigate(`/buckets/${bucketName}/objects`),
+            renderBucketLocation: (bucketName)=>/*#__PURE__*/ jsx(BucketLocation, {
+                    bucketName: bucketName
+                })
+        }),
+        rightPanel: /*#__PURE__*/ jsx(BucketDetails, {})
+    });
+};
+const BucketPage = BucketPage_BucketPage;
+export { BucketPage_BucketPage as BucketPage, BucketPage as default };

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

@@ -0,0 +1,7 @@
+interface BucketPolicyButtonProps {
+    hasPolicy: boolean;
+    isLoading?: boolean;
+    onEdit: () => void;
+}
+export declare const BucketPolicyButton: React.FC<BucketPolicyButtonProps>;
+export {};

package/dist/components/buckets/BucketPolicyButton.js

@@ -0,0 +1,18 @@
+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, {
+        display: "flex",
+        alignItems: "center",
+        gap: spacing.r8,
+        children: /*#__PURE__*/ jsx(Button, {
+            isLoading: isLoading,
+            variant: "outline",
+            label: hasPolicy ? "Edit" : "Create",
+            icon: /*#__PURE__*/ jsx(Icon, {
+                name: hasPolicy ? "Pen" : "Create-add"
+            }),
+            onClick: onEdit
+        })
+    });
+export { BucketPolicyButton };

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

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

package/dist/components/buckets/BucketPolicyPage.js

@@ -0,0 +1,236 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo } from "react";
+import { useNavigate, useParams } from "react-router-dom";
+import { Banner, Form, FormGroup, FormSection, Icon, Loader, Stack, Text } from "@scality/core-ui";
+import { Box, Button, CopyButton } from "@scality/core-ui/dist/next";
+import { Controller, useForm } from "react-hook-form";
+import { Editor } from "../Editor.js";
+import { useGetBucketPolicy, useISVBucketStatus, useSetBucketPolicy } from "../../hooks/index.js";
+import bucketPolicySchema from "../../schemas/bucketPolicySchema.json";
+const getDefaultPolicyTemplate = (bucketName)=>`{
+  "Version": "2012-10-17",
+  "Statement": [
+    {
+      "Sid": "ExampleStatement",
+      "Effect": "Allow",
+      "Principal": "*",
+      "Action": "s3:GetObject",
+      "Resource": "arn:aws:s3:::${bucketName}/*"
+    }
+  ]
+}`;
+const BucketPolicyPage = ()=>{
+    const { bucketName } = useParams();
+    const navigate = useNavigate();
+    const { mutate: savePolicy, isPending: isSaving } = useSetBucketPolicy();
+    const { isISVManaged, isvApplication, isLoading: isISVLoading } = useISVBucketStatus(bucketName);
+    const { control, handleSubmit, watch, setValue, setError, formState: { isDirty, isValid, errors } } = useForm({
+        mode: "onChange",
+        defaultValues: {
+            policyDocument: ""
+        }
+    });
+    const policyDocument = watch("policyDocument");
+    const { data: policyData, status: policyStatus, error: policyError } = useGetBucketPolicy({
+        Bucket: bucketName
+    });
+    const isCreateMode = useMemo(()=>policyError && ("NoSuchBucketPolicy" === policyError.name || policyError.message?.includes("does not exist")), [
+        policyError
+    ]);
+    const initialPolicy = useMemo(()=>{
+        const policyString = policyData?.Policy;
+        if (policyString) try {
+            const parsed = JSON.parse(policyString);
+            return JSON.stringify(parsed, null, 2);
+        } catch  {
+            return policyString;
+        }
+        return getDefaultPolicyTemplate(bucketName);
+    }, [
+        policyData,
+        bucketName
+    ]);
+    useEffect(()=>{
+        setValue("policyDocument", initialPolicy);
+    }, [
+        initialPolicy,
+        setValue
+    ]);
+    const handleBeforeMount = useCallback((monaco)=>{
+        monaco.languages.json.jsonDefaults.setDiagnosticsOptions({
+            validate: true,
+            schemas: [
+                {
+                    uri: "http://myserver/bucket-policy-schema.json",
+                    fileMatch: [
+                        "*"
+                    ],
+                    schema: bucketPolicySchema
+                }
+            ]
+        });
+    }, []);
+    const handleCancel = useCallback(()=>{
+        navigate(`/buckets/${bucketName}`);
+    }, [
+        navigate,
+        bucketName
+    ]);
+    const onSubmit = useCallback((data)=>{
+        try {
+            JSON.parse(data.policyDocument);
+        } catch (error) {
+            const errorMessage = "Invalid JSON format";
+            setError("policyDocument", {
+                type: "custom",
+                message: errorMessage
+            });
+            return;
+        }
+        const minifiedPolicy = JSON.stringify(JSON.parse(data.policyDocument));
+        savePolicy({
+            Bucket: bucketName,
+            Policy: minifiedPolicy
+        }, {
+            onSuccess: ()=>{
+                navigate(`/buckets/${bucketName}`);
+            },
+            onError: (error)=>{
+                const errorMessage = error instanceof Error ? error.message : "Failed to save policy";
+                setError("policyDocument", {
+                    type: "custom",
+                    message: `Save policy error: ${errorMessage}`
+                });
+            }
+        });
+    }, [
+        bucketName,
+        savePolicy,
+        navigate,
+        setError
+    ]);
+    if ("pending" === policyStatus || isISVLoading) return /*#__PURE__*/ jsx(Loader, {
+        centered: true,
+        size: "massive",
+        children: /*#__PURE__*/ jsx(Fragment, {
+            children: "Loading policy..."
+        })
+    });
+    return /*#__PURE__*/ jsx(Form, {
+        onSubmit: handleSubmit(onSubmit),
+        layout: {
+            kind: "page",
+            title: `Bucket Policy ${isCreateMode ? "Creation" : "Edition"}`
+        },
+        requireMode: isCreateMode ? "partial" : "all",
+        rightActions: /*#__PURE__*/ jsxs(Stack, {
+            gap: "r16",
+            children: [
+                /*#__PURE__*/ jsx(Button, {
+                    variant: "outline",
+                    label: "Cancel",
+                    onClick: handleCancel,
+                    type: "button",
+                    disabled: isSaving
+                }),
+                /*#__PURE__*/ jsx(Button, {
+                    variant: "primary",
+                    label: "Save",
+                    icon: /*#__PURE__*/ jsx(Icon, {
+                        name: "Save"
+                    }),
+                    type: "submit",
+                    disabled: !isDirty || !isValid || isSaving
+                })
+            ]
+        }),
+        children: /*#__PURE__*/ jsxs(Fragment, {
+            children: [
+                isISVManaged && /*#__PURE__*/ jsx(Banner, {
+                    variant: "warning",
+                    icon: /*#__PURE__*/ jsx(Icon, {
+                        color: "statusWarning",
+                        name: "Exclamation-triangle"
+                    }),
+                    children: /*#__PURE__*/ jsxs(Text, {
+                        children: [
+                            /*#__PURE__*/ jsx("strong", {
+                                children: "Warning:"
+                            }),
+                            " This bucket is managed by",
+                            " ",
+                            isvApplication,
+                            ". Adding a Bucket Policy may conflict with IAM policies created by ",
+                            isvApplication,
+                            ", potentially disrupting",
+                            " ",
+                            isvApplication,
+                            " operations (e.g., backup cleanup). Ensure your Bucket Policy does not deny actions that ",
+                            isvApplication,
+                            " ",
+                            "requires."
+                        ]
+                    })
+                }),
+                /*#__PURE__*/ jsxs(FormSection, {
+                    children: [
+                        /*#__PURE__*/ jsx(FormGroup, {
+                            id: "bucketName",
+                            label: "Bucket Name",
+                            required: true,
+                            direction: "horizontal",
+                            content: /*#__PURE__*/ jsx(Text, {
+                                children: bucketName
+                            })
+                        }),
+                        /*#__PURE__*/ jsx(FormGroup, {
+                            id: "policyDocument",
+                            label: "Policy Document",
+                            required: true,
+                            direction: "vertical",
+                            help: "AWS Bucket policy standards are supported.",
+                            helpErrorPosition: "bottom",
+                            error: errors?.policyDocument?.message,
+                            content: /*#__PURE__*/ jsxs(Stack, {
+                                children: [
+                                    /*#__PURE__*/ jsx(Controller, {
+                                        control: control,
+                                        name: "policyDocument",
+                                        rules: {
+                                            required: "The policy document is required",
+                                            validate: (value)=>{
+                                                try {
+                                                    JSON.parse(value);
+                                                    return true;
+                                                } catch  {
+                                                    return "Invalid JSON format";
+                                                }
+                                            }
+                                        },
+                                        render: ({ field: { onChange, value } })=>/*#__PURE__*/ jsx(Editor, {
+                                                value: value,
+                                                onChange: onChange,
+                                                language: "json",
+                                                height: "60vh",
+                                                width: "33rem",
+                                                beforeMount: handleBeforeMount
+                                            })
+                                    }),
+                                    /*#__PURE__*/ jsx(Box, {
+                                        alignSelf: "baseline",
+                                        children: /*#__PURE__*/ jsx(CopyButton, {
+                                            textToCopy: policyDocument,
+                                            label: "Policy",
+                                            variant: "outline"
+                                        })
+                                    })
+                                ]
+                            })
+                        })
+                    ]
+                })
+            ]
+        })
+    });
+};
+export { BucketPolicyPage };

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

@@ -0,0 +1 @@
+export declare function BucketReplicationFormPage(): import("react/jsx-runtime").JSX.Element;