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

package/dist/components/objects/ObjectLock/ObjectLockSettingsUtils.d.ts

@@ -0,0 +1,8 @@
+import type { GetObjectRetentionCommandOutput } from "@aws-sdk/client-s3";
+export declare function getDefaultRetention(retentionData: GetObjectRetentionCommandOutput | null | undefined): {
+    isDefaultRetentionEnabled: boolean;
+    defaultRetentionUntilDate: Date;
+    defaultRetentionMode: import("@aws-sdk/client-s3").ObjectLockRetentionMode;
+};
+export declare function getDefaultMinRetainUntilDate(d: Date | null | undefined, mode: string): string;
+export declare function getRetainUntilDateHint(dateString: string): string;

package/dist/components/objects/ObjectLock/ObjectLockSettingsUtils.js

@@ -0,0 +1,39 @@
+function getDefaultRetention(retentionData) {
+    const isDefaultRetentionEnabled = retentionData?.Retention !== void 0 && null !== retentionData.Retention;
+    const defaultRetentionUntilDate = retentionData?.Retention?.RetainUntilDate ? new Date(retentionData.Retention.RetainUntilDate) : new Date();
+    const defaultRetentionMode = retentionData?.Retention?.Mode || "GOVERNANCE";
+    return {
+        isDefaultRetentionEnabled,
+        defaultRetentionUntilDate,
+        defaultRetentionMode
+    };
+}
+function getDefaultMinRetainUntilDate(d, mode) {
+    const tomorrow = new Date();
+    tomorrow.setDate(tomorrow.getDate() + 1);
+    const futureDate = formatDateForInput(tomorrow);
+    if (!d) return futureDate;
+    const previousRetainUntilDate = "GOVERNANCE" === mode ? formatDateForInput(d) : formatDateForInput(addDays(d, 1));
+    return previousRetainUntilDate > futureDate ? previousRetainUntilDate : futureDate;
+}
+function formatDateForInput(date) {
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, "0");
+    const day = String(date.getDate()).padStart(2, "0");
+    return `${year}-${month}-${day}`;
+}
+function addDays(date, days) {
+    const result = new Date(date);
+    result.setDate(result.getDate() + days);
+    return result;
+}
+function getRetainUntilDateHint(dateString) {
+    const now = new Date();
+    const retainUntilDate = new Date(dateString);
+    const diffInMs = retainUntilDate.getTime() - now.getTime();
+    const diffInDays = Math.floor(diffInMs / 86400000);
+    if (diffInDays < 1) return "(within 24 hours from now)";
+    if (1 === diffInDays) return "(1 day from now)";
+    return `(${diffInDays} days from now)`;
+}
+export { getDefaultMinRetainUntilDate, getDefaultRetention, getRetainUntilDateHint };

package/dist/components/objects/ObjectLock/__tests__/EditRetentionButton.test.d.ts

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

package/dist/components/objects/ObjectLock/__tests__/EditRetentionButton.test.js

