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

package/dist/components/buckets/BucketOverview.js

@@ -0,0 +1,209 @@
+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 "react";
+import { useGetBucketAcl, useGetBucketCors, useGetBucketObjectLockConfiguration, useGetBucketPolicy, useGetBucketVersioning } from "../../hooks/index.js";
+import { useDataBrowserContext } from "../providers/DataBrowserProvider.js";
+import { Body, Group, GroupContent, GroupName, Key, Row, Table, TableContainer, Value } from "../ui/Table.elements.js";
+import { BucketLocation } from "./BucketLocation.js";
+import { BucketPolicyButton } from "./BucketPolicyButton.js";
+const BucketOverview = ({ bucketName, onEmptyBucket, onDeleteBucket, onEditPolicy, renderDeleteButton, renderEmptyButton, isEmptyBucketDisabled = true, isDeleteBucketDisabled = false })=>{
+    const { getS3Config } = useDataBrowserContext();
+    const config = getS3Config();
+    const { data: versioningData, status: versioningStatus } = useGetBucketVersioning({
+        Bucket: bucketName
+    });
+    const { data: aclData, status: aclStatus } = useGetBucketAcl({
+        Bucket: bucketName
+    });
+    const { data: corsData, status: corsStatus } = useGetBucketCors({
+        Bucket: bucketName
+    });
+    const { data: objectLockData, status: objectLockStatus } = useGetBucketObjectLockConfiguration({
+        Bucket: bucketName
+    });
+    const { data: policyData, error: policyError, status: policyStatus } = useGetBucketPolicy({
+        Bucket: bucketName
+    });
+    return /*#__PURE__*/ jsxs(TableContainer, {
+        children: [
+            /*#__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
+                    })
+                ]
+            }),
+            /*#__PURE__*/ jsx(Table, {
+                children: /*#__PURE__*/ jsxs(Body, {
+                    children: [
+                        /*#__PURE__*/ jsxs(Group, {
+                            children: [
+                                /*#__PURE__*/ jsx(GroupName, {
+                                    children: "General"
+                                }),
+                                /*#__PURE__*/ jsxs(GroupContent, {
+                                    children: [
+                                        /*#__PURE__*/ jsxs(Row, {
+                                            children: [
+                                                /*#__PURE__*/ jsx(Key, {
+                                                    children: "Name"
+                                                }),
+                                                /*#__PURE__*/ jsx(Value, {
+                                                    width: "15rem",
+                                                    children: /*#__PURE__*/ jsx(ConstrainedText, {
+                                                        text: bucketName,
+                                                        lineClamp: 2
+                                                    })
+                                                })
+                                            ]
+                                        }),
+                                        /*#__PURE__*/ jsxs(Row, {
+                                            children: [
+                                                /*#__PURE__*/ jsx(Key, {
+                                                    children: "Versioning"
+                                                }),
+                                                /*#__PURE__*/ jsx(Value, {
+                                                    children: "pending" === versioningStatus ? /*#__PURE__*/ jsx(Loader, {}) : "error" === versioningStatus ? "Error" : versioningData?.Status === "Enabled" ? "Active" : "Inactive"
+                                                })
+                                            ]
+                                        }),
+                                        /*#__PURE__*/ jsxs(Row, {
+                                            children: [
+                                                /*#__PURE__*/ jsx(Key, {
+                                                    children: "Location"
+                                                }),
+                                                /*#__PURE__*/ jsx(Value, {
+                                                    children: /*#__PURE__*/ jsx(BucketLocation, {
+                                                        bucketName: bucketName
+                                                    })
+                                                })
+                                            ]
+                                        })
+                                    ]
+                                })
+                            ]
+                        }),
+                        /*#__PURE__*/ jsxs(Group, {
+                            children: [
+                                /*#__PURE__*/ jsx(GroupName, {
+                                    children: "Data protection"
+                                }),
+                                /*#__PURE__*/ jsx(GroupContent, {
+                                    children: /*#__PURE__*/ jsxs(Row, {
+                                        children: [
+                                            /*#__PURE__*/ jsx(Key, {
+                                                children: "Object-lock"
+                                            }),
+                                            /*#__PURE__*/ jsx(Value, {
+                                                children: "pending" === objectLockStatus ? /*#__PURE__*/ jsx(Loader, {}) : "error" === objectLockStatus ? "Disabled" : objectLockData?.ObjectLockConfiguration?.ObjectLockEnabled === "Enabled" ? "Enabled" : "Disabled"
+                                            })
+                                        ]
+                                    })
+                                })
+                            ]
+                        }),
+                        /*#__PURE__*/ jsxs(Group, {
+                            children: [
+                                /*#__PURE__*/ jsx(GroupName, {
+                                    children: "Permissions"
+                                }),
+                                /*#__PURE__*/ jsxs(GroupContent, {
+                                    children: [
+                                        /*#__PURE__*/ jsxs(Row, {
+                                            children: [
+                                                /*#__PURE__*/ jsx(Key, {
+                                                    children: "Owner"
+                                                }),
+                                                /*#__PURE__*/ jsx(Value, {
+                                                    children: "pending" === aclStatus ? /*#__PURE__*/ jsx(Loader, {}) : "error" === aclStatus ? "Error" : aclData?.Owner?.DisplayName || "N/A"
+                                                })
+                                            ]
+                                        }),
+                                        /*#__PURE__*/ jsxs(Row, {
+                                            children: [
+                                                /*#__PURE__*/ jsx(Key, {
+                                                    children: "ACL"
+                                                }),
+                                                /*#__PURE__*/ jsx(Value, {
+                                                    children: "pending" === aclStatus ? /*#__PURE__*/ jsx(Loader, {}) : "error" === aclStatus ? "Error" : aclData?.Grants?.length ? `${aclData.Grants.length} Grantee${1 !== aclData.Grants.length ? "s" : ""}` : "N/A"
+                                                })
+                                            ]
+                                        }),
+                                        /*#__PURE__*/ jsxs(Row, {
+                                            children: [
+                                                /*#__PURE__*/ jsx(Key, {
+                                                    children: "CORS"
+                                                }),
+                                                /*#__PURE__*/ jsx(Value, {
+                                                    children: "pending" === corsStatus ? /*#__PURE__*/ jsx(Loader, {}) : "error" === corsStatus ? "No" : corsData?.CORSRules && corsData.CORSRules.length > 0 ? "Yes" : "No"
+                                                })
+                                            ]
+                                        }),
+                                        /*#__PURE__*/ jsxs(Row, {
+                                            children: [
+                                                /*#__PURE__*/ jsx(Key, {
+                                                    children: "Public"
+                                                }),
+                                                /*#__PURE__*/ jsx(Value, {
+                                                    children: "pending" === aclStatus ? /*#__PURE__*/ jsx(Loader, {}) : "error" === aclStatus ? "No" : aclData?.Grants ? aclData.Grants.find((grant)=>grant.Grantee?.URI === (config.publicAclIndicator || "http://acs.amazonaws.com/groups/global/AllUsers")) ? "Yes" : "No" : "No"
+                                                })
+                                            ]
+                                        }),
+                                        /*#__PURE__*/ jsxs(Row, {
+                                            children: [
+                                                /*#__PURE__*/ jsx(Key, {
+                                                    children: "Bucket Policy"
+                                                }),
+                                                /*#__PURE__*/ jsx(Value, {
+                                                    children: "error" === policyStatus && policyError?.name !== "NoSuchBucketPolicy" ? "Error" : /*#__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)
+                                                            })
+                                                        ]
+                                                    })
+                                                })
+                                            ]
+                                        })
+                                    ]
+                                })
+                            ]
+                        })
+                    ]
+                })
+            })
+        ]
+    });
+};
+export { BucketOverview };

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("/create-bucket"),
+            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,205 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo } from "react";
+import { useNavigate, useParams } from "react-router-dom";
+import { 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, 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 { 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) 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(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/DeleteBucketButton.d.ts

@@ -0,0 +1,8 @@
+interface DeleteBucketButtonProps {
+    bucketName: string;
+    onDeleteSuccess?: (bucketName: string) => void;
+    onDeleteError?: (error: Error) => void;
+    disabled?: boolean;
+}
+export declare const DeleteBucketButton: ({ bucketName, onDeleteSuccess, onDeleteError, disabled, }: DeleteBucketButtonProps) => import("react/jsx-runtime").JSX.Element;
+export default DeleteBucketButton;

package/dist/components/buckets/DeleteBucketButton.js

@@ -0,0 +1,78 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { useIsBucketEmpty } from "../../hooks/useIsBucketEmpty.js";
+import { useDeleteBucket } from "../../hooks/bucketOperations.js";
+import { Icon, Loader, Modal, Stack, Tooltip, Wrap } from "@scality/core-ui";
+import { Button } from "@scality/core-ui/dist/next";
+const DeleteBucketButton = ({ bucketName, onDeleteSuccess, onDeleteError, disabled = false })=>{
+    const [isDeleteModalOpen, setIsDeleteModalOpen] = useState(false);
+    const { isEmpty, isLoading } = useIsBucketEmpty(bucketName);
+    const { mutate: deleteBucket, status } = useDeleteBucket();
+    const handleDeleteClick = ()=>{
+        setIsDeleteModalOpen(!isDeleteModalOpen);
+    };
+    const approve = ()=>{
+        deleteBucket({
+            Bucket: bucketName
+        }, {
+            onSuccess: ()=>{
+                handleDeleteClick();
+                onDeleteSuccess?.(bucketName);
+            },
+            onError: (error)=>{
+                onDeleteError?.(error instanceof Error ? error : new Error("Delete failed"));
+            }
+        });
+    };
+    const isButtonDisabled = disabled || !isEmpty;
+    return /*#__PURE__*/ jsxs(Fragment, {
+        children: [
+            /*#__PURE__*/ jsx(Tooltip, {
+                overlay: isLoading ? "Checking bucket..." : "Bucket is not empty",
+                overlayStyle: {
+                    display: isEmpty ? "none" : void 0
+                },
+                children: /*#__PURE__*/ jsx(Button, {
+                    icon: /*#__PURE__*/ jsx(Icon, {
+                        name: "Delete"
+                    }),
+                    disabled: isButtonDisabled,
+                    variant: "danger",
+                    onClick: handleDeleteClick,
+                    label: "Delete Bucket"
+                })
+            }),
+            /*#__PURE__*/ jsx(Modal, {
+                close: handleDeleteClick,
+                isOpen: isDeleteModalOpen,
+                footer: /*#__PURE__*/ jsxs(Wrap, {
+                    children: [
+                        /*#__PURE__*/ jsx("p", {}),
+                        /*#__PURE__*/ jsxs(Stack, {
+                            children: [
+                                /*#__PURE__*/ jsx(Button, {
+                                    variant: "outline",
+                                    onClick: handleDeleteClick,
+                                    label: "Cancel"
+                                }),
+                                /*#__PURE__*/ jsx(Button, {
+                                    disabled: "pending" === status,
+                                    variant: "danger",
+                                    onClick: approve,
+                                    icon: "pending" === status && /*#__PURE__*/ jsx(Loader, {
+                                        size: "larger"
+                                    }),
+                                    label: "Delete"
+                                })
+                            ]
+                        })
+                    ]
+                }),
+                title: "Confirmation",
+                children: `Are you sure you want to delete bucket: ${bucketName} ?`
+            })
+        ]
+    });
+};
+const buckets_DeleteBucketButton = DeleteBucketButton;
+export { DeleteBucketButton, buckets_DeleteBucketButton as default };

package/dist/components/index.d.ts

@@ -0,0 +1,12 @@
+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 { 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";

package/dist/components/index.js

@@ -0,0 +1,13 @@
+import { DeleteBucketButton } from "./buckets/DeleteBucketButton.js";
+import { BucketList } from "./buckets/BucketList.js";
+import { BucketOverview } from "./buckets/BucketOverview.js";
+import { BucketPage } from "./buckets/BucketPage.js";
+import { BucketPolicyPage } from "./buckets/BucketPolicyPage.js";
+import { UploadButton } from "./objects/UploadButton.js";
+import { CreateFolderButton } from "./objects/CreateFolderButton.js";
+import { ObjectDetails } from "./objects/ObjectDetails/index.js";
+import { ObjectList } from "./objects/ObjectList.js";
+import { ObjectPage } from "./objects/ObjectPage.js";
+import { MetadataSearch } from "./search/MetadataSearch.js";
+import { DataBrowserProvider, useDataBrowserContext, useDataBrowserTheme } from "./providers/DataBrowserProvider.js";
+export { BucketList, BucketOverview, BucketPage, BucketPolicyPage, CreateFolderButton, DataBrowserProvider, DeleteBucketButton, MetadataSearch, ObjectDetails, ObjectList, ObjectPage, UploadButton, useDataBrowserContext, useDataBrowserTheme };

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

@@ -0,0 +1,9 @@
+import 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;
+}
+export declare const BrowserPageLayout: React.FC<BrowserPageLayoutProps>;
+export {};