@@ -0,0 +1,204 @@
+import { jsx } from "react/jsx-runtime";
+import { fireEvent, render, screen } from "@testing-library/react";
+import { MemoryRouter, useNavigate } from "react-router-dom";
+import { createTestWrapper } from "../../../../test/testUtils.js";
+import { EditRetentionButton } from "../EditRetentionButton.js";
+import { useISVBucketStatus } from "../../../../hooks/index.js";
+jest.mock("../../../../hooks");
+jest.mock("react-router-dom", ()=>({
+        ...jest.requireActual("react-router-dom"),
+        useNavigate: jest.fn()
+    }));
+const mockUseISVBucketStatus = jest.mocked(useISVBucketStatus);
+const mockUseNavigate = jest.mocked(useNavigate);
+const renderEditRetentionButton = (props = {})=>{
+    const Wrapper = createTestWrapper();
+    const mockNavigate = jest.fn();
+    mockUseNavigate.mockReturnValue(mockNavigate);
+    const result = render(/*#__PURE__*/ jsx(MemoryRouter, {
+        children: /*#__PURE__*/ jsx(Wrapper, {
+            children: /*#__PURE__*/ jsx(EditRetentionButton, {
+                bucketName: "test-bucket",
+                ...props
+            })
+        })
+    }));
+    return {
+        ...result,
+        navigate: mockNavigate
+    };
+};
+beforeEach(()=>{
+    jest.clearAllMocks();
+    mockUseISVBucketStatus.mockReturnValue({
+        isVeeamBucket: false,
+        isCommvaultBucket: false,
+        isISVManaged: false,
+        isvApplication: void 0,
+        isLoading: false,
+        bucketTagsStatus: "success"
+    });
+});
+it("renders edit button", ()=>{
+    renderEditRetentionButton();
+    const editButton = screen.getByRole("button", {
+        name: /edit default retention/i
+    });
+    expect(editButton).toBeInTheDocument();
+});
+it("navigates to object lock settings page when clicked", ()=>{
+    const { navigate } = renderEditRetentionButton();
+    const editButton = screen.getByRole("button", {
+        name: /edit default retention/i
+    });
+    fireEvent.click(editButton);
+    expect(navigate).toHaveBeenCalledWith("/buckets/test-bucket/objects/object-lock-settings");
+});
+it("navigates with correct bucket name", ()=>{
+    const { navigate } = renderEditRetentionButton();
+    const editButton = screen.getByRole("button", {
+        name: /edit default retention/i
+    });
+    fireEvent.click(editButton);
+    expect(navigate).toHaveBeenCalledWith("/buckets/test-bucket/objects/object-lock-settings");
+});
+it("is enabled for regular buckets without ISV tags", ()=>{
+    renderEditRetentionButton();
+    const editButton = screen.getByRole("button", {
+        name: /edit default retention/i
+    });
+    expect(editButton).not.toBeDisabled();
+});
+it("is disabled for Veeam Backup & Replication buckets", ()=>{
+    mockUseISVBucketStatus.mockReturnValue({
+        isVeeamBucket: true,
+        isCommvaultBucket: false,
+        isISVManaged: true,
+        isvApplication: "Veeam",
+        isLoading: false,
+        bucketTagsStatus: "success"
+    });
+    renderEditRetentionButton();
+    const editButton = screen.getByRole("button", {
+        name: /edit default retention/i
+    });
+    expect(editButton).toBeDisabled();
+});
+it("is disabled for Veeam Office 365 v6/v7 buckets", ()=>{
+    mockUseISVBucketStatus.mockReturnValue({
+        isVeeamBucket: true,
+        isCommvaultBucket: false,
+        isISVManaged: true,
+        isvApplication: "Veeam",
+        isLoading: false,
+        bucketTagsStatus: "success"
+    });
+    renderEditRetentionButton();
+    const editButton = screen.getByRole("button", {
+        name: /edit default retention/i
+    });
+    expect(editButton).toBeDisabled();
+});
+it("is disabled for Veeam Office 365 v8+ buckets", ()=>{
+    mockUseISVBucketStatus.mockReturnValue({
+        isVeeamBucket: true,
+        isCommvaultBucket: false,
+        isISVManaged: true,
+        isvApplication: "Veeam",
+        isLoading: false,
+        bucketTagsStatus: "success"
+    });
+    renderEditRetentionButton();
+    const editButton = screen.getByRole("button", {
+        name: /edit default retention/i
+    });
+    expect(editButton).toBeDisabled();
+});
+it("is disabled for Commvault buckets", ()=>{
+    mockUseISVBucketStatus.mockReturnValue({
+        isVeeamBucket: false,
+        isCommvaultBucket: true,
+        isISVManaged: true,
+        isvApplication: "Commvault",
+        isLoading: false,
+        bucketTagsStatus: "success"
+    });
+    renderEditRetentionButton();
+    const editButton = screen.getByRole("button", {
+        name: /edit default retention/i
+    });
+    expect(editButton).toBeDisabled();
+});
+it("is disabled for ISV buckets tagged as Veeam Backup for Microsoft 365", ()=>{
+    mockUseISVBucketStatus.mockReturnValue({
+        isVeeamBucket: true,
+        isCommvaultBucket: false,
+        isISVManaged: true,
+        isvApplication: "Veeam",
+        isLoading: false,
+        bucketTagsStatus: "success"
+    });
+    renderEditRetentionButton();
+    const editButton = screen.getByRole("button", {
+        name: /edit default retention/i
+    });
+    expect(editButton).toBeDisabled();
+});
+it("is disabled for ISV buckets tagged as Veeam Backup & Replication", ()=>{
+    mockUseISVBucketStatus.mockReturnValue({
+        isVeeamBucket: true,
+        isCommvaultBucket: false,
+        isISVManaged: true,
+        isvApplication: "Veeam",
+        isLoading: false,
+        bucketTagsStatus: "success"
+    });
+    renderEditRetentionButton();
+    const editButton = screen.getByRole("button", {
+        name: /edit default retention/i
+    });
+    expect(editButton).toBeDisabled();
+});
+it("handles missing bucket tags gracefully", ()=>{
+    renderEditRetentionButton();
+    const editButton = screen.getByRole("button", {
+        name: /edit default retention/i
+    });
+    expect(editButton).not.toBeDisabled();
+});
+it("handles empty TagSet gracefully", ()=>{
+    renderEditRetentionButton();
+    const editButton = screen.getByRole("button", {
+        name: /edit default retention/i
+    });
+    expect(editButton).not.toBeDisabled();
+});
+it("is enabled for buckets with non-ISV tags", ()=>{
+    renderEditRetentionButton();
+    const editButton = screen.getByRole("button", {
+        name: /edit default retention/i
+    });
+    expect(editButton).not.toBeDisabled();
+});
+it("handles bucket tagging query error gracefully", ()=>{
+    renderEditRetentionButton();
+    const editButton = screen.getByRole("button", {
+        name: /edit default retention/i
+    });
+    expect(editButton).not.toBeDisabled();
+});
+it("shows loading state when fetching bucket tags", ()=>{
+    mockUseISVBucketStatus.mockReturnValue({
+        isVeeamBucket: false,
+        isCommvaultBucket: false,
+        isISVManaged: false,
+        isvApplication: void 0,
+        isLoading: true,
+        bucketTagsStatus: "pending"
+    });
+    renderEditRetentionButton();
+    const editButton = screen.getByRole("button", {
+        name: /edit default retention/i
+    });
+    expect(editButton).toBeInTheDocument();
+});

package/dist/components/objects/ObjectLock/__tests__/ObjectLockSettings.test.d.ts

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

package/dist/components/objects/ObjectLock/__tests__/ObjectLockSettings.test.js

@@ -0,0 +1,374 @@
+import { jsx } from "react/jsx-runtime";
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import user_event from "@testing-library/user-event";
+import { MemoryRouter, Route, Routes } from "react-router-dom";
+import { createTestWrapper } from "../../../../test/testUtils.js";
+import { ObjectLockSettings } from "../ObjectLockSettings.js";
+import { useGetBucketObjectLockConfiguration, useSetBucketObjectLockConfiguration } from "../../../../hooks/index.js";
+jest.mock("../../../../hooks", ()=>({
+        useGetBucketObjectLockConfiguration: jest.fn(),
+        useSetBucketObjectLockConfiguration: jest.fn()
+    }));
+const mockUseGetBucketObjectLockConfiguration = jest.mocked(useGetBucketObjectLockConfiguration);
+const mockUseSetBucketObjectLockConfiguration = jest.mocked(useSetBucketObjectLockConfiguration);
+const mockNavigate = jest.fn();
+jest.mock("react-router-dom", ()=>({
+        ...jest.requireActual("react-router-dom"),
+        useNavigate: ()=>mockNavigate
+    }));
+const renderObjectLockSettings = (bucketName = "test-bucket")=>{
+    const Wrapper = createTestWrapper();
+    return render(/*#__PURE__*/ jsx(MemoryRouter, {
+        initialEntries: [
+            `/buckets/${bucketName}/objects/settings`
+        ],
+        children: /*#__PURE__*/ jsx(Wrapper, {
+            children: /*#__PURE__*/ jsx(Routes, {
+                children: /*#__PURE__*/ jsx(Route, {
+                    path: "/buckets/:bucketName/objects/settings",
+                    element: /*#__PURE__*/ jsx(ObjectLockSettings, {})
+                })
+            })
+        })
+    }));
+};
+describe("ObjectLockSettings", ()=>{
+    const mockMutate = jest.fn();
+    beforeEach(()=>{
+        jest.clearAllMocks();
+        mockNavigate.mockClear();
+        mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+            data: void 0,
+            status: "success"
+        });
+        mockUseSetBucketObjectLockConfiguration.mockReturnValue({
+            mutate: mockMutate,
+            isPending: false
+        });
+    });
+    it("displays loading state while fetching bucket configuration", ()=>{
+        mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+            data: void 0,
+            status: "pending"
+        });
+        renderObjectLockSettings();
+        expect(screen.getByText("Loading retention settings...")).toBeInTheDocument();
+    });
+    it("renders form with Object Lock checkbox", async ()=>{
+        renderObjectLockSettings();
+        await waitFor(()=>{
+            expect(screen.getByText("Object-lock settings")).toBeInTheDocument();
+        });
+        expect(screen.getByLabelText(/object-lock/i)).toBeInTheDocument();
+    });
+    it("disables save button when Object Lock is not enabled", async ()=>{
+        renderObjectLockSettings();
+        await waitFor(()=>{
+            const saveButton = screen.getByRole("button", {
+                name: /save/i
+            });
+            expect(saveButton).toBeDisabled();
+        });
+    });
+    it("shows Default Retention fields when Object Lock is enabled", async ()=>{
+        mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+            data: {
+                ObjectLockConfiguration: {
+                    ObjectLockEnabled: "Enabled"
+                }
+            },
+            status: "success"
+        });
+        renderObjectLockSettings();
+        await waitFor(()=>{
+            expect(screen.getByText("Default Retention")).toBeInTheDocument();
+            expect(screen.getByText("Retention mode")).toBeInTheDocument();
+            expect(screen.getByText("Retention period")).toBeInTheDocument();
+        }, {
+            timeout: 3000
+        });
+    });
+    it("enables save button when Object Lock is enabled", async ()=>{
+        mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+            data: {
+                ObjectLockConfiguration: {
+                    ObjectLockEnabled: "Enabled"
+                }
+            },
+            status: "success"
+        });
+        renderObjectLockSettings();
+        await waitFor(()=>{
+            const saveButton = screen.getByRole("button", {
+                name: /save/i
+            });
+            expect(saveButton).toBeEnabled();
+        }, {
+            timeout: 3000
+        });
+    });
+    it("enables retention fields when Default Retention is checked", async ()=>{
+        mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+            data: {
+                ObjectLockConfiguration: {
+                    ObjectLockEnabled: "Enabled"
+                }
+            },
+            status: "success"
+        });
+        renderObjectLockSettings();
+        await waitFor(()=>{
+            expect(screen.getByText("Default Retention")).toBeInTheDocument();
+        });
+        const defaultRetentionCheckbox = screen.getByLabelText(/default retention/i);
+        expect(defaultRetentionCheckbox).not.toBeChecked();
+        fireEvent.click(defaultRetentionCheckbox);
+        await waitFor(()=>{
+            const governanceRadio = screen.getByLabelText(/governance/i);
+            expect(governanceRadio).not.toBeDisabled();
+        }, {
+            timeout: 3000
+        });
+    });
+    it("disables retention fields when Default Retention is unchecked", async ()=>{
+        mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+            data: {
+                ObjectLockConfiguration: {
+                    ObjectLockEnabled: "Enabled",
+                    Rule: {
+                        DefaultRetention: {
+                            Mode: "GOVERNANCE",
+                            Days: 30
+                        }
+                    }
+                }
+            },
+            status: "success"
+        });
+        renderObjectLockSettings();
+        await waitFor(()=>{
+            const defaultRetentionCheckbox = screen.getByLabelText(/default retention/i);
+            fireEvent.click(defaultRetentionCheckbox);
+        });
+        await waitFor(()=>{
+            const governanceRadio = screen.getByLabelText(/governance/i);
+            expect(governanceRadio).toBeDisabled();
+        });
+    });
+    it("shows validation error when retention period is invalid", async ()=>{
+        mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+            data: {
+                ObjectLockConfiguration: {
+                    ObjectLockEnabled: "Enabled"
+                }
+            },
+            status: "success"
+        });
+        renderObjectLockSettings();
+        await waitFor(()=>{
+            expect(screen.getByText("Default Retention")).toBeInTheDocument();
+        });
+        const defaultRetentionCheckbox = screen.getByLabelText(/default retention/i);
+        fireEvent.click(defaultRetentionCheckbox);
+        await waitFor(()=>{
+            const retentionPeriodInput = screen.getByLabelText(/retention period/i);
+            expect(retentionPeriodInput).toBeInTheDocument();
+        });
+        const retentionPeriodInput = screen.getByLabelText(/retention period/i);
+        await user_event.clear(retentionPeriodInput);
+        await user_event.type(retentionPeriodInput, "0");
+        await waitFor(()=>{
+            const saveButton = screen.getByRole("button", {
+                name: /save/i
+            });
+            expect(saveButton).toBeDisabled();
+        }, {
+            timeout: 3000
+        });
+    });
+    it("saves Object Lock configuration with Default Retention and navigates on success", async ()=>{
+        mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+            data: {
+                ObjectLockConfiguration: {
+                    ObjectLockEnabled: "Enabled"
+                }
+            },
+            status: "success"
+        });
+        renderObjectLockSettings();
+        await waitFor(()=>{
+            expect(screen.getByText("Default Retention")).toBeInTheDocument();
+        });
+        const defaultRetentionCheckbox = screen.getByLabelText(/default retention/i);
+        fireEvent.click(defaultRetentionCheckbox);
+        await waitFor(()=>{
+            const retentionPeriodInput = screen.getByLabelText(/retention period/i);
+            expect(retentionPeriodInput).toBeInTheDocument();
+        });
+        const retentionPeriodInput = screen.getByLabelText(/retention period/i);
+        await user_event.clear(retentionPeriodInput);
+        await user_event.type(retentionPeriodInput, "30");
+        const governanceRadio = screen.getByLabelText(/governance/i);
+        fireEvent.click(governanceRadio);
+        mockMutate.mockImplementation((_, options)=>{
+            options?.onSuccess?.();
+        });
+        const saveButton = screen.getByRole("button", {
+            name: /save/i
+        });
+        await waitFor(()=>expect(saveButton).toBeEnabled(), {
+            timeout: 3000
+        });
+        fireEvent.click(saveButton);
+        await waitFor(()=>{
+            expect(mockMutate).toHaveBeenCalled();
+            const callArgs = mockMutate.mock.calls[0][0];
+            expect(callArgs.Bucket).toBe("test-bucket");
+            expect(callArgs.ObjectLockConfiguration.ObjectLockEnabled).toBe("Enabled");
+            expect(callArgs.ObjectLockConfiguration.Rule.DefaultRetention.Mode).toBe("GOVERNANCE");
+            expect(callArgs.ObjectLockConfiguration.Rule.DefaultRetention.Days || callArgs.ObjectLockConfiguration.Rule.DefaultRetention.Years).toBe(30);
+            expect(mockNavigate).toHaveBeenCalledWith("/buckets/test-bucket");
+        });
+    });
+    it("saves Object Lock configuration with Years frequency", async ()=>{
+        mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+            data: {
+                ObjectLockConfiguration: {
+                    ObjectLockEnabled: "Enabled"
+                }
+            },
+            status: "success"
+        });
+        renderObjectLockSettings();
+        await waitFor(()=>{
+            expect(screen.getByText("Default Retention")).toBeInTheDocument();
+        });
+        const defaultRetentionCheckbox = screen.getByLabelText(/default retention/i);
+        fireEvent.click(defaultRetentionCheckbox);
+        await waitFor(()=>{
+            const retentionPeriodInput = screen.getByLabelText(/retention period/i);
+            expect(retentionPeriodInput).toBeInTheDocument();
+        });
+        const retentionPeriodInput = screen.getByLabelText(/retention period/i);
+        await user_event.clear(retentionPeriodInput);
+        await user_event.type(retentionPeriodInput, "2");
+        mockMutate.mockImplementation((_, options)=>{
+            options?.onSuccess?.();
+        });
+        const saveButton = screen.getByRole("button", {
+            name: /save/i
+        });
+        await waitFor(()=>expect(saveButton).toBeEnabled(), {
+            timeout: 3000
+        });
+        fireEvent.click(saveButton);
+        await waitFor(()=>{
+            expect(mockMutate).toHaveBeenCalled();
+            const callArgs = mockMutate.mock.calls[0][0];
+            expect(callArgs.Bucket).toBe("test-bucket");
+            expect(callArgs.ObjectLockConfiguration.ObjectLockEnabled).toBe("Enabled");
+            expect(callArgs.ObjectLockConfiguration.Rule.DefaultRetention.Mode).toBe("GOVERNANCE");
+            expect(callArgs.ObjectLockConfiguration.Rule.DefaultRetention.Days || callArgs.ObjectLockConfiguration.Rule.DefaultRetention.Years).toBe(2);
+        });
+    });
+    it("saves Object Lock configuration without Default Retention", async ()=>{
+        mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+            data: {
+                ObjectLockConfiguration: {
+                    ObjectLockEnabled: "Enabled"
+                }
+            },
+            status: "success"
+        });
+        renderObjectLockSettings();
+        await waitFor(()=>{
+            const saveButton = screen.getByRole("button", {
+                name: /save/i
+            });
+            expect(saveButton).toBeEnabled();
+        }, {
+            timeout: 3000
+        });
+        mockMutate.mockImplementation((_, options)=>{
+            options?.onSuccess?.();
+        });
+        const saveButton = screen.getByRole("button", {
+            name: /save/i
+        });
+        fireEvent.click(saveButton);
+        await waitFor(()=>{
+            expect(mockMutate).toHaveBeenCalled();
+            const callArgs = mockMutate.mock.calls[0][0];
+            expect(callArgs.Bucket).toBe("test-bucket");
+            expect(callArgs.ObjectLockConfiguration.ObjectLockEnabled).toBe("Enabled");
+            expect(callArgs.ObjectLockConfiguration.Rule).toBeUndefined();
+        });
+    });
+    it("displays error toast when save fails", async ()=>{
+        mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+            data: {
+                ObjectLockConfiguration: {
+                    ObjectLockEnabled: "Enabled"
+                }
+            },
+            status: "success"
+        });
+        renderObjectLockSettings();
+        await waitFor(()=>{
+            const saveButton = screen.getByRole("button", {
+                name: /save/i
+            });
+            expect(saveButton).toBeEnabled();
+        }, {
+            timeout: 3000
+        });
+        const error = new Error("Access Denied");
+        mockMutate.mockImplementation((_, options)=>{
+            options?.onError?.(error);
+        });
+        const saveButton = screen.getByRole("button", {
+            name: /save/i
+        });
+        fireEvent.click(saveButton);
+        await waitFor(()=>{
+            expect(mockNavigate).not.toHaveBeenCalled();
+        });
+    });
+    it("navigates back when cancel button is clicked", async ()=>{
+        renderObjectLockSettings();
+        await waitFor(()=>{
+            const cancelButton = screen.getByRole("button", {
+                name: /cancel/i
+            });
+            fireEvent.click(cancelButton);
+        });
+        expect(mockNavigate).toHaveBeenCalledWith("/buckets/test-bucket");
+    });
+    it("populates form with existing bucket configuration", async ()=>{
+        mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+            data: {
+                ObjectLockConfiguration: {
+                    ObjectLockEnabled: "Enabled",
+                    Rule: {
+                        DefaultRetention: {
+                            Mode: "COMPLIANCE",
+                            Days: 60
+                        }
+                    }
+                }
+            },
+            status: "success"
+        });
+        renderObjectLockSettings();
+        await waitFor(()=>{
+            const objectLockCheckbox = screen.getByLabelText(/object-lock/i);
+            expect(objectLockCheckbox).toBeChecked();
+        });
+        const defaultRetentionCheckbox = screen.getByLabelText(/default retention/i);
+        expect(defaultRetentionCheckbox).toBeChecked();
+        const complianceRadio = screen.getByLabelText(/compliance/i);
+        expect(complianceRadio).toBeChecked();
+        const retentionPeriodInput = screen.getByLabelText(/retention period/i);
+        expect(retentionPeriodInput).toHaveValue(60);
+    });
+});

package/dist/components/ui/ArrayFieldActions.d.ts

@@ -0,0 +1,36 @@
+export type ArrayFieldActionsProps = {
+    /**
+     * Callback when remove button is clicked
+     */
+    onRemove: () => void;
+    /**
+     * Callback when add button is clicked
+     * Only called if showAdd is true
+     */
+    onAdd: () => void;
+    /**
+     * Whether the remove button should be enabled
+     */
+    canRemove: boolean;
+    /**
+     * Whether the add button should be enabled
+     * @default true
+     */
+    canAdd?: boolean;
+    /**
+     * Whether to show the add button
+     * Typically true only for the last item in the array
+     */
+    showAdd: boolean;
+    /**
+     * Aria label for remove button
+     * @default "Remove"
+     */
+    removeLabel?: string;
+    /**
+     * Aria label for add button
+     * @default "Add"
+     */
+    addLabel?: string;
+};
+export declare function ArrayFieldActions({ onRemove, onAdd, canRemove, canAdd, showAdd, removeLabel, addLabel, }: ArrayFieldActionsProps): import("react/jsx-runtime").JSX.Element;